Version: 0.5.8.dev.260315

♻️ refactor(agent): 拆分 agentsvc，并增强 quicknote/outbox 注释与可维护性 - 📦 将 Agent 服务实现从 `service` 根目录迁移到 `service/agentsvc`，包含 `agent.go`、`agent_quick_note.go` 及相关测试 - 🔌 新增 service 层兼容桥接 `agent_bridge.go`，保持 `service.NewAgentService` 与 `*service.AgentService` 现有调用方式不变 - 📝 为 `quicknote` 补充高密度中文步骤化注释，覆盖 `graph` / `runner` / `nodes` / `tool` / `state` / `prompt`，明确职责边界、分支条件、重试与兜底策略 - 🧭 为 `infra/outbox` 与 service agent 链路补充详细中文注释，覆盖状态机流转、幂等处理、失败回写与异步持久化语义 - ✅ 统一格式化相关文件，并通过全量后端测试：`go test ./...` 📝 chore(docs): 更新 AGENTS.md 注释强制规范 - 📚 追加“注释规范（强制）”与“注释风格示例” - ✍️ 明确复杂逻辑必须使用步骤化注释、跨文件调用需写调用目的、注释需同步维护
2026-03-15 18:08:33 +08:00
parent c689af56c8
commit 7603a7561a
22 changed files with 1009 additions and 429 deletions
--- a/backend/service/agent_async_pipeline.go
+++ b/backend/service/agent_async_pipeline.go
@@ -1,229 +0,0 @@
-package service
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log"
-	"time"
-
-	"github.com/LoveLosita/smartflow/backend/dao"
-	kafkabus "github.com/LoveLosita/smartflow/backend/kafka"
-	"github.com/LoveLosita/smartflow/backend/model"
-	segmentkafka "github.com/segmentio/kafka-go"
-	"gorm.io/gorm"
-)
-
-// AgentAsyncPipeline 负责 outbox 扫描、Kafka 投递与消费落库。
-type AgentAsyncPipeline struct {
-	outboxRepo *dao.OutboxDAO
-	producer   *kafkabus.Producer
-	consumer   *kafkabus.Consumer
-	brokers    []string
-	topic      string
-	maxRetry   int
-	scanEvery  time.Duration
-	scanBatch  int
-}
-
-func NewAgentAsyncPipeline(outboxRepo *dao.OutboxDAO, cfg kafkabus.Config) (*AgentAsyncPipeline, error) {
-	if !cfg.Enabled {
-		return nil, nil
-	}
-	producer, err := kafkabus.NewProducer(cfg)
-	if err != nil {
-		return nil, err
-	}
-	consumer, err := kafkabus.NewConsumer(cfg)
-	if err != nil {
-		_ = producer.Close()
-		return nil, err
-	}
-	return &AgentAsyncPipeline{
-		outboxRepo: outboxRepo,
-		producer:   producer,
-		consumer:   consumer,
-		brokers:    cfg.Brokers,
-		topic:      cfg.Topic,
-		maxRetry:   cfg.MaxRetry,
-		scanEvery:  cfg.RetryScanInterval,
-		scanBatch:  cfg.RetryBatchSize,
-	}, nil
-}
-
-func (p *AgentAsyncPipeline) Start(ctx context.Context) {
-	if p == nil {
-		return
-	}
-
-	log.Printf("Kafka async pipeline starting: topic=%s brokers=%v retry_scan=%s batch=%d", p.topic, p.brokers, p.scanEvery, p.scanBatch)
-	if err := kafkabus.WaitTopicReady(ctx, p.brokers, p.topic, 30*time.Second); err != nil {
-		log.Printf("Kafka topic not ready before consume loop start: %v", err)
-	} else {
-		log.Printf("Kafka topic is ready: %s", p.topic)
-	}
-
-	go p.startDispatchLoop(ctx)
-	go p.startConsumeLoop(ctx)
-}
-
-func (p *AgentAsyncPipeline) Close() {
-	if p == nil {
-		return
-	}
-	if err := p.producer.Close(); err != nil {
-		log.Printf("关闭 Kafka producer 失败: %v", err)
-	}
-	if err := p.consumer.Close(); err != nil {
-		log.Printf("关闭 Kafka consumer 失败: %v", err)
-	}
-}
-
-// EnqueueChatHistoryPersist 仅把消息写入 outbox。
-//
-// 关键设计：
-// 1) 不再在请求路径里做“首次同步投递 Kafka”；
-// 2) 投递统一由 startDispatchLoop 异步扫描执行；
-// 3) CreateChatHistoryMessage 会设置 next_retry_at=now，扫描器下一轮即可捞取。
-//
-// 这样可以把请求链路成本收敛到“写 outbox”，避免 Kafka 写入延迟污染首字和主链路时延。
-func (p *AgentAsyncPipeline) EnqueueChatHistoryPersist(ctx context.Context, payload model.ChatHistoryPersistPayload) error {
-	if p == nil {
-		return errors.New("Kafka 异步链路未初始化")
-	}
-	_, err := p.outboxRepo.CreateChatHistoryMessage(ctx, p.topic, payload.ConversationID, payload, p.maxRetry)
-	return err
-}
-
-func (p *AgentAsyncPipeline) startDispatchLoop(ctx context.Context) {
-	ticker := time.NewTicker(p.scanEvery)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-ticker.C:
-			pendingMessages, err := p.outboxRepo.ListDueMessages(ctx, p.scanBatch)
-			if err != nil {
-				log.Printf("扫描 outbox 失败: %v", err)
-				continue
-			}
-			if len(pendingMessages) > 0 {
-				log.Printf("outbox due messages=%d, start dispatch", len(pendingMessages))
-			}
-			for _, msg := range pendingMessages {
-				if err = p.dispatchOne(ctx, msg.ID); err != nil {
-					log.Printf("重试投递 outbox 消息失败(id=%d): %v", msg.ID, err)
-				}
-			}
-		}
-	}
-}
-
-func (p *AgentAsyncPipeline) dispatchOne(ctx context.Context, outboxID int64) error {
-	outboxMsg, err := p.outboxRepo.GetByID(ctx, outboxID)
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil
-		}
-		return err
-	}
-	if outboxMsg.Status == model.OutboxStatusConsumed || outboxMsg.Status == model.OutboxStatusDead {
-		return nil
-	}
-
-	envelope := kafkabus.Envelope{
-		OutboxID: outboxMsg.ID,
-		BizType:  outboxMsg.BizType,
-		Payload:  json.RawMessage(outboxMsg.Payload),
-	}
-	raw, err := json.Marshal(envelope)
-	if err != nil {
-		markErr := p.outboxRepo.MarkDead(ctx, outboxMsg.ID, "序列化 outbox 包装失败: "+err.Error())
-		if markErr != nil {
-			log.Printf("标记 outbox 死信失败(id=%d): %v", outboxMsg.ID, markErr)
-		}
-		return err
-	}
-
-	if err = p.producer.Enqueue(ctx, outboxMsg.Topic, outboxMsg.MessageKey, raw); err != nil {
-		_ = p.outboxRepo.MarkFailedForRetry(ctx, outboxMsg.ID, "投递 Kafka 失败: "+err.Error())
-		return err
-	}
-	if err = p.outboxRepo.MarkPublished(ctx, outboxMsg.ID); err != nil {
-		_ = p.outboxRepo.MarkFailedForRetry(ctx, outboxMsg.ID, "更新已投递状态失败: "+err.Error())
-		return err
-	}
-	return nil
-}
-
-func (p *AgentAsyncPipeline) startConsumeLoop(ctx context.Context) {
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		default:
-		}
-
-		msg, err := p.consumer.Dequeue(ctx)
-		if err != nil {
-			if errors.Is(err, context.Canceled) {
-				return
-			}
-			log.Printf("Kafka 消费拉取失败(topic=%s): %v", p.topic, err)
-			time.Sleep(300 * time.Millisecond)
-			continue
-		}
-		if err = p.handleMessage(ctx, msg); err != nil {
-			log.Printf("处理 Kafka 消息失败(topic=%s, partition=%d, offset=%d): %v", msg.Topic, msg.Partition, msg.Offset, err)
-		}
-	}
-}
-
-func (p *AgentAsyncPipeline) handleMessage(ctx context.Context, msg segmentkafka.Message) error {
-	var envelope kafkabus.Envelope
-	if err := json.Unmarshal(msg.Value, &envelope); err != nil {
-		_ = p.consumer.Commit(ctx, msg)
-		return fmt.Errorf("解析 Kafka 包装失败: %w", err)
-	}
-	if envelope.OutboxID <= 0 {
-		_ = p.consumer.Commit(ctx, msg)
-		return errors.New("Kafka 包装缺少 outbox_id")
-	}
-
-	switch envelope.BizType {
-	case model.OutboxBizTypeChatHistoryPersist:
-		return p.consumeChatHistory(ctx, msg, envelope)
-	default:
-		_ = p.outboxRepo.MarkDead(ctx, envelope.OutboxID, "未知业务类型: "+envelope.BizType)
-		if err := p.consumer.Commit(ctx, msg); err != nil {
-			return err
-		}
-		return nil
-	}
-}
-
-func (p *AgentAsyncPipeline) consumeChatHistory(ctx context.Context, msg segmentkafka.Message, envelope kafkabus.Envelope) error {
-	var payload model.ChatHistoryPersistPayload
-	if err := json.Unmarshal(envelope.Payload, &payload); err != nil {
-		_ = p.outboxRepo.MarkDead(ctx, envelope.OutboxID, "解析聊天持久化载荷失败: "+err.Error())
-		if commitErr := p.consumer.Commit(ctx, msg); commitErr != nil {
-			return commitErr
-		}
-		return nil
-	}
-
-	if err := p.outboxRepo.PersistChatHistoryAndMarkConsumed(ctx, envelope.OutboxID, payload); err != nil {
-		if markErr := p.outboxRepo.MarkFailedForRetry(ctx, envelope.OutboxID, "消费并落库失败: "+err.Error()); markErr != nil {
-			return markErr
-		}
-		if commitErr := p.consumer.Commit(ctx, msg); commitErr != nil {
-			return commitErr
-		}
-		return err
-	}
-
-	return p.consumer.Commit(ctx, msg)
-}
--- a/backend/service/agent_bridge.go
+++ b/backend/service/agent_bridge.go
@@ -0,0 +1,22 @@
+package service
+
+import (
+	"github.com/LoveLosita/smartflow/backend/dao"
+	outboxinfra "github.com/LoveLosita/smartflow/backend/infra/outbox"
+	"github.com/LoveLosita/smartflow/backend/inits"
+	"github.com/LoveLosita/smartflow/backend/service/agentsvc"
+)
+
+// AgentService 是 service 层对 agentsvc.AgentService 的兼容别名。
+// 迁移目的：
+// 1) 把 Agent 业务实现收拢到 service/agentsvc，提升目录整洁度；
+// 2) 不破坏既有调用方（api/cmd 仍然可以引用 service.AgentService）。
+type AgentService = agentsvc.AgentService
+
+// NewAgentService 是迁移期兼容构造函数。
+// 说明：
+// 1) 外部调用签名保持不变；
+// 2) 真实构造逻辑已下沉到 service/agentsvc 包。
+func NewAgentService(aiHub *inits.AIHub, repo *dao.AgentDAO, taskRepo *dao.TaskDAO, agentRedis *dao.AgentCache, asyncPipeline *outboxinfra.ChatHistoryAsync) *AgentService {
+	return agentsvc.NewAgentService(aiHub, repo, taskRepo, agentRedis, asyncPipeline)
+}
--- a/backend/service/agentsvc/agent.go
+++ b/backend/service/agentsvc/agent.go
@@ -1,4 +1,4 @@
-package service
+package agentsvc

 import (
 	"context"
@@ -9,6 +9,7 @@ import (
 	"github.com/LoveLosita/smartflow/backend/agent/chat"
 	"github.com/LoveLosita/smartflow/backend/conv"
 	"github.com/LoveLosita/smartflow/backend/dao"
+	outboxinfra "github.com/LoveLosita/smartflow/backend/infra/outbox"
 	"github.com/LoveLosita/smartflow/backend/inits"
 	"github.com/LoveLosita/smartflow/backend/model"
 	"github.com/LoveLosita/smartflow/backend/pkg"
@@ -22,10 +23,13 @@ type AgentService struct {
 	repo          *dao.AgentDAO
 	taskRepo      *dao.TaskDAO
 	agentCache    *dao.AgentCache
-	asyncPipeline *AgentAsyncPipeline
+	asyncPipeline *outboxinfra.ChatHistoryAsync
 }

-func NewAgentService(aiHub *inits.AIHub, repo *dao.AgentDAO, taskRepo *dao.TaskDAO, agentRedis *dao.AgentCache, asyncPipeline *AgentAsyncPipeline) *AgentService {
+// NewAgentService 构造 AgentService。
+// 这里通过依赖注入把“模型、仓储、缓存、异步持久化通道”统一交给服务层管理，
+// 便于后续在单测中替换实现，或在启动流程中按环境切换配置。
+func NewAgentService(aiHub *inits.AIHub, repo *dao.AgentDAO, taskRepo *dao.TaskDAO, agentRedis *dao.AgentCache, asyncPipeline *outboxinfra.ChatHistoryAsync) *AgentService {
 	return &AgentService{
 		AIHub:         aiHub,
 		repo:          repo,
@@ -35,6 +39,10 @@ func NewAgentService(aiHub *inits.AIHub, repo *dao.AgentDAO, taskRepo *dao.TaskD
 	}
 }

+// normalizeConversationID 规范会话 ID。
+// 规则：
+// 1) 去除首尾空白；
+// 2) 若为空则生成 UUID，保证后续缓存/数据库操作始终有合法 chat_id。
 func normalizeConversationID(chatID string) string {
 	trimmed := strings.TrimSpace(chatID)
 	if trimmed == "" {
@@ -43,6 +51,10 @@ func normalizeConversationID(chatID string) string {
 	return trimmed
 }

+// pickChatModel 根据请求选择模型。
+// 当前约定：
+// - strategist：策略模型；
+// - 其余值默认 worker（包含空字符串场景）。
 func (s *AgentService) pickChatModel(requestModel string) (*ark.ChatModel, string) {
 	modelName := strings.TrimSpace(requestModel)
 	if strings.EqualFold(modelName, "strategist") {
@@ -55,12 +67,19 @@ func (s *AgentService) pickChatModel(requestModel string) (*ark.ChatModel, strin
 // 1) 开启异步链路时，走 outbox + Kafka；
 // 2) 未开启时，直接同步写库。
 func (s *AgentService) saveChatHistoryReliable(ctx context.Context, payload model.ChatHistoryPersistPayload) error {
+	// 1. 未注入异步通道时（例如本地极简环境），直接同步写 DB。
+	//    这样可以保证功能不依赖 Kafka 也能跑通。
 	if s.asyncPipeline == nil {
 		return s.repo.SaveChatHistory(ctx, payload.UserID, payload.ConversationID, payload.Role, payload.Message)
 	}
+	// 2. 已启用异步通道时，只入 outbox，不在请求路径阻塞 Kafka。
 	return s.asyncPipeline.EnqueueChatHistoryPersist(ctx, payload)
 }

+// pushErrNonBlocking 向错误通道“尽力投递”错误。
+// 目的：
+// 1) 避免 goroutine 在 errChan 满时被阻塞导致泄漏；
+// 2) 保证主业务协程不因“错误上报拥塞”卡死。
 func pushErrNonBlocking(errChan chan error, err error) {
 	select {
 	case errChan <- err:
@@ -86,6 +105,7 @@ func (s *AgentService) runNormalChatFlow(
 	outChan chan<- string,
 	errChan chan error,
 ) {
+	// 1. 先尝试从 Redis 读历史，命中可直接进入模型推理，减少 DB 压力。
 	chatHistory, err := s.agentCache.GetHistory(ctx, chatID)
 	if err != nil {
 		pushErrNonBlocking(errChan, err)
@@ -94,6 +114,7 @@ func (s *AgentService) runNormalChatFlow(

 	cacheMiss := false
 	if chatHistory == nil {
+		// 2. 缓存未命中时回源 DB，并转换为 Eino message 格式。
 		cacheMiss = true
 		histories, hisErr := s.repo.GetUserChatHistories(ctx, userID, pkg.HistoryFetchLimitByModel(resolvedModelName), chatID)
 		if hisErr != nil {
@@ -103,10 +124,13 @@ func (s *AgentService) runNormalChatFlow(
 		chatHistory = conv.ToEinoMessages(histories)
 	}

+	// 3. 计算本次请求可用的历史 token 预算，并执行历史裁剪。
+	//    这样可以在上下文增长时稳定控制模型窗口，避免超长上下文引发报错或高延迟。
 	historyBudget := pkg.HistoryTokenBudgetByModel(resolvedModelName, chat.SystemPrompt, userMessage)
 	trimmedHistory, totalHistoryTokens, keptHistoryTokens, droppedCount := pkg.TrimHistoryByTokenBudget(chatHistory, historyBudget)
 	chatHistory = trimmedHistory

+	// 4. 根据裁剪后历史长度更新 Redis 会话窗口配置，并主动执行窗口收敛。
 	targetWindow := pkg.CalcSessionWindowSize(len(chatHistory))
 	if err = s.agentCache.SetSessionWindowSize(ctx, chatID, targetWindow); err != nil {
 		log.Printf("设置历史窗口失败 chat=%s: %v", chatID, err)
@@ -121,18 +145,24 @@ func (s *AgentService) runNormalChatFlow(
 	}

 	if cacheMiss {
+		// 5. 回源后把历史回填到 Redis，减少下一次请求的冷启动成本。
 		if err = s.agentCache.BackfillHistory(ctx, chatID, chatHistory); err != nil {
 			pushErrNonBlocking(errChan, err)
 			return
 		}
 	}

+	// 6. 执行真正的流式聊天。
+	//    fullText 用于后续写 Redis/持久化，outChan 用于把流片段实时推给前端。
 	fullText, streamErr := chat.StreamChat(ctx, selectedModel, resolvedModelName, userMessage, ifThinking, chatHistory, outChan, traceID, chatID, requestStart)
 	if streamErr != nil {
 		pushErrNonBlocking(errChan, streamErr)
 		return
 	}

+	// 7. 后置持久化（用户消息）：
+	//    7.1 先写 Redis，保证“最新会话上下文”可立即用于下一轮推理；
+	//    7.2 再走可靠持久化入口（outbox 或同步 DB）。
 	if err = s.agentCache.PushMessage(ctx, chatID, &schema.Message{Role: schema.User, Content: userMessage}); err != nil {
 		log.Printf("写入用户消息到 Redis 失败: %v", err)
 	}
@@ -149,6 +179,9 @@ func (s *AgentService) runNormalChatFlow(

 	// 普通聊天链路也需要把助手回复写入 Redis，
 	// 否则会出现“数据库有助手消息，但 Redis 最新会话只有用户消息”的口径不一致。
+	// 8. 后置持久化（助手消息）：
+	//    8.1 先写 Redis，保证下一轮上下文可见；
+	//    8.2 再异步可靠落库，失败通过 errChan 回传给上层。
 	if err = s.agentCache.PushMessage(context.Background(), chatID, &schema.Message{Role: schema.Assistant, Content: fullText}); err != nil {
 		log.Printf("写入助手消息到 Redis 失败: %v", err)
 	}
@@ -167,6 +200,9 @@ func (s *AgentService) AgentChat(ctx context.Context, userMessage string, ifThin
 	requestStart := time.Now()
 	traceID := uuid.NewString()

+	// 1. 每个请求都返回两个通道：
+	//    - outChan：推送流式输出片段；
+	//    - errChan：推送异步阶段错误（非阻塞上报）。
 	outChan := make(chan string, 8)
 	errChan := make(chan error, 1)

@@ -175,6 +211,7 @@ func (s *AgentService) AgentChat(ctx context.Context, userMessage string, ifThin
 	selectedModel, resolvedModelName := s.pickChatModel(modelName)

 	// 2) 确保会话存在（优先缓存，必要时回源 DB 并创建）。
+	// 2.1 先查 Redis 会话标记，命中则可跳过 DB 存在性校验。
 	result, err := s.agentCache.GetConversationStatus(ctx, chatID)
 	if err != nil {
 		errChan <- err
@@ -183,6 +220,7 @@ func (s *AgentService) AgentChat(ctx context.Context, userMessage string, ifThin
 		return outChan, errChan
 	}
 	if !result {
+		// 2.2 缓存未命中时回源 DB：确认会话是否存在。
 		innerResult, ifErr := s.repo.IfChatExists(ctx, userID, chatID)
 		if ifErr != nil {
 			errChan <- ifErr
@@ -191,6 +229,7 @@ func (s *AgentService) AgentChat(ctx context.Context, userMessage string, ifThin
 			return outChan, errChan
 		}
 		if !innerResult {
+			// 2.3 DB 里也不存在则创建新会话。
 			if _, err = s.repo.CreateNewChat(userID, chatID); err != nil {
 				errChan <- err
 				close(outChan)
@@ -198,6 +237,7 @@ func (s *AgentService) AgentChat(ctx context.Context, userMessage string, ifThin
 				return outChan, errChan
 			}
 		}
+		// 2.4 补写 Redis 会话标记，优化下次访问。
 		if err = s.agentCache.SetConversationStatus(ctx, chatID); err != nil {
 			log.Printf("设置会话状态缓存失败 chat=%s: %v", chatID, err)
 		}
@@ -210,15 +250,19 @@ func (s *AgentService) AgentChat(ctx context.Context, userMessage string, ifThin
 	go func() {
 		defer close(outChan)

+		// 3.1 先走轻量路由，判断是否进入“随口记”图。
 		routing := s.decideQuickNoteRouting(ctx, selectedModel, userMessage)
 		if !routing.EnterQuickNote {
+			// 3.2 非随口记：直接走普通聊天主链路。
 			s.runNormalChatFlow(ctx, selectedModel, resolvedModelName, userMessage, ifThinking, userID, chatID, traceID, requestStart, outChan, errChan)
 			return
 		}

+		// 3.3 随口记：先发阶段状态，减少用户等待时的“无反馈感”。
 		progress := newQuickNoteProgressEmitter(outChan, resolvedModelName, true)
 		progress.Emit("request.accepted", routing.Detail)

+		// 3.4 执行随口记 graph。
 		quickHandled, quickState, quickErr := s.tryHandleQuickNoteWithGraph(
 			ctx,
 			selectedModel,
@@ -230,10 +274,12 @@ func (s *AgentService) AgentChat(ctx context.Context, userMessage string, ifThin
 			progress.Emit,
 		)
 		if quickErr != nil {
+			// graph 出错不直接中断用户请求，而是回退普通聊天，保证可用性优先。
 			log.Printf("随口记 graph 执行失败，回退普通聊天 trace_id=%s chat_id=%s err=%v", traceID, chatID, quickErr)
 		}

 		if quickHandled {
+			// 3.5 随口记处理成功：组织最终回复并按 OpenAI 兼容格式输出。
 			progress.Emit("quick_note.reply.polishing", "正在结合你的话题润色回复。")
 			quickReply := buildQuickNoteFinalReply(ctx, selectedModel, userMessage, quickState)
 			if emitErr := emitSingleAssistantCompletion(outChan, resolvedModelName, quickReply); emitErr != nil {
@@ -241,10 +287,12 @@ func (s *AgentService) AgentChat(ctx context.Context, userMessage string, ifThin
 				return
 			}

+			// 3.6 对随口记回复执行统一后置持久化（Redis + outbox/DB）。
 			s.persistChatAfterReply(ctx, userID, chatID, userMessage, quickReply, errChan)
 			return
 		}

+		// 3.7 路由误判或 graph 判定非随口记时，回落普通聊天，保证“能聊”。
 		progress.Emit("quick_note.fallback", "当前输入不是随口记请求，切换到普通对话。")
 		s.runNormalChatFlow(ctx, selectedModel, resolvedModelName, userMessage, ifThinking, userID, chatID, traceID, requestStart, outChan, errChan)
 	}()
--- a/backend/service/agentsvc/agent_quick_note.go
+++ b/backend/service/agentsvc/agent_quick_note.go
@@ -1,4 +1,4 @@
-package service
+package agentsvc

 import (
 	"context"
@@ -35,11 +35,15 @@ type quickNoteProgressEmitter struct {
 	enablePush bool
 }

+// newQuickNoteProgressEmitter 构造“阶段进度推送器”。
+// 该推送器只负责发 reasoning 块，不负责正文回复。
 func newQuickNoteProgressEmitter(outChan chan<- string, modelName string, enable bool) *quickNoteProgressEmitter {
+	// 1. 模型名兜底，避免出现空 model 字段导致客户端兼容性问题。
 	resolvedModel := strings.TrimSpace(modelName)
 	if resolvedModel == "" {
 		resolvedModel = "worker"
 	}
+	// 2. 每次请求生成独立 request_id，方便前端或日志侧关联本次流式输出。
 	return &quickNoteProgressEmitter{
 		outChan:    outChan,
 		modelName:  resolvedModel,
@@ -54,9 +58,11 @@ func newQuickNoteProgressEmitter(outChan chan<- string, modelName string, enable
 // 1) 这里不输出 role，避免和后续正文 role 块冲突；
 // 2) 即使发送失败，也只记录日志，不影响主流程继续执行。
 func (e *quickNoteProgressEmitter) Emit(stage, detail string) {
+	// 1. 推送器不可用（nil/禁用/无通道）时直接返回，避免 panic。
 	if e == nil || !e.enablePush || e.outChan == nil {
 		return
 	}
+	// 2. 统一清理空白，避免日志和输出里出现异常空字符串。
 	stage = strings.TrimSpace(stage)
 	detail = strings.TrimSpace(detail)
 	if stage == "" && detail == "" {
@@ -68,8 +74,10 @@ func (e *quickNoteProgressEmitter) Emit(stage, detail string) {
 		reasoning += "\n" + detail
 	}

+	// 3. 复用 OpenAI 兼容封装：把阶段文本伪装成 reasoning_content。
 	chunk, err := chat.ToOpenAIStream(&schema.Message{ReasoningContent: reasoning}, e.requestID, e.modelName, e.created, false)
 	if err != nil {
+		// 3.1 阶段推送失败不应影响主链路，只打日志即可。
 		log.Printf("输出随口记阶段状态失败 stage=%s err=%v", stage, err)
 		return
 	}
@@ -93,19 +101,28 @@ func (s *AgentService) tryHandleQuickNoteWithGraph(
 	trustRoute bool,
 	emitStage func(stage, detail string),
 ) (handled bool, state *quicknote.QuickNoteState, err error) {
+	// 1. 依赖预检：taskRepo 或模型未注入时，不做随口记处理，交给上层回落聊天。
 	if s.taskRepo == nil || selectedModel == nil {
 		return false, nil, nil
 	}

+	// 2. 初始化随口记状态对象（贯穿 graph 全流程的共享上下文）。
 	state = quicknote.NewQuickNoteState(traceID, userID, chatID, userMessage)
+
+	// 3. 执行 quick note graph。
+	//    本次依赖注入了两个“工具能力”：
+	//    3.1 ResolveUserID：从当前请求上下文确定 user_id；
+	//    3.2 CreateTask：真正执行任务写库。
 	finalState, runErr := quicknote.RunQuickNoteGraph(ctx, quicknote.QuickNoteGraphRunInput{
 		Model: selectedModel,
 		State: state,
 		Deps: quicknote.QuickNoteToolDeps{
 			ResolveUserID: func(ctx context.Context) (int, error) {
+				// 当前链路 userID 已由上层鉴权拿到，这里直接复用。
 				return userID, nil
 			},
 			CreateTask: func(ctx context.Context, req quicknote.QuickNoteCreateTaskRequest) (*quicknote.QuickNoteCreateTaskResult, error) {
+				// 3.2.1 把 quick note 的工具入参映射成项目 Task 模型。
 				taskModel := &model.Task{
 					UserID:      req.UserID,
 					Title:       req.Title,
@@ -113,10 +130,14 @@ func (s *AgentService) tryHandleQuickNoteWithGraph(
 					IsCompleted: false,
 					DeadlineAt:  req.DeadlineAt,
 				}
+
+				// 3.2.2 调用 DAO 写库。
 				created, createErr := s.taskRepo.AddTask(taskModel)
 				if createErr != nil {
 					return nil, createErr
 				}
+
+				// 3.2.3 把写库结果回填给 graph 状态，用于后续回复拼装。
 				return &quicknote.QuickNoteCreateTaskResult{
 					TaskID:        created.ID,
 					Title:         created.Title,
@@ -129,11 +150,15 @@ func (s *AgentService) tryHandleQuickNoteWithGraph(
 		EmitStage:              emitStage,
 	})
 	if runErr != nil {
+		// 4. graph 执行失败由上层统一决定是否回退普通聊天。
 		return false, nil, runErr
 	}
+
+	// 5. graph 正常结束但判定“非随口记”时，明确返回 handled=false。
 	if finalState == nil || !finalState.IsQuickNoteIntent {
 		return false, nil, nil
 	}
+	// 6. 走到这里表示随口记链路已完成（含写库成功或业务失败反馈文案）。
 	return true, finalState, nil
 }

@@ -142,12 +167,14 @@ func (s *AgentService) tryHandleQuickNoteWithGraph(
 // 1) 保持现有 OpenAI 兼容格式不变；
 // 2) 正文只发一次，不做伪分段。
 func emitSingleAssistantCompletion(outChan chan<- string, modelName, reply string) error {
+	// 1. 模型名兜底，保持 OpenAI 兼容响应字段完整。
 	if strings.TrimSpace(modelName) == "" {
 		modelName = "worker"
 	}
 	requestID := "chatcmpl-" + uuid.NewString()
 	created := time.Now().Unix()

+	// 2. 正文 chunk（完整一次性输出，不做人为拆片）。
 	chunk, err := chat.ToOpenAIStream(&schema.Message{Role: schema.Assistant, Content: reply}, requestID, modelName, created, true)
 	if err != nil {
 		return err
@@ -156,6 +183,7 @@ func emitSingleAssistantCompletion(outChan chan<- string, modelName, reply strin
 		outChan <- chunk
 	}

+	// 3. 按 OpenAI 风格补 finish chunk + [DONE]，确保客户端可正确收尾。
 	finishChunk, err := chat.ToOpenAIFinishStream(requestID, modelName, created)
 	if err != nil {
 		return err
@@ -171,12 +199,14 @@ func emitSingleAssistantCompletion(outChan chan<- string, modelName, reply strin
 // 2) 轻松跟进句交给 AI 生成，贴合用户话题；
 // 3) AI 生成失败时自动降级为固定友好文案，保证稳定可用。
 func buildQuickNoteFinalReply(ctx context.Context, selectedModel *ark.ChatModel, userMessage string, state *quicknote.QuickNoteState) string {
+	// 1. 极端兜底：状态为空时给出稳定失败文案，避免返回空字符串。
 	if state == nil {
 		return "我这次没成功记上，别急，再发我一次我马上补上。"
 	}

 	// 仅当“确实拿到了有效 task_id”时才走成功文案，避免出现“回复成功但库里没数据”的错觉。
 	if state.Persisted && state.PersistedTaskID > 0 {
+		// 2. 组装“事实段”：标题 + 优先级 + 截止时间。
 		title := strings.TrimSpace(state.ExtractedTitle)
 		if title == "" {
 			title = "这条任务"
@@ -193,13 +223,17 @@ func buildQuickNoteFinalReply(ctx context.Context, selectedModel *ark.ChatModel,
 		}

 		factLine := fmt.Sprintf("好，给你安排上了：%s（%s%s）。", title, priorityText, deadlineText)
+
+		// 2.1 如果 graph 单次请求已生成 banter，直接使用，避免重复调用模型。
 		if strings.TrimSpace(state.ExtractedBanter) != "" {
 			return factLine + " " + strings.TrimSpace(state.ExtractedBanter)
 		}
+		// 2.2 聚合调用模式下，通常已在主流程完成风格化，给稳定文案即可。
 		if state.PlannedBySingleCall {
 			return factLine + " 已帮你稳稳记下，放心推进。"
 		}

+		// 2.3 兜底生成轻松跟进句；失败则降级固定文案，确保体验连续。
 		banter, err := generateQuickNoteBanter(ctx, selectedModel, userMessage, title, priorityText, deadlineText)
 		if err != nil {
 			return factLine + " 这下可以先安心推进，不用等 ddl 来敲门了。"
@@ -210,13 +244,16 @@ func buildQuickNoteFinalReply(ctx context.Context, selectedModel *ark.ChatModel,
 		return factLine + " " + banter
 	}

+	// 3. 若时间校验失败，优先返回“可执行的修正引导”。
 	if strings.TrimSpace(state.DeadlineValidationError) != "" {
 		return "我识别到你给了时间，但格式不够明确，暂时不敢乱记。你可以改成比如：2026-03-20 18:30、明天下午3点、下周一上午9点，我立刻帮你安排。"
 	}

+	// 4. 若 graph 已给出助手回复（例如非意图/业务失败原因），优先透传。
 	if strings.TrimSpace(state.AssistantReply) != "" {
 		return strings.TrimSpace(state.AssistantReply)
 	}
+	// 5. 最终兜底文案。
 	return "这次没成功写入任务，我没跑路，再给我一次我就把它稳稳记上。"
 }

@@ -233,10 +270,12 @@ func generateQuickNoteBanter(
 	priorityText string,
 	deadlineText string,
 ) (string, error) {
+	// 1. 模型防御校验。
 	if selectedModel == nil {
 		return "", fmt.Errorf("model is nil")
 	}

+	// 2. 把事实信息显式塞入 prompt，约束模型只能“润色语气”。
 	prompt := fmt.Sprintf(`用户原话：%s
 已确认事实：
 - 任务标题：%s
@@ -250,11 +289,15 @@ func generateQuickNoteBanter(
 		strings.TrimSpace(deadlineText),
 	)

+	// 3. 构造消息：
+	//    - system：定义输出边界（一句话、不改事实）；
+	//    - user：提供本次上下文素材。
 	messages := []*schema.Message{
 		schema.SystemMessage(quicknote.QuickNoteReplyBanterPrompt),
 		schema.UserMessage(prompt),
 	}

+	// 4. 调用模型生成 banter，并显式关闭 thinking，减少额外延迟。
 	resp, err := selectedModel.Generate(ctx, messages,
 		ark.WithThinking(&arkModel.Thinking{Type: arkModel.ThinkingTypeDisabled}),
 		einoModel.WithTemperature(0.7),
@@ -267,6 +310,10 @@ func generateQuickNoteBanter(
 		return "", fmt.Errorf("empty response")
 	}

+	// 5. 输出清洗：
+	//    5.1 去首尾空白与引号；
+	//    5.2 若模型多行输出，只取第一行；
+	//    5.3 最终为空则视为失败，让上层走降级文案。
 	text := strings.TrimSpace(resp.Content)
 	text = strings.Trim(text, "\"'“”‘’")
 	if text == "" {
@@ -281,6 +328,8 @@ func generateQuickNoteBanter(
 // decideQuickNoteRouting 决定当前输入是否进入“随口记 graph”。
 // 该函数只是服务层薄封装，具体控制码解析逻辑已下沉到 agent/route 包。
 func (s *AgentService) decideQuickNoteRouting(ctx context.Context, selectedModel *ark.ChatModel, userMessage string) quickNoteRoutingDecision {
+	// 这里保留方法是为了让 AgentService 对外语义完整，
+	// 同时避免上层调用方直接依赖 route 包，降低耦合。
 	_ = s
 	return route.DecideQuickNoteRouting(ctx, selectedModel, userMessage)
 }
@@ -296,10 +345,12 @@ func (s *AgentService) persistChatAfterReply(
 	assistantReply string,
 	errChan chan error,
 ) {
+	// 1. 先把用户消息写入 Redis，保证会话上下文“马上可见”。
 	if err := s.agentCache.PushMessage(ctx, chatID, &schema.Message{Role: schema.User, Content: userMessage}); err != nil {
 		log.Printf("写入用户消息到 Redis 失败: %v", err)
 	}

+	// 2. 再把用户消息写入可靠持久化通道（outbox 或同步 DB）。
 	if err := s.saveChatHistoryReliable(ctx, model.ChatHistoryPersistPayload{
 		UserID:         userID,
 		ConversationID: chatID,
@@ -310,10 +361,12 @@ func (s *AgentService) persistChatAfterReply(
 		return
 	}

+	// 3. 助手消息同样遵循“Redis 先行 + 可靠持久化补齐”策略。
 	if err := s.agentCache.PushMessage(context.Background(), chatID, &schema.Message{Role: schema.Assistant, Content: assistantReply}); err != nil {
 		log.Printf("写入助手消息到 Redis 失败: %v", err)
 	}

+	// 4. 助手消息持久化失败不阻断主流程，通过 errChan 异步上报。
 	if err := s.saveChatHistoryReliable(context.Background(), model.ChatHistoryPersistPayload{
 		UserID:         userID,
 		ConversationID: chatID,
--- a/backend/service/agentsvc/agent_quick_note_route_test.go
+++ b/backend/service/agentsvc/agent_quick_note_route_test.go
@@ -1,4 +1,4 @@
-package service
+package agentsvc

 import (
 	"strings"