Enhance smoking tracking features with AI next smoke time suggestions

- Added new API endpoint `GET /api/v1/smoke/next_smoke_time` to provide AI-generated suggestions for the next smoking time based on user data.
- Introduced a new database table `fa_smoke_ai_next_smoke` to store structured AI time node suggestions.
- Updated smoke handler and service to integrate the new AI next smoke time functionality.
- Enhanced documentation to reflect the new API endpoint and its usage, including details on how to generate AI time nodes.

cmd/api/main.go

@@ -52,6 +52,7 @@ func main() {
 		&smokemodel.SmokeUserProfile{},
 		&smokemodel.SmokeAIAdvice{},
 		&smokemodel.SmokeAIAdviceUnlock{},
+		&smokemodel.SmokeAINextSmoke{},
 	); err != nil {
 		log.Fatalf("auto migrate failed: %v", err)
 	}
@@ -73,7 +74,9 @@ func main() {
 	smokeLogService := smokeservice.NewSmokeLogService(database.DB)
 	smokeAIAdviceService := smokeservice.NewSmokeAIAdviceService(database.DB, config.AppConfig.AI)
 	smokeProfileService := smokeservice.NewSmokeProfileService(database.DB)
-	smokeHandler := smokehandler.NewSmokeHandler(smokeLogService, smokeAIAdviceService, smokeProfileService)
+	smokeNextService := smokeservice.NewSmokeNextService(database.DB)
+	smokeAINextService := smokeservice.NewSmokeAINextSmokeService(database.DB, config.AppConfig.AI)
+	smokeHandler := smokehandler.NewSmokeHandler(smokeLogService, smokeAIAdviceService, smokeProfileService, smokeNextService, smokeAINextService)
 
 	redeemCodeService := membershipservice.NewRedeemCodeService(database.DB, config.AppConfig.Admin.Token)
 	redeemCodeHandler := membershiphandler.NewRedeemCodeHandler(redeemCodeService)

docs/smoke/API.md

@@ -22,7 +22,8 @@
 说明：
 - `smoke_time` 可选；不传则默认“当天”。
 - `smoke_at` 可选；真实抽烟时间（格式 `YYYY-MM-DD HH:MM:SS`）。用于“按时间节点分析/AI 建议”；不传则可用 `createtime` 近似。
-- `level/num` 可选；不传或传 `<=0` 时会按 `1` 处理。
+- `level/num` 可选；不传时后端会按 `1` 处理。
+- 如果要记录“想抽但忍住了”，请传 `level=0` 且 `num=0`（会在 `fa_smoke_log` 中展示为一条记录，但不会影响看板的支数累加）。
 
 curl 示例：
 
@@ -120,7 +121,7 @@ curl -X GET 'http://127.0.0.1:8080/api/v1/smoke/logs/5202' \
 
 字段说明：
 - `today_count`：当天吸烟总支数（累加 `num`）
-- `minutes_since_last`：距最后一次抽烟的分钟数，通过最近一条 `smoke_at/smoke_time/createtime` 计算；若历史为空则字段不存在
+- `minutes_since_last`：距最后一次“实际抽烟”（忽略 `level=0 && num=0` 的忍住记录）的分钟数，通过最近一条 `smoke_at/smoke_time/createtime` 计算；若历史为空则字段不存在
 - `weekly`：起止日期内每日汇总，`count` 为当日总支数，`is_today` 标记当前日期（即便不在 `start/end` 范围内也会标记为 `false`）
 
 ## 5) 最近记录列表（轻量版）
@@ -237,6 +238,8 @@ curl -X GET 'http://127.0.0.1:8080/api/v1/smoke/logs/5202' \
 说明：
 - 该接口用于记录“已完成观看广告”，落库到 `fa_smoke_ai_advice_unlocks`（`uid + unlock_date` 唯一）。
 - `ad_watched_at` 可由后端取当前时间；如需审计/对账可保留前端上报并做校验。
+- 解锁是“按天”的：观看一次广告解锁一天内的 AI 生成功能（可用于「每日 AI 建议」以及「AI 下次抽烟时间节点」）。
+- 如果你要生成“明天”的 AI 时间节点，请把 `date` 传为明天日期（例如 `2026-01-06`）。
 
 ## 10) 获取用户基础信息（首次进入：判断是否需要补全）
 
@@ -321,3 +324,93 @@ curl -X GET 'http://127.0.0.1:8080/api/v1/smoke/logs/5202' \
 ```
 
 成功响应：同 `GET /api/v1/smoke/profile`（返回最新 `profile` + `is_completed` + `baseline_interval_minutes`）。
+
+## 12) 想抽但忍住了（写入一条 level=0,num=0 的记录）
+
+`POST /api/v1/smoke/logs/resisted`
+
+请求体（示例）：
+```json
+{
+  "smoke_time": "2026-01-05",
+  "smoke_at": "2026-01-05 10:20:00",
+  "remark": "压力大，想抽但忍住了"
+}
+```
+
+说明：
+- 该接口会在 `fa_smoke_log` 中新增一条记录：`level=0` 且 `num=0`，用于更直观记录“想抽/忍住”的过程。
+- 这类记录不会影响 `today_count/weekly.count` 的支数统计（因为 `num=0`）。
+
+## 13) 获取“下次抽烟记录时间”（默认 + AI 自动切换）
+
+`GET /api/v1/smoke/next_smoke_time`
+
+说明：
+- 用于首页展示“建议的下次记录时间”。
+- 如果指定日期存在 AI 给出的时间节点（`time_nodes` 不为空），则优先使用 AI 的建议；否则使用默认策略。
+- 可选参数：
+  - `date`：计划日期（默认今天），支持 `YYYY-MM-DD` 或 `today/tomorrow`。
+  - `mode`（默认 `auto`）
+    - `auto`：只在已存在 AI 时间节点时使用 AI（不主动生成）
+    - `ai`：生成该 `date` 的 AI 时间节点（需要先看广告解锁；生成一次缓存一天）
+    - `default`：永远返回默认策略
+
+默认策略（不使用 AI）：
+- 基础间隔：优先使用 `GET /api/v1/smoke/profile` 返回的 `baseline_interval_minutes`；若不存在则默认 `60` 分钟。
+- 阶梯式延时：最近 7 天内每累计 `5` 条“忍住记录（level=0,num=0）”，在基础间隔上 `+5` 分钟（最多 `+60` 分钟）。
+- 若用户已补全作息时间，会自动规避睡眠区间：若计算出的时间落在睡眠区间，顺延到下一次起床时间。
+
+AI 生成说明：
+- 当 `mode=ai` 时，会把最近 3 天的抽烟数据（含“忍住记录”）作为输入提供给 AI，用于更贴合近期模式生成时间节点。
+- 未解锁时会返回 `403`：提示需要观看广告解锁。
+
+成功响应（示例：回落到默认）：
+```json
+{
+  "code": 200,
+  "message": "success",
+  "data": {
+    "source": "default",
+    "not_before_at": "2026-01-05T10:18:00+08:00",
+    "suggested_at": "2026-01-05T10:18:00+08:00",
+    "default": {
+      "last_smoke_at": "2026-01-05T09:30:00+08:00",
+      "next_smoke_at": "2026-01-05T10:18:00+08:00",
+      "base_interval_minutes": 48,
+      "interval_minutes": 48,
+      "stage": 0,
+      "resisted_7d": 3,
+      "sleep_adjusted": false,
+      "algorithm": "staircase_delay_v1",
+      "as_of": "2026-01-05T10:00:00+08:00"
+    }
+  }
+}
+```
+
+当存在 AI 建议且包含 `time_nodes` 时，响应会是（示例）：
+```json
+{
+  "code": 200,
+  "message": "success",
+  "data": {
+    "source": "ai",
+    "not_before_at": "2026-01-05T10:18:00+08:00",
+    "suggested_at": "2026-01-05T10:28:00+08:00",
+    "time_nodes": ["10:30", "11:10", "14:00", "16:30"],
+    "advice": "先把这次冲动延后到10:28，期间做一次5分钟快走+喝水，压力场景用深呼吸替代。",
+    "default": { "algorithm": "staircase_delay_v1" },
+    "ai": {
+      "plan_date": "2026-01-05",
+      "not_before_at": "2026-01-05T10:18:00+08:00",
+      "suggested_at": "2026-01-05T10:28:00+08:00",
+      "time_nodes": ["10:30", "11:10", "14:00", "16:30"],
+      "advice": "先把这次冲动延后到10:28，期间做一次5分钟快走+喝水，压力场景用深呼吸替代。",
+      "prompt_version": "v1",
+      "model": "gpt-4.1-mini",
+      "provider": "openai-compatible"
+    }
+  }
+}
+```

docs/smoke/README.md

@@ -41,6 +41,7 @@
 涉及表（DDL 见：`docs/sql/smoke.sql`）：
 - `fa_smoke_ai_advice`：按 `uid + advice_date + prompt_version` 缓存建议结果，避免重复调用 AI。
 - `fa_smoke_ai_advice_unlocks`：非会员用户的“每日解锁”记录（按 `uid + unlock_date` 唯一）。
+- `fa_smoke_ai_next_smoke`：保存“AI 下次抽烟时间节点”（每个时间点一条记录），AI 元信息复用 `fa_smoke_ai_advice`（`type=next_smoke_time`）。
 
 建议的权限判断顺序：
 1) 若用户是会员：直接允许生成/获取建议。

docs/sql/smoke.sql

@@ -24,6 +24,7 @@ CREATE TABLE `fa_smoke_log` (
 CREATE TABLE IF NOT EXISTS `fa_smoke_ai_advice` (
   `id` bigint unsigned NOT NULL AUTO_INCREMENT,
   `uid` int(11) NOT NULL COMMENT '用户ID',
+  `type` varchar(30) NOT NULL DEFAULT 'daily_advice' COMMENT '用途类型(daily_advice/next_smoke_time/...)',
   `advice_date` date NOT NULL COMMENT '建议针对的日期（通常=昨天）',
   `prompt_version` varchar(30) NOT NULL DEFAULT 'v1' COMMENT '提示词版本',
   `provider` varchar(30) DEFAULT NULL COMMENT 'AI 提供方（可选）',
@@ -37,7 +38,7 @@ CREATE TABLE IF NOT EXISTS `fa_smoke_ai_advice` (
   `updatetime` int(11) DEFAULT NULL COMMENT '修改时间',
   `deletetime` int(11) DEFAULT NULL COMMENT '删除时间',
   PRIMARY KEY (`id`),
-  UNIQUE KEY `uniq_smoke_ai_advice` (`uid`,`advice_date`,`prompt_version`),
+  UNIQUE KEY `uniq_smoke_ai_advice` (`uid`,`type`,`advice_date`,`prompt_version`),
   KEY `idx_smoke_ai_advice_uid_date` (`uid`,`advice_date`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='每日AI戒烟建议';
 
@@ -77,3 +78,23 @@ CREATE TABLE IF NOT EXISTS `fa_smoke_user_profile` (
   UNIQUE KEY `uniq_smoke_profile_uid` (`uid`),
   KEY `idx_smoke_profile_deleted_at` (`deleted_at`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='戒烟-用户基础信息';
+
+-- AI 下次抽烟时间建议（结构化缓存：当天）
+-- 说明：
+-- - not_before_at：AI 给出的“不早于”时间；suggested_at：AI 建议的下次抽烟时间（>= not_before_at）
+-- - time_nodes：建议时间节点（JSON 数组，例如 ["10:30","11:10","14:00"]）
+CREATE TABLE IF NOT EXISTS `fa_smoke_ai_next_smoke` (
+  `id` bigint unsigned NOT NULL AUTO_INCREMENT,
+  `uid` int(11) NOT NULL COMMENT '用户ID',
+  `plan_date` date NOT NULL COMMENT '计划日期(当天)',
+  `ai_advice_id` bigint unsigned NOT NULL COMMENT '关联AI建议ID(fa_smoke_ai_advice.id)',
+  `node_type` varchar(20) NOT NULL COMMENT '节点类型(not_before/suggested/node)',
+  `node_at` datetime NOT NULL COMMENT '时间点',
+  `createtime` int(11) DEFAULT NULL COMMENT '创建时间',
+  `updatetime` int(11) DEFAULT NULL COMMENT '修改时间',
+  `deletetime` int(11) DEFAULT NULL COMMENT '删除时间',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uniq_smoke_ai_next_node` (`ai_advice_id`,`node_type`,`node_at`),
+  KEY `idx_smoke_ai_next_uid_date` (`uid`,`plan_date`),
+  KEY `idx_smoke_ai_next_advice` (`ai_advice_id`,`node_type`,`node_at`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='AI下次抽烟时间节点';

internal/routes/smoke_routes.go

@@ -14,8 +14,12 @@ func registerSmokeRoutes(protected *gin.RouterGroup, smokeHandler *smokehandler.
 		smoke.GET("/profile", smokeHandler.GetProfile)
 		smoke.PUT("/profile", smokeHandler.UpsertProfile)
 
+		// 不使用 AI 时的默认“下次抽烟时间”建议（阶梯式延时）
+		smoke.GET("/next_smoke_time", smokeHandler.GetNextSmokeTime)
+
 		smoke.GET("/dashboard", smokeHandler.Dashboard)
 		smoke.POST("/logs", smokeHandler.Create)
+		smoke.POST("/logs/resisted", smokeHandler.Resist)
 		smoke.GET("/logs", smokeHandler.List)
 		smoke.GET("/logs/latest", smokeHandler.LatestLogs)
 		smoke.GET("/logs/:id", smokeHandler.Get)
@@ -25,5 +29,8 @@ func registerSmokeRoutes(protected *gin.RouterGroup, smokeHandler *smokehandler.
 		// AI 戒烟建议（会员优先；非会员需看广告解锁）
 		smoke.GET("/ai/advice", smokeHandler.GetAIAdvice)
 		smoke.POST("/ai/advice_unlocks", smokeHandler.UnlockAIAdvice)
+
+		// AI 下次抽烟时间建议（结构化时间节点）
+		smoke.GET("/ai/next_smoke_time", smokeHandler.GetAINextSmokeTime)
 	}
 }

internal/smoke/handler/smoke_ai_next_smoke_handler.go

@@ -0,0 +1,12 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+)
+
+func (h *SmokeHandler) GetAINextSmokeTime(c *gin.Context) {
+	q := c.Request.URL.Query()
+	q.Set("mode", "ai")
+	c.Request.URL.RawQuery = q.Encode()
+	h.GetNextSmokeTime(c)
+}

internal/smoke/handler/smoke_handler.go

@@ -2,6 +2,7 @@ package handler
 
 import (
 	"errors"
+	"io"
 	"net/http"
 	"strconv"
 	"time"
@@ -17,13 +18,23 @@ type SmokeHandler struct {
 	smokeLogService      *smokeservice.SmokeLogService
 	smokeAIAdviceService *smokeservice.SmokeAIAdviceService
 	smokeProfileService  *smokeservice.SmokeProfileService
+	smokeNextService     *smokeservice.SmokeNextService
+	smokeAINextService   *smokeservice.SmokeAINextSmokeService
 }
 
-func NewSmokeHandler(smokeLogService *smokeservice.SmokeLogService, smokeAIAdviceService *smokeservice.SmokeAIAdviceService, smokeProfileService *smokeservice.SmokeProfileService) *SmokeHandler {
+func NewSmokeHandler(
+	smokeLogService *smokeservice.SmokeLogService,
+	smokeAIAdviceService *smokeservice.SmokeAIAdviceService,
+	smokeProfileService *smokeservice.SmokeProfileService,
+	smokeNextService *smokeservice.SmokeNextService,
+	smokeAINextService *smokeservice.SmokeAINextSmokeService,
+) *SmokeHandler {
 	return &SmokeHandler{
 		smokeLogService:      smokeLogService,
 		smokeAIAdviceService: smokeAIAdviceService,
 		smokeProfileService:  smokeProfileService,
+		smokeNextService:     smokeNextService,
+		smokeAINextService:   smokeAINextService,
 	}
 }
 
@@ -37,8 +48,8 @@ type createSmokeLogRequest struct {
 	// 真实抽烟时间（精确到时分秒，可补录）
 	SmokeAt string `json:"smoke_at"`
 	Remark  string `json:"remark"`
-	Level   int64  `json:"level"`
-	Num     int    `json:"num"`
+	Level   *int64 `json:"level"`
+	Num     *int   `json:"num"`
 }
 
 func (h *SmokeHandler) Create(c *gin.Context) {
@@ -54,6 +65,83 @@ func (h *SmokeHandler) Create(c *gin.Context) {
 		return
 	}
 
+	level := int64(1)
+	if req.Level != nil {
+		if *req.Level < 0 {
+			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "level 不能为负数"))
+			return
+		}
+		level = *req.Level
+	}
+	num := 1
+	if req.Num != nil {
+		if *req.Num < 0 {
+			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "num 不能为负数"))
+			return
+		}
+		num = *req.Num
+	}
+
+	if level < 0 || num < 0 {
+		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "level/num 不能为负数"))
+		return
+	}
+
+	var smokeTime *time.Time
+	if req.SmokeTime != "" {
+		parsed, err := time.ParseInLocation(dateLayout, req.SmokeTime, time.Local)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "smoke_time 格式错误，应为 YYYY-MM-DD"))
+			return
+		}
+		smokeTime = &parsed
+	}
+
+	var smokeAt *time.Time
+	if req.SmokeAt != "" {
+		parsed, err := time.ParseInLocation(dateTimeLayout, req.SmokeAt, time.Local)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "smoke_at 格式错误，应为 YYYY-MM-DD HH:MM:SS"))
+			return
+		}
+		smokeAt = &parsed
+	}
+
+	record, err := h.smokeLogService.Create(c.Request.Context(), int(user.ID), smokeservice.CreateSmokeLogRequest{
+		SmokeTime: smokeTime,
+		SmokeAt:   smokeAt,
+		Remark:    req.Remark,
+		Level:     level,
+		Num:       num,
+	})
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "创建记录失败，请稍后重试"))
+		return
+	}
+
+	c.JSON(http.StatusOK, model.Success(record))
+}
+
+type resistedSmokeLogRequest struct {
+	SmokeTime string `json:"smoke_time"`
+	SmokeAt   string `json:"smoke_at"`
+	Remark    string `json:"remark"`
+}
+
+// Resist 表示“想抽但忍住了”：在 fa_smoke_log 中写入 level=0,num=0。
+func (h *SmokeHandler) Resist(c *gin.Context) {
+	user, ok := middleware.CurrentUser(c)
+	if !ok {
+		c.JSON(http.StatusUnauthorized, model.Error(http.StatusUnauthorized, "未登录或登录已过期"))
+		return
+	}
+
+	var req resistedSmokeLogRequest
+	if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
+		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "请求参数错误"))
+		return
+	}
+
 	var smokeTime *time.Time
 	if req.SmokeTime != "" {
 		parsed, err := time.ParseInLocation(dateLayout, req.SmokeTime, time.Local)
@@ -78,8 +166,8 @@ func (h *SmokeHandler) Create(c *gin.Context) {
 		SmokeTime: smokeTime,
 		SmokeAt:   smokeAt,
 		Remark:    req.Remark,
-		Level:     req.Level,
-		Num:       req.Num,
+		Level:     0,
+		Num:       0,
 	})
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "创建记录失败，请稍后重试"))
@@ -271,6 +359,15 @@ func (h *SmokeHandler) Update(c *gin.Context) {
 		return
 	}
 
+	if req.Level != nil && *req.Level < 0 {
+		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "level 不能为负数"))
+		return
+	}
+	if req.Num != nil && *req.Num < 0 {
+		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "num 不能为负数"))
+		return
+	}
+
 	smokeTimeProvided := req.SmokeTime != nil
 	var smokeTime *time.Time
 	if req.SmokeTime != nil {

internal/smoke/handler/smoke_next_handler.go

@@ -0,0 +1,140 @@
+package handler
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+
+	"wx_service/internal/middleware"
+	"wx_service/internal/model"
+	smokeservice "wx_service/internal/smoke/service"
+)
+
+type nextSmokeTimeUnifiedResponse struct {
+	Source      string                          `json:"source"`
+	NotBeforeAt string                          `json:"not_before_at"`
+	SuggestedAt string                          `json:"suggested_at"`
+	TimeNodes   []string                        `json:"time_nodes,omitempty"`
+	Advice      string                          `json:"advice,omitempty"`
+	Default     smokeservice.NextSmokeSuggestion `json:"default"`
+	AI          *smokeservice.AINextSmokeSuggestion `json:"ai,omitempty"`
+}
+
+func (h *SmokeHandler) GetNextSmokeTime(c *gin.Context) {
+	user, ok := middleware.CurrentUser(c)
+	if !ok {
+		c.JSON(http.StatusUnauthorized, model.Error(http.StatusUnauthorized, "未登录或登录已过期"))
+		return
+	}
+
+	asOf := time.Now().In(time.Local)
+	planDate := dateOnlyLocal(asOf)
+	if v := strings.TrimSpace(c.Query("date")); v != "" {
+		switch strings.ToLower(v) {
+		case "today":
+			planDate = dateOnlyLocal(asOf)
+		case "tomorrow":
+			planDate = dateOnlyLocal(asOf).AddDate(0, 0, 1)
+		default:
+			parsed, err := time.ParseInLocation(dateLayout, v, time.Local)
+			if err != nil {
+				c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "date 格式错误，应为 YYYY-MM-DD 或 today/tomorrow"))
+				return
+			}
+			planDate = parsed
+		}
+	}
+	if planDate.Before(dateOnlyLocal(asOf)) {
+		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "date 不能早于今天"))
+		return
+	}
+
+	view, err := h.smokeProfileService.GetView(c.Request.Context(), int(user.ID))
+	if err != nil {
+		if errors.Is(err, smokeservice.ErrSmokeProfileInvalidTime) {
+			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "作息时间格式错误，应为 HH:MM"))
+			return
+		}
+		c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "获取基础信息失败，请稍后重试"))
+		return
+	}
+
+	defaultSuggestion, err := h.smokeNextService.GetDefaultSuggestion(c.Request.Context(), int(user.ID), asOf, planDate, view)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "计算失败，请稍后重试"))
+		return
+	}
+
+	mode := strings.ToLower(strings.TrimSpace(c.DefaultQuery("mode", "auto")))
+
+	formatPtr := func(t *time.Time) string {
+		if t == nil {
+			return ""
+		}
+		return t.In(time.Local).Format(time.RFC3339)
+	}
+
+	resp := nextSmokeTimeUnifiedResponse{
+		Source:      "default",
+		NotBeforeAt: formatPtr(defaultSuggestion.NextSmokeAt),
+		SuggestedAt: formatPtr(defaultSuggestion.NextSmokeAt),
+		Default:     defaultSuggestion,
+	}
+
+	// mode=default: 永远返回默认建议
+	if mode == "default" {
+		c.JSON(http.StatusOK, model.Success(resp))
+		return
+	}
+
+	// mode=auto: 仅在“已存在 AI 时间节点”时使用 AI（不主动生成）
+	// mode=ai: 尝试生成/刷新 AI，再优先使用 AI；失败则回落到默认
+	var ai smokeservice.AINextSmokeSuggestion
+	var hasAI bool
+
+	if mode == "ai" {
+		v, err := h.smokeAINextService.GetOrGenerate(c.Request.Context(), user, asOf, planDate, "v1", defaultSuggestion)
+		if err != nil {
+			switch {
+			case errors.Is(err, smokeservice.ErrAINextLocked):
+				c.JSON(http.StatusForbidden, model.Error(http.StatusForbidden, "需要观看广告解锁后才可生成"))
+				return
+			case errors.Is(err, smokeservice.ErrAINextServiceDisabled):
+				c.JSON(http.StatusServiceUnavailable, model.Error(http.StatusServiceUnavailable, "AI 服务暂不可用，请联系管理员"))
+				return
+			default:
+				c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "生成 AI 建议失败，请稍后重试"))
+				return
+			}
+		}
+		ai = v
+		hasAI = len(ai.TimeNodes) > 0
+	} else {
+		v, ok, err := h.smokeAINextService.GetCached(c.Request.Context(), user, planDate, "v1")
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "获取 AI 建议失败，请稍后重试"))
+			return
+		}
+		ai = v
+		hasAI = ok && len(ai.TimeNodes) > 0
+	}
+
+	if hasAI {
+		resp.Source = "ai"
+		resp.NotBeforeAt = ai.NotBeforeAt
+		resp.SuggestedAt = ai.SuggestedAt
+		resp.TimeNodes = ai.TimeNodes
+		resp.Advice = ai.Advice
+		resp.AI = &ai
+	}
+
+	c.JSON(http.StatusOK, model.Success(resp))
+}
+
+func dateOnlyLocal(t time.Time) time.Time {
+	local := t.In(time.Local)
+	return time.Date(local.Year(), local.Month(), local.Day(), 0, 0, 0, 0, time.Local)
+}

internal/smoke/model/smoke_ai.go

@@ -9,8 +9,11 @@ type SmokeAIAdvice struct {
 	ID  uint `gorm:"primaryKey;autoIncrement;comment:记录ID" json:"id"`
 	UID int `gorm:"column:uid;index:idx_smoke_ai_advice_uid_date,priority:1;uniqueIndex:uniq_smoke_ai_advice,priority:1" json:"-"`
 
-	AdviceDate    time.Time `gorm:"column:advice_date;type:date;index:idx_smoke_ai_advice_uid_date,priority:2;uniqueIndex:uniq_smoke_ai_advice,priority:2;comment:建议日期" json:"advice_date"`
-	PromptVersion string    `gorm:"column:prompt_version;size:30;default:v1;uniqueIndex:uniq_smoke_ai_advice,priority:3;comment:提示词版本" json:"prompt_version"`
+	// Type 用于区分 AI 使用场景（例如：daily_advice / next_smoke_time）。
+	Type string `gorm:"column:type;size:30;default:daily_advice;index:idx_smoke_ai_advice_uid_date,priority:2;uniqueIndex:uniq_smoke_ai_advice,priority:2;comment:用途类型" json:"type"`
+
+	AdviceDate    time.Time `gorm:"column:advice_date;type:date;index:idx_smoke_ai_advice_uid_date,priority:3;uniqueIndex:uniq_smoke_ai_advice,priority:3;comment:建议日期" json:"advice_date"`
+	PromptVersion string    `gorm:"column:prompt_version;size:30;default:v1;uniqueIndex:uniq_smoke_ai_advice,priority:4;comment:提示词版本" json:"prompt_version"`
 
 	Provider string `gorm:"column:provider;size:30;comment:AI提供方" json:"provider,omitempty"`
 	Model    string `gorm:"column:model;size:60;comment:模型名" json:"model,omitempty"`

internal/smoke/model/smoke_ai_next_smoke.go

@@ -0,0 +1,32 @@
+package model
+
+import "time"
+
+// SmokeAINextSmoke 对应表 fa_smoke_ai_next_smoke（AI 生成的“下次抽烟时间节点”）。
+//
+// 说明：
+// - 该表只保存“时间节点”本身（每个时间点一条记录），AI 元信息复用 fa_smoke_ai_advice（通过 AIAdviceID 关联）。
+// - 沿用旧系统字段（createtime/updatetime/deletetime 为秒级时间戳），不使用 gorm.Model。
+type SmokeAINextSmoke struct {
+	ID  uint `gorm:"primaryKey;autoIncrement;comment:记录ID" json:"id"`
+	UID int  `gorm:"column:uid;index:idx_smoke_ai_next_uid_date,priority:1;comment:用户ID" json:"-"`
+
+	PlanDate   time.Time `gorm:"column:plan_date;type:date;index:idx_smoke_ai_next_uid_date,priority:2;comment:计划日期(当天)" json:"plan_date"`
+	AIAdviceID uint      `gorm:"column:ai_advice_id;index:idx_smoke_ai_next_advice,priority:1;comment:关联AI建议ID(fa_smoke_ai_advice.id)" json:"ai_advice_id"`
+
+	// NodeType: not_before / suggested / node
+	NodeType string    `gorm:"column:node_type;size:20;index:idx_smoke_ai_next_advice,priority:2;uniqueIndex:uniq_smoke_ai_next_node,priority:2;comment:节点类型" json:"node_type"`
+	NodeAt   time.Time `gorm:"column:node_at;type:datetime;uniqueIndex:uniq_smoke_ai_next_node,priority:3;comment:时间点" json:"node_at"`
+
+	CreateTime *int64 `gorm:"column:createtime;comment:创建时间(秒)" json:"createtime,omitempty"`
+	UpdateTime *int64 `gorm:"column:updatetime;comment:更新时间(秒)" json:"updatetime,omitempty"`
+	DeleteTime *int64 `gorm:"column:deletetime;comment:删除时间(秒)" json:"deletetime,omitempty"`
+}
+
+func (SmokeAINextSmoke) TableName() string {
+	return "fa_smoke_ai_next_smoke"
+}
+
+func (SmokeAINextSmoke) TableComment() string {
+	return "AI下次抽烟时间节点"
+}

internal/smoke/service/smoke_ai_advice_service.go

@@ -30,6 +30,11 @@ const (
 	defaultTemperature         = 0.7
 )
 
+const (
+	SmokeAIAdviceTypeDaily      = "daily_advice"
+	SmokeAIAdviceTypeNextSmoke  = "next_smoke_time"
+)
+
 type SmokeAIAdviceService struct {
 	db     *gorm.DB
 	cfg    config.AIConfig
@@ -82,7 +87,7 @@ func (s *SmokeAIAdviceService) GetOrGenerate(ctx context.Context, user *usermode
 		promptVersion = DefaultAdvicePromptVersion
 	}
 
-	cached, err := s.getCached(ctx, int(user.ID), adviceDate, promptVersion)
+	cached, err := s.getCached(ctx, int(user.ID), SmokeAIAdviceTypeDaily, adviceDate, promptVersion)
 	if err != nil {
 		return nil, err
 	}
@@ -114,6 +119,7 @@ func (s *SmokeAIAdviceService) GetOrGenerate(ctx context.Context, user *usermode
 
 	record := smokemodel.SmokeAIAdvice{
 		UID:           int(user.ID),
+		Type:          SmokeAIAdviceTypeDaily,
 		AdviceDate:    dateOnly(adviceDate),
 		PromptVersion: promptVersion,
 		Provider:      "openai-compatible",
@@ -166,11 +172,11 @@ func (s *SmokeAIAdviceService) Unlock(ctx context.Context, user *usermodel.User,
 	return nil
 }
 
-func (s *SmokeAIAdviceService) getCached(ctx context.Context, uid int, adviceDate time.Time, promptVersion string) (*smokemodel.SmokeAIAdvice, error) {
+func (s *SmokeAIAdviceService) getCached(ctx context.Context, uid int, adviceType string, adviceDate time.Time, promptVersion string) (*smokemodel.SmokeAIAdvice, error) {
 	var record smokemodel.SmokeAIAdvice
 	err := s.db.WithContext(ctx).
-		Where("uid = ? AND advice_date = ? AND prompt_version = ? AND (deletetime IS NULL OR deletetime = 0)",
-			uid, dateOnly(adviceDate).Format("2006-01-02"), promptVersion).
+		Where("uid = ? AND type = ? AND advice_date = ? AND prompt_version = ? AND (deletetime IS NULL OR deletetime = 0)",
+			uid, adviceType, dateOnly(adviceDate).Format("2006-01-02"), promptVersion).
 		First(&record).Error
 	if err == nil {
 		return &record, nil
@@ -231,7 +237,7 @@ func (s *SmokeAIAdviceService) buildSnapshot(ctx context.Context, uid int, advic
 		return adviceSnapshot{}, nil, ErrNoSmokeLogs
 	}
 
-	profile := s.loadAdviceProfile(ctx, uid)
+	profile := loadAdviceUserProfile(ctx, s.db, uid)
 
 	type timedLog struct {
 		log      smokemodel.SmokeLog
@@ -299,9 +305,9 @@ func (s *SmokeAIAdviceService) buildSnapshot(ctx context.Context, uid int, advic
 	return snap, b, nil
 }
 
-func (s *SmokeAIAdviceService) loadAdviceProfile(ctx context.Context, uid int) *adviceUserProfile {
+func loadAdviceUserProfile(ctx context.Context, db *gorm.DB, uid int) *adviceUserProfile {
 	var profile smokemodel.SmokeUserProfile
-	err := s.db.WithContext(ctx).
+	err := db.WithContext(ctx).
 		Where("uid = ? AND deleted_at IS NULL", uid).
 		First(&profile).Error
 	if err != nil {

internal/smoke/service/smoke_ai_next_smoke_service.go

@@ -0,0 +1,666 @@
+package service
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"gorm.io/gorm"
+
+	"wx_service/config"
+	usermodel "wx_service/internal/model"
+	smokemodel "wx_service/internal/smoke/model"
+)
+
+var (
+	ErrAINextServiceDisabled = errors.New("ai service is not configured")
+	ErrAINextLocked          = errors.New("ai next smoke is locked, ad unlock required")
+)
+
+type SmokeAINextSmokeService struct {
+	db     *gorm.DB
+	cfg    config.AIConfig
+	client *http.Client
+}
+
+func NewSmokeAINextSmokeService(db *gorm.DB, cfg config.AIConfig) *SmokeAINextSmokeService {
+	timeout := cfg.RequestTimeout
+	if timeout <= 0 {
+		timeout = 15 * time.Second
+	}
+	return &SmokeAINextSmokeService{
+		db:  db,
+		cfg: cfg,
+		client: &http.Client{
+			Timeout: timeout,
+		},
+	}
+}
+
+type aiNextSmokeInput struct {
+	AsOf             string              `json:"as_of"`
+	PlanDate         string              `json:"plan_date"`
+	MinNotBeforeAt   string              `json:"min_not_before_at"`
+	DefaultSuggestion NextSmokeSuggestion `json:"default_suggestion"`
+	Profile          *adviceUserProfile   `json:"profile,omitempty"`
+	Recent3Days      []recentDaySnapshot  `json:"recent_3_days"`
+}
+
+type aiNextSmokeOutput struct {
+	NotBeforeAt string   `json:"not_before_at"`
+	SuggestedAt string   `json:"suggested_at"`
+	TimeNodes   []string `json:"time_nodes"`
+	Advice      string   `json:"advice"`
+}
+
+type recentDaySnapshot struct {
+	Date          string          `json:"date"`
+	TotalNum      int             `json:"total_num"`
+	ResistedCount int             `json:"resisted_count"`
+	Nodes         []recentDayNode `json:"nodes"`
+}
+
+type recentDayNode struct {
+	Time       string `json:"time"`
+	Num        int    `json:"num"`
+	Level      int64  `json:"level"`
+	IsResisted bool   `json:"is_resisted"`
+	Remark     string `json:"remark,omitempty"`
+}
+
+type AINextSmokeSuggestion struct {
+	PlanDate     string   `json:"plan_date"`
+	NotBeforeAt  string   `json:"not_before_at"`
+	SuggestedAt  string   `json:"suggested_at"`
+	TimeNodes    []string `json:"time_nodes"`
+	Advice       string   `json:"advice"`
+	PromptVersion string  `json:"prompt_version"`
+	Model        string   `json:"model,omitempty"`
+	Provider     string   `json:"provider,omitempty"`
+}
+
+func (s *SmokeAINextSmokeService) GetOrGenerate(ctx context.Context, user *usermodel.User, asOf time.Time, planDate time.Time, promptVersion string, defaultSuggestion NextSmokeSuggestion) (AINextSmokeSuggestion, error) {
+	if promptVersion == "" {
+		promptVersion = "v1"
+	}
+
+	planDate = dateOnly(planDate)
+	cachedAdvice, err := s.getCachedAdvice(ctx, int(user.ID), planDate, promptVersion)
+	if err != nil {
+		return AINextSmokeSuggestion{}, err
+	}
+	if cachedAdvice != nil {
+		return s.buildFromCache(ctx, cachedAdvice)
+	}
+
+	if s.cfg.APIKey == "" || s.cfg.Model == "" || s.cfg.BaseURL == "" {
+		return AINextSmokeSuggestion{}, ErrAINextServiceDisabled
+	}
+
+	allowed, err := s.isAllowed(ctx, user, planDate)
+	if err != nil {
+		return AINextSmokeSuggestion{}, err
+	}
+	if !allowed {
+		return AINextSmokeSuggestion{}, ErrAINextLocked
+	}
+
+	// 尝试复用 profile（用于 sleep window / 动机动力）；如果读取失败则忽略。
+	profile := loadAdviceUserProfile(ctx, s.db, int(user.ID))
+
+	recent, err := s.loadRecent3Days(ctx, int(user.ID), planDate)
+	if err != nil {
+		return AINextSmokeSuggestion{}, err
+	}
+
+	minNotBefore := s.computeMinNotBefore(asOf, planDate, defaultSuggestion, profile)
+
+	input := aiNextSmokeInput{
+		AsOf:               asOf.In(time.Local).Format(time.RFC3339),
+		PlanDate:           planDate.Format("2006-01-02"),
+		MinNotBeforeAt:     minNotBefore.In(time.Local).Format(time.RFC3339),
+		DefaultSuggestion:  defaultSuggestion,
+		Profile:            profile,
+		Recent3Days:        recent,
+	}
+	inputJSON, _ := json.Marshal(input)
+
+	output, outputJSON, modelName, tokensIn, tokensOut, err := s.callAI(ctx, input)
+	if err != nil {
+		return AINextSmokeSuggestion{}, err
+	}
+
+	notBeforeAt, err := parseFlexibleTime(output.NotBeforeAt, planDate)
+	if err != nil {
+		return AINextSmokeSuggestion{}, fmt.Errorf("parse not_before_at: %w", err)
+	}
+	suggestedAt, err := parseFlexibleTime(output.SuggestedAt, planDate)
+	if err != nil {
+		return AINextSmokeSuggestion{}, fmt.Errorf("parse suggested_at: %w", err)
+	}
+
+	// 强制：AI 的“不早于”不可以早于 minNotBefore（避免比默认更激进，且支持明天计划）。
+	if notBeforeAt.Before(minNotBefore) {
+		notBeforeAt = minNotBefore
+	}
+	if suggestedAt.Before(notBeforeAt) {
+		suggestedAt = notBeforeAt
+	}
+
+	// 避免睡眠时间：若 profile 有作息，则把 not_before/suggested 落在睡眠区间的情况顺延到起床。
+	if profile != nil && strings.TrimSpace(profile.WakeUpTime) != "" && strings.TrimSpace(profile.SleepTime) != "" {
+		if adjusted, ok, _ := adjustToWakeIfInSleep(notBeforeAt, profile.WakeUpTime, profile.SleepTime); ok {
+			notBeforeAt = adjusted
+		}
+		if adjusted, ok, _ := adjustToWakeIfInSleep(suggestedAt, profile.WakeUpTime, profile.SleepTime); ok {
+			suggestedAt = adjusted
+		}
+		if suggestedAt.Before(notBeforeAt) {
+			suggestedAt = notBeforeAt
+		}
+	}
+
+	nowUnix := time.Now().Unix()
+	createTime := nowUnix
+	updateTime := nowUnix
+
+	// 1) 写入 AI 元信息与建议（复用 fa_smoke_ai_advice + type 区分）
+	adviceRecord := smokemodel.SmokeAIAdvice{
+		UID:           int(user.ID),
+		Type:          SmokeAIAdviceTypeNextSmoke,
+		AdviceDate:    planDate,
+		PromptVersion: promptVersion,
+		Provider:      "openai-compatible",
+		Model:         modelName,
+		InputSnapshot: inputJSON,
+		Advice:        strings.TrimSpace(output.Advice),
+		TokensIn:      tokensIn,
+		TokensOut:     tokensOut,
+		CreateTime:    &createTime,
+		UpdateTime:    &updateTime,
+	}
+
+	if err := s.db.WithContext(ctx).Create(&adviceRecord).Error; err != nil {
+		return AINextSmokeSuggestion{}, fmt.Errorf("save ai next smoke advice: %w", err)
+	}
+
+	// 2) 写入时间节点（每个时间点一条）
+	nodes, err := s.normalizeNodes(output.TimeNodes, asOf, planDate, notBeforeAt, profile)
+	if err != nil {
+		return AINextSmokeSuggestion{}, err
+	}
+
+	if err := s.saveNodes(ctx, int(user.ID), planDate, adviceRecord.ID, notBeforeAt, suggestedAt, nodes); err != nil {
+		return AINextSmokeSuggestion{}, err
+	}
+
+	_ = outputJSON
+	return AINextSmokeSuggestion{
+		PlanDate:      planDate.Format("2006-01-02"),
+		NotBeforeAt:   notBeforeAt.In(time.Local).Format(time.RFC3339),
+		SuggestedAt:   suggestedAt.In(time.Local).Format(time.RFC3339),
+		TimeNodes:     nodes,
+		Advice:        adviceRecord.Advice,
+		PromptVersion: adviceRecord.PromptVersion,
+		Model:         adviceRecord.Model,
+		Provider:      adviceRecord.Provider,
+	}, nil
+}
+
+func (s *SmokeAINextSmokeService) GetCached(ctx context.Context, user *usermodel.User, planDate time.Time, promptVersion string) (AINextSmokeSuggestion, bool, error) {
+	if promptVersion == "" {
+		promptVersion = "v1"
+	}
+
+	planDate = dateOnly(planDate)
+	cachedAdvice, err := s.getCachedAdvice(ctx, int(user.ID), planDate, promptVersion)
+	if err != nil {
+		return AINextSmokeSuggestion{}, false, err
+	}
+	if cachedAdvice == nil {
+		return AINextSmokeSuggestion{}, false, nil
+	}
+
+	suggestion, err := s.buildFromCache(ctx, cachedAdvice)
+	if err != nil {
+		return AINextSmokeSuggestion{}, false, err
+	}
+	return suggestion, true, nil
+}
+
+func (s *SmokeAINextSmokeService) getCachedAdvice(ctx context.Context, uid int, planDate time.Time, promptVersion string) (*smokemodel.SmokeAIAdvice, error) {
+	var record smokemodel.SmokeAIAdvice
+	err := s.db.WithContext(ctx).
+		Where("uid = ? AND type = ? AND advice_date = ? AND prompt_version = ? AND (deletetime IS NULL OR deletetime = 0)",
+			uid, SmokeAIAdviceTypeNextSmoke, dateOnly(planDate).Format("2006-01-02"), promptVersion).
+		First(&record).Error
+	if err == nil {
+		return &record, nil
+	}
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, nil
+	}
+	return nil, fmt.Errorf("load cached ai next smoke advice: %w", err)
+}
+
+func (s *SmokeAINextSmokeService) buildFromCache(ctx context.Context, advice *smokemodel.SmokeAIAdvice) (AINextSmokeSuggestion, error) {
+	nodes, notBeforeAt, suggestedAt, err := s.loadNodes(ctx, advice.ID)
+	if err != nil {
+		return AINextSmokeSuggestion{}, err
+	}
+	return AINextSmokeSuggestion{
+		PlanDate:      dateOnly(advice.AdviceDate).Format("2006-01-02"),
+		NotBeforeAt:   notBeforeAt.In(time.Local).Format(time.RFC3339),
+		SuggestedAt:   suggestedAt.In(time.Local).Format(time.RFC3339),
+		TimeNodes:     nodes,
+		Advice:        advice.Advice,
+		PromptVersion: advice.PromptVersion,
+		Model:         advice.Model,
+		Provider:      advice.Provider,
+	}, nil
+}
+
+func (s *SmokeAINextSmokeService) loadNodes(ctx context.Context, aiAdviceID uint) ([]string, time.Time, time.Time, error) {
+	var rows []smokemodel.SmokeAINextSmoke
+	if err := s.db.WithContext(ctx).
+		Where("ai_advice_id = ? AND (deletetime IS NULL OR deletetime = 0)", aiAdviceID).
+		Order("node_at ASC").
+		Find(&rows).Error; err != nil {
+		return nil, time.Time{}, time.Time{}, fmt.Errorf("load ai next nodes: %w", err)
+	}
+
+	var notBeforeAt, suggestedAt time.Time
+	var nodes []string
+	for _, r := range rows {
+		switch r.NodeType {
+		case "not_before":
+			notBeforeAt = r.NodeAt.In(time.Local)
+		case "suggested":
+			suggestedAt = r.NodeAt.In(time.Local)
+		case "node":
+			nodes = append(nodes, r.NodeAt.In(time.Local).Format("15:04"))
+		}
+	}
+	if notBeforeAt.IsZero() {
+		notBeforeAt = time.Now().In(time.Local)
+	}
+	if suggestedAt.IsZero() {
+		suggestedAt = notBeforeAt
+	}
+	return nodes, notBeforeAt, suggestedAt, nil
+}
+
+func (s *SmokeAINextSmokeService) normalizeNodes(raw []string, asOf time.Time, planDate time.Time, notBeforeAt time.Time, profile *adviceUserProfile) ([]string, error) {
+	now := asOf.In(time.Local)
+	seen := map[string]bool{}
+	out := make([]string, 0, 6)
+
+	for _, v := range raw {
+		if len(out) >= 6 {
+			break
+		}
+		t, err := parseFlexibleTime(v, planDate)
+		if err != nil {
+			continue
+		}
+		t = t.In(time.Local)
+		if dateOnly(t) != dateOnly(planDate) {
+			continue
+		}
+		// 计划日期=今天：不能早于当前时间；计划日期=明天：这里通常不会早于 now。
+		if t.Before(now) && dateOnly(planDate).Equal(dateOnly(now)) {
+			continue
+		}
+		if t.Before(notBeforeAt) {
+			continue
+		}
+		if profile != nil && strings.TrimSpace(profile.WakeUpTime) != "" && strings.TrimSpace(profile.SleepTime) != "" {
+			if adjusted, ok, _ := adjustToWakeIfInSleep(t, profile.WakeUpTime, profile.SleepTime); ok {
+				t = adjusted
+			}
+			if t.Before(notBeforeAt) {
+				continue
+			}
+			if dateOnly(t) != dateOnly(planDate) {
+				continue
+			}
+		}
+		label := t.Format("15:04")
+		if seen[label] {
+			continue
+		}
+		seen[label] = true
+		out = append(out, label)
+	}
+
+	return out, nil
+}
+
+func (s *SmokeAINextSmokeService) computeMinNotBefore(asOf time.Time, planDate time.Time, defaultSuggestion NextSmokeSuggestion, profile *adviceUserProfile) time.Time {
+	asOf = asOf.In(time.Local)
+	planDate = dateOnly(planDate)
+	today := dateOnly(asOf)
+
+	if planDate.After(today) {
+		min := time.Date(planDate.Year(), planDate.Month(), planDate.Day(), 7, 0, 0, 0, time.Local)
+		if profile != nil && strings.TrimSpace(profile.WakeUpTime) != "" {
+			if m, err := parseHHMMToMinutes(profile.WakeUpTime); err == nil {
+				min = time.Date(planDate.Year(), planDate.Month(), planDate.Day(), m/60, m%60, 0, 0, time.Local)
+			}
+		}
+		return min
+	}
+
+	if defaultSuggestion.NextSmokeAt != nil && !defaultSuggestion.NextSmokeAt.IsZero() {
+		return defaultSuggestion.NextSmokeAt.In(time.Local)
+	}
+	return asOf.Add(5 * time.Minute)
+}
+
+func (s *SmokeAINextSmokeService) loadRecent3Days(ctx context.Context, uid int, planDate time.Time) ([]recentDaySnapshot, error) {
+	planDate = dateOnly(planDate)
+	today := dateOnly(time.Now().In(time.Local))
+
+	end := planDate
+	if end.After(today) {
+		end = today
+	}
+	start := end.AddDate(0, 0, -2)
+
+	var logs []smokemodel.SmokeLog
+	if err := s.db.WithContext(ctx).
+		Where("uid = ? AND (deletetime IS NULL OR deletetime = 0)", uid).
+		Where("smoke_time BETWEEN ? AND ?", start.Format("2006-01-02"), end.Format("2006-01-02")).
+		Order("smoke_time ASC").
+		Order("COALESCE(smoke_at, FROM_UNIXTIME(createtime)) ASC").
+		Order("id ASC").
+		Find(&logs).Error; err != nil {
+		return nil, fmt.Errorf("load recent logs: %w", err)
+	}
+
+	byDay := map[string]*recentDaySnapshot{}
+	ensure := func(day time.Time) *recentDaySnapshot {
+		key := dateOnly(day).Format("2006-01-02")
+		if existing, ok := byDay[key]; ok {
+			return existing
+		}
+		snap := &recentDaySnapshot{Date: key, Nodes: []recentDayNode{}}
+		byDay[key] = snap
+		return snap
+	}
+
+	for _, l := range logs {
+		day := start
+		if l.SmokeTime != nil {
+			day = dateOnly(*l.SmokeTime)
+		}
+		snap := ensure(day)
+
+		isResisted := l.Level == 0 && l.Num == 0
+		if isResisted {
+			snap.ResistedCount++
+		} else if l.Num > 0 {
+			snap.TotalNum += l.Num
+		}
+
+		if len(snap.Nodes) >= 50 {
+			continue
+		}
+
+		eventAt, ok := lastEventTime(l)
+		timeLabel := ""
+		if ok {
+			timeLabel = eventAt.In(time.Local).Format("15:04")
+		}
+
+		remark := strings.TrimSpace(l.Remark)
+		if len(remark) > 80 {
+			remark = remark[:80]
+		}
+
+		snap.Nodes = append(snap.Nodes, recentDayNode{
+			Time:       timeLabel,
+			Num:        l.Num,
+			Level:      l.Level,
+			IsResisted: isResisted,
+			Remark:     remark,
+		})
+	}
+
+	out := make([]recentDaySnapshot, 0, 3)
+	for d := start; !d.After(end); d = d.AddDate(0, 0, 1) {
+		key := d.Format("2006-01-02")
+		if snap, ok := byDay[key]; ok {
+			out = append(out, *snap)
+		} else {
+			out = append(out, recentDaySnapshot{Date: key, Nodes: []recentDayNode{}})
+		}
+	}
+	return out, nil
+}
+
+func (s *SmokeAINextSmokeService) isAllowed(ctx context.Context, user *usermodel.User, planDate time.Time) (bool, error) {
+	isVIP, err := s.isVIP(ctx, user)
+	if err != nil {
+		return false, err
+	}
+	if isVIP {
+		return true, nil
+	}
+	return s.isUnlocked(ctx, int(user.ID), planDate)
+}
+
+func (s *SmokeAINextSmokeService) isVIP(ctx context.Context, user *usermodel.User) (bool, error) {
+	now := time.Now()
+	var count int64
+	if err := s.db.WithContext(ctx).
+		Model(&usermodel.UserMembership{}).
+		Where("mini_program_id = ? AND user_id = ? AND status = ? AND ends_at > ?",
+			user.MiniProgramID, user.ID, "active", now).
+		Count(&count).Error; err != nil {
+		return false, fmt.Errorf("check vip: %w", err)
+	}
+	return count > 0, nil
+}
+
+func (s *SmokeAINextSmokeService) isUnlocked(ctx context.Context, uid int, planDate time.Time) (bool, error) {
+	startOfDay := dateOnly(planDate)
+	var unlock smokemodel.SmokeAIAdviceUnlock
+	err := s.db.WithContext(ctx).
+		Where("uid = ? AND unlock_date = ? AND (deletetime IS NULL OR deletetime = 0)", uid, startOfDay.Format("2006-01-02")).
+		First(&unlock).Error
+	if err == nil {
+		return true, nil
+	}
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return false, nil
+	}
+	return false, fmt.Errorf("check unlock: %w", err)
+}
+
+func (s *SmokeAINextSmokeService) saveNodes(ctx context.Context, uid int, planDate time.Time, aiAdviceID uint, notBeforeAt time.Time, suggestedAt time.Time, nodes []string) error {
+	nowUnix := time.Now().Unix()
+	createTime := nowUnix
+	updateTime := nowUnix
+
+	rows := []smokemodel.SmokeAINextSmoke{
+		{
+			UID:        uid,
+			PlanDate:   planDate,
+			AIAdviceID: aiAdviceID,
+			NodeType:   "not_before",
+			NodeAt:     notBeforeAt,
+			CreateTime: &createTime,
+			UpdateTime: &updateTime,
+		},
+		{
+			UID:        uid,
+			PlanDate:   planDate,
+			AIAdviceID: aiAdviceID,
+			NodeType:   "suggested",
+			NodeAt:     suggestedAt,
+			CreateTime: &createTime,
+			UpdateTime: &updateTime,
+		},
+	}
+
+	ref := planDate.In(time.Local)
+	for _, label := range nodes {
+		t, err := parseFlexibleTime(label, ref)
+		if err != nil {
+			continue
+		}
+		rows = append(rows, smokemodel.SmokeAINextSmoke{
+			UID:        uid,
+			PlanDate:   planDate,
+			AIAdviceID: aiAdviceID,
+			NodeType:   "node",
+			NodeAt:     t.In(time.Local),
+			CreateTime: &createTime,
+			UpdateTime: &updateTime,
+		})
+	}
+
+	if err := s.db.WithContext(ctx).Create(&rows).Error; err != nil {
+		return fmt.Errorf("save ai next smoke nodes: %w", err)
+	}
+	return nil
+}
+
+func (s *SmokeAINextSmokeService) callAI(ctx context.Context, input aiNextSmokeInput) (aiNextSmokeOutput, []byte, string, *int, *int, error) {
+	systemPrompt := strings.TrimSpace(`
+你是一名专业的戒烟教练与行为改变顾问。你将收到一段 JSON，包含：
+- 现在时间(as_of)
+- 计划日期(plan_date)：你输出的时间必须属于该日期
+- 最小不早于时间(min_not_before_at)：你输出的 not_before_at 必须 >= 该值
+- 最近3天数据(recent_3_days)：用于判断近期模式（含忍住记录）
+- 后端默认策略(default_suggestion)：仅供参考
+- 可选的用户 profile：包含作息时间、动机/动力
+
+你必须只输出一段严格的 JSON（不要 Markdown、不要解释文字），格式：
+{
+  "not_before_at": "RFC3339 时间字符串(含时区)",
+  "suggested_at": "RFC3339 时间字符串(含时区)",
+  "time_nodes": ["HH:MM", "HH:MM", ...],
+  "advice": "一句话建议(<=200字)"
+}
+
+约束：
+1) not_before_at 必须 >= min_not_before_at；
+2) suggested_at 必须 >= not_before_at；
+3) 如果 profile 提供了 wake_up_time/sleep_time，建议时间与 time_nodes 不要落在睡眠区间；如不可避免，顺延到起床后；
+4) time_nodes 只需要给出 plan_date 的 3~6 个“关键节点”（字符串 HH:MM），并且都不早于 not_before_at。
+`)
+
+	userPrompt := fmt.Sprintf("输入(JSON)：\n%s", mustJSON(input))
+
+	reqBody := chatCompletionRequest{
+		Model: s.cfg.Model,
+		Messages: []chatMessage{
+			{Role: "system", Content: systemPrompt},
+			{Role: "user", Content: userPrompt},
+		},
+		Temperature: defaultTemperature,
+	}
+
+	payload, err := json.Marshal(reqBody)
+	if err != nil {
+		return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("marshal ai request: %w", err)
+	}
+
+	endpoint := strings.TrimRight(s.cfg.BaseURL, "/") + "/chat/completions"
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(payload))
+	if err != nil {
+		return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("build ai request: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", "application/json")
+	httpReq.Header.Set("Authorization", "Bearer "+s.cfg.APIKey)
+
+	resp, err := s.client.Do(httpReq)
+	if err != nil {
+		return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("call ai: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("read ai response: %w", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("ai http %d: %s", resp.StatusCode, truncateString(string(body), 512))
+	}
+
+	var parsed chatCompletionResponse
+	if err := json.Unmarshal(body, &parsed); err != nil {
+		return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("parse ai response: %w", err)
+	}
+	if len(parsed.Choices) == 0 {
+		return aiNextSmokeOutput{}, nil, "", nil, nil, errors.New("ai response has no choices")
+	}
+
+	content := strings.TrimSpace(parsed.Choices[0].Message.Content)
+	if content == "" {
+		return aiNextSmokeOutput{}, nil, "", nil, nil, errors.New("ai response content is empty")
+	}
+
+	jsonPart := extractJSONObject(content)
+	if jsonPart == "" {
+		return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("ai response is not json: %s", truncateString(content, 256))
+	}
+
+	var out aiNextSmokeOutput
+	if err := json.Unmarshal([]byte(jsonPart), &out); err != nil {
+		return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("unmarshal ai json: %w", err)
+	}
+
+	modelName := parsed.Model
+	if modelName == "" {
+		modelName = s.cfg.Model
+	}
+
+	var tokensIn, tokensOut *int
+	if parsed.Usage != nil {
+		tokensIn = &parsed.Usage.PromptTokens
+		tokensOut = &parsed.Usage.CompletionTokens
+	}
+
+	return out, []byte(jsonPart), modelName, tokensIn, tokensOut, nil
+}
+
+func extractJSONObject(s string) string {
+	start := strings.Index(s, "{")
+	end := strings.LastIndex(s, "}")
+	if start < 0 || end < 0 || end <= start {
+		return ""
+	}
+	return s[start : end+1]
+}
+
+func parseFlexibleTime(value string, ref time.Time) (time.Time, error) {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return time.Time{}, errors.New("empty time")
+	}
+	if t, err := time.Parse(time.RFC3339, value); err == nil {
+		return t.In(time.Local), nil
+	}
+	if t, err := time.ParseInLocation("2006-01-02 15:04:05", value, time.Local); err == nil {
+		return t.In(time.Local), nil
+	}
+	// 仅提供 HH:MM：使用 ref 的日期
+	if len(value) == 5 && value[2] == ':' {
+		min, err := parseHHMMToMinutes(value)
+		if err != nil {
+			return time.Time{}, err
+		}
+		r := ref.In(time.Local)
+		return time.Date(r.Year(), r.Month(), r.Day(), min/60, min%60, 0, 0, time.Local), nil
+	}
+	return time.Time{}, fmt.Errorf("unsupported time format: %s", value)
+}

internal/smoke/service/smoke_log_service.go

@@ -37,11 +37,11 @@ func (s *SmokeLogService) Create(ctx context.Context, uid int, req CreateSmokeLo
 	updateTime := now
 
 	level := req.Level
-	if level <= 0 {
+	if level < 0 {
 		level = 1
 	}
 	num := req.Num
-	if num <= 0 {
+	if num < 0 {
 		num = 1
 	}
 
@@ -212,7 +212,8 @@ func (s *SmokeLogService) Dashboard(ctx context.Context, uid int, req SmokeDashb
 	var last smokemodel.SmokeLog
 	if err := s.db.WithContext(ctx).
 		Where("uid = ? AND (deletetime IS NULL OR deletetime = 0)", uid).
-		Order("COALESCE(smoke_at, smoke_time, FROM_UNIXTIME(createtime)) DESC").
+		Where("NOT (level = 0 AND num = 0)").
+		Order("COALESCE(smoke_at, FROM_UNIXTIME(createtime), smoke_time) DESC").
 		Order("id DESC").
 		Limit(1).
 		Take(&last).Error; err != nil {
@@ -260,7 +261,7 @@ func (s *SmokeLogService) ListLatest(ctx context.Context, uid int, limit int) ([
 		Model(&smokemodel.SmokeLog{}).
 		Select("id, uid, smoke_time, smoke_at, remark, level, num, createtime, updatetime, deletetime").
 		Where("uid = ? AND (deletetime IS NULL OR deletetime = 0)", uid).
-		Order("COALESCE(smoke_at, smoke_time, FROM_UNIXTIME(createtime)) DESC").
+		Order("COALESCE(smoke_at, FROM_UNIXTIME(createtime), smoke_time) DESC").
 		Order("id DESC").
 		Limit(limit).
 		Find(&items).Error; err != nil {
@@ -274,13 +275,13 @@ func lastEventTime(log smokemodel.SmokeLog) (time.Time, bool) {
 	if log.SmokeAt != nil {
 		return log.SmokeAt.In(time.Local), true
 	}
+	if log.CreateTime != nil {
+		return time.Unix(*log.CreateTime, 0).In(time.Local), true
+	}
 	if log.SmokeTime != nil {
 		day := dateOnly(*log.SmokeTime)
 		return day, true
 	}
-	if log.CreateTime != nil {
-		return time.Unix(*log.CreateTime, 0).In(time.Local), true
-	}
 	return time.Time{}, false
 }
 
@@ -321,14 +322,14 @@ func (s *SmokeLogService) Update(ctx context.Context, uid int, id int, req Updat
 		updates["remark"] = *req.Remark
 	}
 	if req.Level != nil {
-		if *req.Level <= 0 {
+		if *req.Level < 0 {
 			updates["level"] = int64(1)
 		} else {
 			updates["level"] = *req.Level
 		}
 	}
 	if req.Num != nil {
-		if *req.Num <= 0 {
+		if *req.Num < 0 {
 			updates["num"] = 1
 		} else {
 			updates["num"] = *req.Num

internal/smoke/service/smoke_next_service.go

@@ -0,0 +1,202 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"gorm.io/gorm"
+
+	smokemodel "wx_service/internal/smoke/model"
+)
+
+type SmokeNextService struct {
+	db *gorm.DB
+}
+
+func NewSmokeNextService(db *gorm.DB) *SmokeNextService {
+	return &SmokeNextService{db: db}
+}
+
+type NextSmokeSuggestion struct {
+	LastSmokeAt           *time.Time `json:"last_smoke_at,omitempty"`
+	NextSmokeAt           *time.Time `json:"next_smoke_at,omitempty"`
+	BaseIntervalMinutes   int        `json:"base_interval_minutes"`
+	IntervalMinutes       int        `json:"interval_minutes"`
+	Stage                int        `json:"stage"`
+	Resisted7d            int        `json:"resisted_7d"`
+	SleepAdjusted         bool       `json:"sleep_adjusted"`
+	Algorithm             string     `json:"algorithm"`
+	AsOf                  string     `json:"as_of"`
+}
+
+// GetDefaultSuggestion 返回“未使用 AI 时”的默认下次抽烟时间建议（阶梯式延时算法）。
+func (s *SmokeNextService) GetDefaultSuggestion(ctx context.Context, uid int, asOf time.Time, planDate time.Time, profileView SmokeProfileView) (NextSmokeSuggestion, error) {
+	now := asOf.In(time.Local)
+	planDay := dateOnly(planDate)
+
+	base := profileView.BaselineIntervalMinute
+	if base <= 0 {
+		base = 60
+	}
+
+	lastSmokeAt, ok, err := s.loadLastActualSmokeAt(ctx, uid)
+	if err != nil {
+		return NextSmokeSuggestion{}, err
+	}
+	if !ok {
+		nowCopy := now
+		lastSmokeAt = &nowCopy
+	}
+
+	resisted, err := s.countResistedLastDays(ctx, uid, 7)
+	if err != nil {
+		return NextSmokeSuggestion{}, err
+	}
+
+	stage := resisted / 5
+	if stage > 12 {
+		stage = 12
+	}
+
+	interval := base + stage*5
+	if interval < 5 {
+		interval = 5
+	}
+	if interval > 240 {
+		interval = 240
+	}
+
+	next := lastSmokeAt.Add(time.Duration(interval) * time.Minute)
+	sleepAdjusted := false
+
+	var wakeUp, sleep string
+	if profileView.Profile != nil {
+		wakeUp = profileView.Profile.WakeUpTime
+		sleep = profileView.Profile.SleepTime
+	}
+
+	// 如果是“生成某一天的计划”（例如明天），默认不早于该日的起床时间（若未配置则使用 07:00）。
+	today := dateOnly(now)
+	if planDay.After(today) {
+		minNotBefore := time.Date(planDay.Year(), planDay.Month(), planDay.Day(), 7, 0, 0, 0, time.Local)
+		if wakeUp != "" {
+			if m, err := parseHHMMToMinutes(wakeUp); err == nil {
+				minNotBefore = time.Date(planDay.Year(), planDay.Month(), planDay.Day(), m/60, m%60, 0, 0, time.Local)
+			}
+		}
+		if next.Before(minNotBefore) {
+			next = minNotBefore
+		}
+	}
+
+	if wakeUp != "" && sleep != "" {
+		adjusted, ok, err := adjustToWakeIfInSleep(next, wakeUp, sleep)
+		if err != nil && !errors.Is(err, ErrSmokeProfileInvalidTime) {
+			return NextSmokeSuggestion{}, err
+		}
+		if ok {
+			next = adjusted
+			sleepAdjusted = true
+		}
+	}
+
+	out := NextSmokeSuggestion{
+		BaseIntervalMinutes: base,
+		IntervalMinutes:     interval,
+		Stage:              stage,
+		Resisted7d:          resisted,
+		SleepAdjusted:       sleepAdjusted,
+		Algorithm:           "staircase_delay_v1",
+		AsOf:                now.Format(time.RFC3339),
+	}
+	out.LastSmokeAt = lastSmokeAt
+	if !next.IsZero() {
+		t := next
+		out.NextSmokeAt = &t
+	}
+	return out, nil
+}
+
+func (s *SmokeNextService) loadLastActualSmokeAt(ctx context.Context, uid int) (*time.Time, bool, error) {
+	var last smokemodel.SmokeLog
+	err := s.db.WithContext(ctx).
+		Where("uid = ? AND (deletetime IS NULL OR deletetime = 0)", uid).
+		Where("NOT (level = 0 AND num = 0)").
+		Order("COALESCE(smoke_at, FROM_UNIXTIME(createtime), smoke_time) DESC").
+		Order("id DESC").
+		Limit(1).
+		Take(&last).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, false, nil
+		}
+		return nil, false, fmt.Errorf("load last smoke log: %w", err)
+	}
+	t, ok := lastEventTime(last)
+	if !ok {
+		return nil, false, nil
+	}
+	return &t, true, nil
+}
+
+func (s *SmokeNextService) countResistedLastDays(ctx context.Context, uid int, days int) (int, error) {
+	if days <= 0 {
+		days = 7
+	}
+	end := dateOnly(time.Now().In(time.Local))
+	start := end.AddDate(0, 0, -(days - 1))
+
+	var count int64
+	if err := s.db.WithContext(ctx).
+		Model(&smokemodel.SmokeLog{}).
+		Where("uid = ? AND (deletetime IS NULL OR deletetime = 0)", uid).
+		Where("level = 0 AND num = 0").
+		Where("smoke_time BETWEEN ? AND ?", start.Format("2006-01-02"), end.Format("2006-01-02")).
+		Count(&count).Error; err != nil {
+		return 0, fmt.Errorf("count resisted logs: %w", err)
+	}
+	return int(count), nil
+}
+
+func adjustToWakeIfInSleep(t time.Time, wakeUpHHMM, sleepHHMM string) (time.Time, bool, error) {
+	wakeMin, err := parseHHMMToMinutes(wakeUpHHMM)
+	if err != nil {
+		return time.Time{}, false, ErrSmokeProfileInvalidTime
+	}
+	sleepMin, err := parseHHMMToMinutes(sleepHHMM)
+	if err != nil {
+		return time.Time{}, false, ErrSmokeProfileInvalidTime
+	}
+	if wakeMin == sleepMin {
+		return t, false, nil
+	}
+
+	minutes := t.Hour()*60 + t.Minute()
+	inSleep := isInSleepWindow(minutes, wakeMin, sleepMin)
+	if !inSleep {
+		return t, false, nil
+	}
+
+	wakeToday := time.Date(t.Year(), t.Month(), t.Day(), wakeMin/60, wakeMin%60, 0, 0, t.Location())
+	if !wakeToday.After(t) {
+		wakeToday = wakeToday.Add(24 * time.Hour)
+	}
+	return wakeToday, true, nil
+}
+
+func isInSleepWindow(minuteOfDay int, wakeMin int, sleepMin int) bool {
+	if minuteOfDay < 0 {
+		minuteOfDay = 0
+	}
+	if minuteOfDay >= 24*60 {
+		minuteOfDay = 24*60 - 1
+	}
+	// wake < sleep: awake=[wake,sleep), sleep=else
+	if wakeMin < sleepMin {
+		return minuteOfDay < wakeMin || minuteOfDay >= sleepMin
+	}
+	// wake > sleep: awake 跨午夜，sleep=[sleep,wake)
+	return minuteOfDay >= sleepMin && minuteOfDay < wakeMin
+}

internal/smoke/service/smoke_next_service_test.go

@@ -0,0 +1,83 @@
+package service
+
+import (
+	"testing"
+	"time"
+)
+
+func TestIsInSleepWindow(t *testing.T) {
+	t.Parallel()
+
+	// wake=07:30, sleep=23:30 => sleep: [23:30, 07:30)
+	wake := 7*60 + 30
+	sleep := 23*60 + 30
+
+	if !isInSleepWindow(0, wake, sleep) {
+		t.Fatalf("expected 00:00 to be in sleep window")
+	}
+	if isInSleepWindow(8*60, wake, sleep) {
+		t.Fatalf("expected 08:00 to be awake")
+	}
+	if !isInSleepWindow(23*60+45, wake, sleep) {
+		t.Fatalf("expected 23:45 to be in sleep window")
+	}
+
+	// wake=18:00, sleep=02:00 => sleep: [02:00, 18:00)
+	wake = 18 * 60
+	sleep = 2 * 60
+	if isInSleepWindow(1*60, wake, sleep) {
+		t.Fatalf("expected 01:00 to be awake (awake window crosses midnight)")
+	}
+	if !isInSleepWindow(10*60, wake, sleep) {
+		t.Fatalf("expected 10:00 to be in sleep window")
+	}
+}
+
+func TestAdjustToWakeIfInSleep(t *testing.T) {
+	t.Parallel()
+
+	loc := time.Local
+	// wake=07:30, sleep=23:30
+	wake := "07:30"
+	sleep := "23:30"
+
+	// 02:00 should adjust to same-day 07:30
+	in := time.Date(2026, 1, 2, 2, 0, 0, 0, loc)
+	out, adjusted, err := adjustToWakeIfInSleep(in, wake, sleep)
+	if err != nil {
+		t.Fatalf("adjustToWakeIfInSleep: %v", err)
+	}
+	if !adjusted {
+		t.Fatalf("expected adjustment")
+	}
+	if out.Hour() != 7 || out.Minute() != 30 {
+		t.Fatalf("expected 07:30, got %02d:%02d", out.Hour(), out.Minute())
+	}
+
+	// 10:00 should not adjust
+	in = time.Date(2026, 1, 2, 10, 0, 0, 0, loc)
+	out, adjusted, err = adjustToWakeIfInSleep(in, wake, sleep)
+	if err != nil {
+		t.Fatalf("adjustToWakeIfInSleep: %v", err)
+	}
+	if adjusted {
+		t.Fatalf("expected no adjustment")
+	}
+	if !out.Equal(in) {
+		t.Fatalf("expected unchanged time")
+	}
+
+	// 23:45 should adjust to next-day 07:30
+	in = time.Date(2026, 1, 2, 23, 45, 0, 0, loc)
+	out, adjusted, err = adjustToWakeIfInSleep(in, wake, sleep)
+	if err != nil {
+		t.Fatalf("adjustToWakeIfInSleep: %v", err)
+	}
+	if !adjusted {
+		t.Fatalf("expected adjustment")
+	}
+	if out.Day() != 3 || out.Hour() != 7 || out.Minute() != 30 {
+		t.Fatalf("expected next day 07:30, got %s", out.Format(time.RFC3339))
+	}
+}
+