Version: 0.9.61.dev.260501

后端：
1. 主动调度 graph + session bridge 收口——把 dry-run / select / preview / confirm / rerun 串成受限 graph，新增 active_schedule_sessions 缓存与聊天拦截，ready_preview 后释放回自由聊天
2. 会话与通知链路对齐——notification 统一绑定 conversation_id，action_url 指向 /assistant/{conversation_id}，会话不存在改回 404 语义，避免 wrong param type 误导排障
3. estimated_sections 写入与主动调度消费链路补齐——任务创建、quick task 与随口记入口都透传估计节数，主动调度只消费落库值

前端：
4. AssistantPanel 最小适配主动调度预览与失败态——复用主动调度卡片/微调弹窗，补历史加载失败可见提示与跨账号会话拦截

文档：
5. 更新主动调度缺口分阶段实施计划和实现方案，标记阶段 0-2 收口并同步接力状态

backend/service/agent_bridge.go

@@ -16,10 +16,19 @@ type AgentService = agentsvc.AgentService
 // NewAgentService 是迁移期兼容构造函数。
 //
 // 说明：
-// 1) 外部调用签名不变，新增排程依赖通过可选方式注入（见 NewAgentServiceWithSchedule）；
-// 2) 真实构造逻辑已下沉到 service/agentsvc 包。
-func NewAgentService(aiHub *inits.AIHub, repo *dao.AgentDAO, taskRepo *dao.TaskDAO, cacheDAO *dao.CacheDAO, agentRedis *dao.AgentCache, eventPublisher outboxinfra.EventPublisher) *AgentService {
-	return agentsvc.NewAgentService(aiHub, repo, taskRepo, cacheDAO, agentRedis, eventPublisher)
+// 1) 继续保留 service 层入口形式，避免 api/cmd 侧直接感知 agentsvc 包路径；
+// 2) 主动调度 session DAO 也在这里显式透传，避免聊天入口再去回查全局单例；
+// 3) 真实构造逻辑已下沉到 service/agentsvc 包。
+func NewAgentService(
+	aiHub *inits.AIHub,
+	repo *dao.AgentDAO,
+	taskRepo *dao.TaskDAO,
+	cacheDAO *dao.CacheDAO,
+	agentRedis *dao.AgentCache,
+	activeSessionDAO *dao.ActiveScheduleSessionDAO,
+	eventPublisher outboxinfra.EventPublisher,
+) *AgentService {
+	return agentsvc.NewAgentService(aiHub, repo, taskRepo, cacheDAO, agentRedis, activeSessionDAO, eventPublisher)
 }
 
 // NewAgentServiceWithSchedule 在基础 AgentService 上注入排程依赖。
@@ -27,18 +36,19 @@ func NewAgentService(aiHub *inits.AIHub, repo *dao.AgentDAO, taskRepo *dao.TaskD
 // 设计目的：
 // 1) 通过函数注入避免 agentsvc 包直接依赖 service 层的 ScheduleService；
 // 2) 排程依赖为可选：未注入时排程路由自动回退到普通聊天；
-// 3) 保持 NewAgentService 签名不变，向下兼容。
+// 3) 主动调度 session DAO 仍沿用统一构造注入，避免排程分支自己拼装仓储。
 func NewAgentServiceWithSchedule(
 	aiHub *inits.AIHub,
 	repo *dao.AgentDAO,
 	taskRepo *dao.TaskDAO,
 	cacheDAO *dao.CacheDAO,
 	agentRedis *dao.AgentCache,
+	activeSessionDAO *dao.ActiveScheduleSessionDAO,
 	eventPublisher outboxinfra.EventPublisher,
 	scheduleSvc *ScheduleService,
 	taskSvc *TaskService,
 ) *AgentService {
-	svc := agentsvc.NewAgentService(aiHub, repo, taskRepo, cacheDAO, agentRedis, eventPublisher)
+	svc := agentsvc.NewAgentService(aiHub, repo, taskRepo, cacheDAO, agentRedis, activeSessionDAO, eventPublisher)
 
 	// 注入排程依赖：将 service 层方法包装为函数闭包，避免循环依赖。
 	if scheduleSvc != nil {

backend/service/agentsvc/agent.go

@@ -26,12 +26,13 @@ import (
 )
 
 type AgentService struct {
-	AIHub          *inits.AIHub
-	repo           *dao.AgentDAO
-	taskRepo       *dao.TaskDAO
-	cacheDAO       *dao.CacheDAO
-	agentCache     *dao.AgentCache
-	eventPublisher outboxinfra.EventPublisher
+	AIHub                    *inits.AIHub
+	repo                     *dao.AgentDAO
+	taskRepo                 *dao.TaskDAO
+	cacheDAO                 *dao.CacheDAO
+	agentCache               *dao.AgentCache
+	activeScheduleSessionDAO *dao.ActiveScheduleSessionDAO
+	eventPublisher           outboxinfra.EventPublisher
 
 	// ── 排程计划依赖（函数注入，避免 service 包循环依赖）──
 
@@ -66,24 +67,34 @@ type AgentService struct {
 	memoryCfg        memorymodel.Config
 	memoryObserver   memoryobserve.Observer
 	memoryMetrics    memoryobserve.MetricsRecorder
+	activeRerunFunc  ActiveScheduleSessionRerunFunc
 }
 
 // NewAgentService 构造 AgentService。
 // 这里通过依赖注入把“模型、仓储、缓存、异步持久化通道”统一交给服务层管理，
 // 便于后续在单测中替换实现，或在启动流程中按环境切换配置。
-func NewAgentService(aiHub *inits.AIHub, repo *dao.AgentDAO, taskRepo *dao.TaskDAO, cacheDAO *dao.CacheDAO, agentRedis *dao.AgentCache, eventPublisher outboxinfra.EventPublisher) *AgentService {
+func NewAgentService(
+	aiHub *inits.AIHub,
+	repo *dao.AgentDAO,
+	taskRepo *dao.TaskDAO,
+	cacheDAO *dao.CacheDAO,
+	agentRedis *dao.AgentCache,
+	activeSessionDAO *dao.ActiveScheduleSessionDAO,
+	eventPublisher outboxinfra.EventPublisher,
+) *AgentService {
 	// 全局注册一次 token 采集 callback：
 	// 1. 只注册一次，避免重复处理；
 	// 2. 只有带 RequestTokenMeter 的请求上下文才会真正累加。
 	ensureTokenMeterCallbackRegistered()
 
 	return &AgentService{
-		AIHub:          aiHub,
-		repo:           repo,
-		taskRepo:       taskRepo,
-		cacheDAO:       cacheDAO,
-		agentCache:     agentRedis,
-		eventPublisher: eventPublisher,
+		AIHub:                    aiHub,
+		repo:                     repo,
+		taskRepo:                 taskRepo,
+		cacheDAO:                 cacheDAO,
+		agentCache:               agentRedis,
+		activeScheduleSessionDAO: activeSessionDAO,
+		eventPublisher:           eventPublisher,
 	}
 }
 

backend/service/agentsvc/agent_active_schedule_session.go

@@ -0,0 +1,323 @@
+package agentsvc
+
+import (
+	"context"
+	"errors"
+	"log"
+	"strings"
+	"time"
+
+	"github.com/LoveLosita/smartflow/backend/model"
+	newagentstream "github.com/LoveLosita/smartflow/backend/newAgent/stream"
+	"github.com/cloudwego/eino/schema"
+)
+
+// ActiveScheduleSessionRerunFunc 表示主动调度 session 被聊天入口接管后，如何同步推进 rerun。
+//
+// 职责边界：
+// 1. 只负责把“当前 session + 用户回复”推进为新的主动调度结果；
+// 2. 不负责决定 session 何时创建，也不负责通知投递；
+// 3. 返回的结果只面向聊天入口的可见消息和 session 状态回写。
+type ActiveScheduleSessionRerunFunc func(
+	ctx context.Context,
+	session *model.ActiveScheduleSessionSnapshot,
+	userMessage string,
+	traceID string,
+	requestStart time.Time,
+) (*ActiveScheduleSessionRerunResult, error)
+
+// ActiveScheduleSessionRerunResult 是主动调度 rerun 的最小返回结果。
+//
+// 职责边界：
+// 1. 只承载聊天入口需要回写的可见消息、业务卡片和 session 状态；
+// 2. 不直接暴露 DAO 行，也不承载 worker / notification 的副作用；
+// 3. AssistantText 为空时，调用方可降级为使用卡片摘要。
+type ActiveScheduleSessionRerunResult struct {
+	AssistantText string
+	BusinessCard  *newagentstream.StreamBusinessCardExtra
+	SessionState  model.ActiveScheduleSessionState
+	SessionStatus string
+	PreviewID     string
+}
+
+// SetActiveScheduleSessionRerunFunc 注入主动调度 rerun 入口。
+func (s *AgentService) SetActiveScheduleSessionRerunFunc(fn ActiveScheduleSessionRerunFunc) {
+	s.activeRerunFunc = fn
+}
+
+// loadActiveScheduleSessionByConversation 尽量从缓存 + 数据库读取当前会话的主动调度 session。
+//
+// 步骤化说明：
+// 1. 先读 Redis 热缓存，命中则直接返回；
+// 2. 缓存未命中再回源数据库，避免把 session 状态逻辑绑死在缓存上；
+// 3. 回源成功后尽力回填缓存，减少下一轮聊天入口的 DB 压力。
+func (s *AgentService) loadActiveScheduleSessionByConversation(ctx context.Context, userID int, chatID string) (*model.ActiveScheduleSessionSnapshot, error) {
+	if s == nil || s.activeScheduleSessionDAO == nil {
+		return nil, nil
+	}
+	normalizedChatID := strings.TrimSpace(chatID)
+	if userID <= 0 || normalizedChatID == "" {
+		return nil, nil
+	}
+
+	if s.cacheDAO != nil {
+		cached, err := s.cacheDAO.GetActiveScheduleSessionFromConversationCache(ctx, userID, normalizedChatID)
+		if err != nil {
+			log.Printf("读取主动调度 session 缓存失败 user=%d chat=%s err=%v", userID, normalizedChatID, err)
+		} else if cached != nil {
+			return cached, nil
+		}
+	}
+
+	row, err := s.activeScheduleSessionDAO.GetActiveScheduleSessionByConversationID(ctx, userID, normalizedChatID)
+	if err != nil || row == nil {
+		return nil, err
+	}
+	if s.cacheDAO != nil {
+		if cacheErr := s.cacheDAO.SetActiveScheduleSessionToCache(ctx, row); cacheErr != nil {
+			log.Printf("回填主动调度 session 缓存失败 user=%d chat=%s err=%v", userID, normalizedChatID, cacheErr)
+		}
+	}
+	return row, nil
+}
+
+// persistActiveScheduleSessionBestEffort 负责把主动调度 session 的最新状态同步回 MySQL 和 Redis。
+//
+// 职责边界：
+// 1. MySQL 是最终真相，先写表再回填缓存；
+// 2. 缓存失败只记日志，不影响主流程；
+// 3. 调用方需要先把 snapshot 改成最终状态，再交给这里落盘。
+func (s *AgentService) persistActiveScheduleSessionBestEffort(ctx context.Context, snapshot *model.ActiveScheduleSessionSnapshot) error {
+	if s == nil || s.activeScheduleSessionDAO == nil || snapshot == nil {
+		return nil
+	}
+	if strings.TrimSpace(snapshot.SessionID) == "" {
+		return errors.New("active schedule session_id 不能为空")
+	}
+
+	if err := s.activeScheduleSessionDAO.UpsertActiveScheduleSession(ctx, snapshot); err != nil {
+		return err
+	}
+
+	// 1. 重新读取一遍，拿到数据库侧最终落表后的标准快照，减少缓存和 DB 的口径漂移。
+	// 2. 如果重读失败，也不影响主链路返回，只要主表已成功写入即可。
+	normalized, err := s.activeScheduleSessionDAO.GetActiveScheduleSessionBySessionID(ctx, snapshot.SessionID)
+	if err == nil && normalized != nil {
+		snapshot = normalized
+	}
+
+	if s.cacheDAO != nil {
+		if cacheErr := s.cacheDAO.SetActiveScheduleSessionToCache(ctx, snapshot); cacheErr != nil {
+			log.Printf("回填主动调度 session 缓存失败 session=%s err=%v", snapshot.SessionID, cacheErr)
+		}
+	}
+	return nil
+}
+
+// handleActiveScheduleSessionChat 处理被主动调度 session 占管的聊天入口。
+//
+// 步骤化说明：
+// 1. 先读 session，判断当前 conversation 是否仍在 waiting_user_reply / rerunning 占管期；
+// 2. 占管期间先把用户消息写入历史和时间线，保证会话内容不丢失；
+// 3. waiting_user_reply 进入 rerunning，并同步调用主动调度 rerun；
+// 4. rerunning 则只提示“正在重跑”，避免同一 conversation 被并发重复推进；
+// 5. 终态或非占管态直接放行普通 newAgent。
+func (s *AgentService) handleActiveScheduleSessionChat(
+	ctx context.Context,
+	userMessage string,
+	traceID string,
+	requestStart time.Time,
+	userID int,
+	chatID string,
+	resolvedModelName string,
+	outChan chan<- string,
+	errChan chan error,
+) (bool, error) {
+	session, err := s.loadActiveScheduleSessionByConversation(ctx, userID, chatID)
+	if err != nil {
+		return false, err
+	}
+	if session == nil || !isActiveScheduleSessionBlockingStatus(session.Status) {
+		return false, nil
+	}
+
+	trimmedMessage := strings.TrimSpace(userMessage)
+	if trimmedMessage != "" {
+		// 1. 主动调度占管期间，用户每次回复仍然要进入正常会话历史。
+		// 2. 这样后续刷新聊天页时，用户可见消息、时间线和 session 状态不会彼此脱节。
+		if err := s.persistNewAgentConversationMessage(ctx, userID, chatID, schema.UserMessage(trimmedMessage), 0); err != nil {
+			return true, err
+		}
+	}
+
+	switch session.Status {
+	case model.ActiveScheduleSessionStatusWaitingUserReply:
+		if trimmedMessage == "" {
+			assistantText := strings.TrimSpace(session.State.PendingQuestion)
+			if assistantText == "" {
+				assistantText = "请先补充主动调度需要的关键信息。"
+			}
+			if err := s.persistNewAgentConversationMessage(ctx, userID, chatID, schema.AssistantMessage(assistantText, nil), 0); err != nil {
+				return true, err
+			}
+			emitActiveScheduleAssistantChunk(outChan, traceID, resolvedModelName, requestStart, assistantText, nil)
+			return true, nil
+		}
+		// 1. 收到用户补充信息后，先把 session 切成 rerunning，避免并发请求继续按旧状态走普通聊天。
+		// 2. 这个阶段只是状态切换，不代表 graph 已经完成。
+		session.Status = model.ActiveScheduleSessionStatusRerunning
+		if err := s.persistActiveScheduleSessionBestEffort(ctx, session); err != nil {
+			return true, err
+		}
+		return true, s.runActiveScheduleSessionRerun(ctx, session, trimmedMessage, traceID, requestStart, resolvedModelName, outChan, errChan)
+	case model.ActiveScheduleSessionStatusRerunning:
+		// 1. rerunning 是占管中的过渡态，说明当前会话已经在重跑或刚开始重跑。
+		// 2. 这里不再触发第二次 rerun，只给用户一个可见的等待提示。
+		if trimmedMessage != "" {
+			assistantText := "主动调度正在重新生成建议，请稍后再试。"
+			if err := s.persistNewAgentConversationMessage(ctx, userID, chatID, schema.AssistantMessage(assistantText, nil), 0); err != nil {
+				return true, err
+			}
+			emitActiveScheduleAssistantChunk(outChan, traceID, resolvedModelName, requestStart, assistantText, nil)
+		}
+		return true, nil
+	default:
+		return false, nil
+	}
+}
+
+// runActiveScheduleSessionRerun 负责把 waiting_user_reply 的用户补充同步推进成新的主动调度结果。
+//
+// 职责边界：
+// 1. 只负责聊天入口的最小编排，不复制 worker / notification 链路；
+// 2. 成功时把新 preview / ask_user / close 的结果写回 session + timeline；
+// 3. 失败时把 session 标成 failed，方便后续排障。
+func (s *AgentService) runActiveScheduleSessionRerun(
+	ctx context.Context,
+	session *model.ActiveScheduleSessionSnapshot,
+	userMessage string,
+	traceID string,
+	requestStart time.Time,
+	resolvedModelName string,
+	outChan chan<- string,
+	errChan chan error,
+) error {
+	if s == nil || s.activeRerunFunc == nil {
+		return errors.New("主动调度 rerun 未接入")
+	}
+	if session == nil {
+		return errors.New("active schedule session 不能为空")
+	}
+
+	result, err := s.activeRerunFunc(ctx, session, userMessage, traceID, requestStart)
+	if err != nil {
+		session.Status = model.ActiveScheduleSessionStatusFailed
+		session.State.FailedReason = strings.TrimSpace(err.Error())
+		_ = s.persistActiveScheduleSessionBestEffort(ctx, session)
+		return err
+	}
+	if result == nil {
+		result = &ActiveScheduleSessionRerunResult{}
+	}
+
+	finalStatus := strings.TrimSpace(result.SessionStatus)
+	if finalStatus == "" {
+		if result.BusinessCard != nil {
+			finalStatus = model.ActiveScheduleSessionStatusReadyPreview
+		} else {
+			finalStatus = model.ActiveScheduleSessionStatusWaitingUserReply
+		}
+	}
+	session.Status = finalStatus
+	session.State = result.SessionState
+	if strings.TrimSpace(result.PreviewID) != "" {
+		session.CurrentPreviewID = strings.TrimSpace(result.PreviewID)
+	} else if session.Status != model.ActiveScheduleSessionStatusReadyPreview {
+		session.CurrentPreviewID = ""
+	}
+	if session.Status == model.ActiveScheduleSessionStatusReadyPreview {
+		session.State.PendingQuestion = ""
+		session.State.MissingInfo = nil
+		session.State.FailedReason = ""
+	}
+
+	if err := s.persistActiveScheduleSessionBestEffort(ctx, session); err != nil {
+		return err
+	}
+
+	assistantText := strings.TrimSpace(result.AssistantText)
+	if assistantText == "" && result.BusinessCard != nil {
+		assistantText = strings.TrimSpace(result.BusinessCard.Summary)
+	}
+	if assistantText == "" {
+		assistantText = "主动调度建议已更新。"
+	}
+
+	// 1. 把新结果写进 conversation history，保证刷新后仍然能看到 rerun 的正文。
+	// 2. 再追加业务卡片时间线，前端可以按 timeline 重建主动调度卡片。
+	if err := s.persistNewAgentConversationMessage(ctx, session.UserID, session.ConversationID, schema.AssistantMessage(assistantText, nil), 0); err != nil {
+		return err
+	}
+	if result.BusinessCard != nil {
+		if _, err := s.appendConversationTimelineEvent(
+			ctx,
+			session.UserID,
+			session.ConversationID,
+			model.AgentTimelineKindBusinessCard,
+			"assistant",
+			assistantText,
+			map[string]any{"business_card": result.BusinessCard},
+			0,
+		); err != nil {
+			return err
+		}
+	}
+
+	emitActiveScheduleAssistantChunk(outChan, traceID, resolvedModelName, requestStart, assistantText, nil)
+	if result.BusinessCard != nil {
+		emitActiveScheduleBusinessCardChunk(outChan, session.SessionID, traceID, resolvedModelName, requestStart, result.BusinessCard)
+	}
+	return nil
+}
+
+func isActiveScheduleSessionBlockingStatus(status string) bool {
+	switch strings.ToLower(strings.TrimSpace(status)) {
+	case model.ActiveScheduleSessionStatusWaitingUserReply,
+		model.ActiveScheduleSessionStatusRerunning:
+		return true
+	default:
+		return false
+	}
+}
+
+func emitActiveScheduleAssistantChunk(outChan chan<- string, traceID string, modelName string, requestStart time.Time, text string, extra *newagentstream.OpenAIChunkExtra) {
+	payload, err := newagentstream.ToOpenAIAssistantChunkWithExtra(traceID, modelName, requestStart.Unix(), strings.TrimSpace(text), true, extra)
+	if err != nil {
+		log.Printf("构造主动调度 assistant chunk 失败 trace=%s err=%v", traceID, err)
+		return
+	}
+	pushChunkNonBlocking(outChan, payload)
+}
+
+func emitActiveScheduleBusinessCardChunk(outChan chan<- string, blockID string, traceID string, modelName string, requestStart time.Time, card *newagentstream.StreamBusinessCardExtra) {
+	if card == nil {
+		return
+	}
+	payload, err := newagentstream.ToOpenAIStreamWithExtra(nil, traceID, modelName, requestStart.Unix(), true, newagentstream.NewBusinessCardExtra(blockID, "active_schedule_session", card))
+	if err != nil {
+		log.Printf("构造主动调度 business card chunk 失败 trace=%s err=%v", traceID, err)
+		return
+	}
+	pushChunkNonBlocking(outChan, payload)
+}
+
+func pushChunkNonBlocking(outChan chan<- string, payload string) {
+	if outChan == nil || strings.TrimSpace(payload) == "" {
+		return
+	}
+	select {
+	case outChan <- payload:
+	default:
+		log.Printf("主动调度 SSE 通道已满，丢弃 payload")
+	}
+}

backend/service/agentsvc/agent_newagent.go

@@ -87,12 +87,21 @@ func (s *AgentService) runNewAgentGraph(
 
 	// 3. retry 机制已下线，不再构建重试元数据。
 
-	// 4. 从 StateStore 加载或创建 RuntimeState。
+	// 4. 如果当前 conversation 被主动调度 session 占管，先走 session 分支，不进入普通 newAgent。
+	//    这样 waiting_user_reply / rerunning 期间，用户消息会先推动主动调度闭环，而不是误进自由聊天。
+	if handled, sessionErr := s.handleActiveScheduleSessionChat(requestCtx, userMessage, traceID, requestStart, userID, chatID, resolvedModelName, outChan, errChan); sessionErr != nil {
+		pushErrNonBlocking(errChan, sessionErr)
+		return
+	} else if handled {
+		return
+	}
+
+	// 5. 从 StateStore 加载或创建 RuntimeState。
 	//    恢复场景（confirm/ask_user）同时拿到快照中保存的 ConversationContext，
 	//    其中包含工具调用/结果等中间消息，保证后续 LLM 调用的消息链完整。
 	runtimeState, savedConversationContext, savedScheduleState, savedOriginalScheduleState := s.loadOrCreateRuntimeState(requestCtx, chatID, userID)
 
-	// 5. 构造 ConversationContext。
+	// 6. 构造 ConversationContext。
 	//    优先使用快照中恢复的 ConversationContext（含工具调用/结果），
 	//    无快照时从 Redis LLM 历史缓存加载。
 	var conversationContext *newagentmodel.ConversationContext
@@ -105,17 +114,17 @@ func (s *AgentService) runNewAgentGraph(
 	} else {
 		conversationContext = s.loadConversationContext(requestCtx, chatID, userMessage)
 	}
-	// 5.1. 在 graph 执行前统一补充与当前输入相关的记忆上下文（预取管线模式）。
-	// 5.1.1 先读 Redis 预取缓存注入到 ConversationContext，再启动后台 goroutine 做完整检索；
-	// 5.1.2 返回的 channel 传入 Deps，供 Execute/Plan 节点在启动前消费最新记忆；
-	// 5.1.3 检索失败只降级为"本轮不注入记忆"，不阻断主链路。
+	// 6.1. 在 graph 执行前统一补充与当前输入相关的记忆上下文（预取管线模式）。
+	// 6.1.1 先读 Redis 预取缓存注入到 ConversationContext，再启动后台 goroutine 做完整检索；
+	// 6.1.2 返回的 channel 传入 Deps，供 Execute/Plan 节点在启动前消费最新记忆；
+	// 6.1.3 检索失败只降级为"本轮不注入记忆"，不阻断主链路。
 	memoryFuture := s.injectMemoryContext(requestCtx, conversationContext, userID, chatID, userMessage)
 
-	// 5.5 将前端传入的 thinkingMode 写入 CommonState，供 ChatNode 及下游节点读取。
+	// 6.5 将前端传入的 thinkingMode 写入 CommonState，供 ChatNode 及下游节点读取。
 	cs := runtimeState.EnsureCommonState()
 	cs.ThinkingMode = thinkingMode
 
-	// 5.6 若 extra 携带 task_class_ids，校验后写入 CommonState（仅首轮/尚未设置时生效，跨轮持久化）。
+	// 6.6 若 extra 携带 task_class_ids，校验后写入 CommonState（仅首轮/尚未设置时生效，跨轮持久化）。
 	if taskClassIDs := readAgentExtraIntSlice(extra, "task_class_ids"); len(taskClassIDs) > 0 {
 		cs := runtimeState.EnsureCommonState()
 		if len(cs.TaskClassIDs) == 0 {
@@ -135,7 +144,7 @@ func (s *AgentService) runNewAgentGraph(
 
 	cs = runtimeState.EnsureCommonState()
 
-	// 5.7 先把本轮用户输入落库，确保后续可见 assistant 消息按真实时间线追加。
+	// 6.7 先把本轮用户输入落库，确保后续可见 assistant 消息按真实时间线追加。
 	userMsg := schema.UserMessage(userMessage)
 	if err := s.persistNewAgentConversationMessage(requestCtx, userID, chatID, userMsg, 0); err != nil {
 		pushErrNonBlocking(errChan, err)
@@ -158,7 +167,7 @@ func (s *AgentService) runNewAgentGraph(
 		return s.persistNewAgentConversationMessage(persistCtx, userID, chatID, msg, 0)
 	}
 
-	// 6. 构造 AgentGraphRequest。
+	// 7. 构造 AgentGraphRequest。
 	var (
 		confirmAction       string
 		resumeInteractionID string
@@ -175,16 +184,16 @@ func (s *AgentService) runNewAgentGraph(
 	}
 	graphRequest.Normalize()
 
-	// 7. 适配 LLM clients（从 AIHub 的 ark.ChatModel 转换为 newAgent LLM Client）。
-	// 7.1 Chat/Deliver 使用 Pro 模型：路由分流、闲聊、交付总结属于标准复杂度。
-	// 7.2 Plan/Execute 使用 Max 模型：规划和 ReAct 循环需要深度推理能力。
+	// 8. 适配 LLM clients（从 AIHub 的 ark.ChatModel 转换为 newAgent LLM Client）。
+	// 8.1 Chat/Deliver 使用 Pro 模型：路由分流、闲聊、交付总结属于标准复杂度。
+	// 8.2 Plan/Execute 使用 Max 模型：规划和 ReAct 循环需要深度推理能力。
 	chatClient := infrallm.WrapArkClient(s.AIHub.Pro)
 	planClient := infrallm.WrapArkClient(s.AIHub.Max)
 	executeClient := infrallm.WrapArkClient(s.AIHub.Max)
 	deliverClient := infrallm.WrapArkClient(s.AIHub.Pro)
 	summaryClient := infrallm.WrapArkClient(s.AIHub.Lite)
 
-	// 8. 适配 SSE emitter。
+	// 9. 适配 SSE emitter。
 	sseEmitter := newagentstream.NewSSEPayloadEmitter(outChan)
 	chunkEmitter := newagentstream.NewChunkEmitter(sseEmitter, traceID, resolvedModelName, requestStart.Unix())
 	chunkEmitter.SetReasoningSummaryFunc(s.makeReasoningSummaryFunc(summaryClient))
@@ -193,7 +202,7 @@ func (s *AgentService) runNewAgentGraph(
 		s.persistNewAgentTimelineExtraEvent(context.Background(), userID, chatID, extra)
 	})
 
-	// 9. 构造 AgentGraphDeps（由 cmd/start.go 注入的依赖）。
+	// 10. 构造 AgentGraphDeps（由 cmd/start.go 注入的依赖）。
 	deps := newagentmodel.AgentGraphDeps{
 		ChatClient:            chatClient,
 		PlanClient:            planClient,
@@ -214,7 +223,7 @@ func (s *AgentService) runNewAgentGraph(
 		QuickTaskDeps:         s.quickTaskDeps,
 	}
 
-	// 10. 构造 AgentGraphRunInput 并运行 graph。
+	// 11. 构造 AgentGraphRunInput 并运行 graph。
 	runInput := newagentmodel.AgentGraphRunInput{
 		RuntimeState:          runtimeState,
 		ConversationContext:   conversationContext,
@@ -240,10 +249,10 @@ func (s *AgentService) runNewAgentGraph(
 		return
 	}
 
-	// 11. 持久化聊天历史（用户消息 + 助手回复）。
+	// 12. 持久化聊天历史（用户消息 + 助手回复）。
 	requestTotalTokens := snapshotRequestTokenMeter(requestCtx).TotalTokens
 	s.adjustNewAgentRequestTokenUsage(requestCtx, userID, chatID, requestTotalTokens)
-	// 11.5. 将最终状态快照异步写入 MySQL（通过 outbox）。
+	// 12.5. 将最终状态快照异步写入 MySQL（通过 outbox）。
 	// Deliver 节点已将快照保存到 Redis（2h TTL），此处通过 outbox 异步写入 MySQL 做永久存储。
 	if finalState != nil {
 		snapshot := &newagentmodel.AgentStateSnapshot{
@@ -253,7 +262,7 @@ func (s *AgentService) runNewAgentGraph(
 		eventsvc.PublishAgentStateSnapshot(requestCtx, s.eventPublisher, snapshot, chatID, userID)
 	}
 
-	// 11.6. graph 完成后条件触发记忆抽取。
+	// 12.6. graph 完成后条件触发记忆抽取。
 	// 说明：
 	// 1. 只有本轮未走快捷随口记任务路径时才触发记忆抽取；
 	// 2. 避免随口记创建的 Task 与记忆系统产生语义冲突。
@@ -269,10 +278,10 @@ func (s *AgentService) runNewAgentGraph(
 	// 排程预览缓存由 Deliver 节点负责写入（通过注入的 WriteSchedulePreview func），
 	// 保证只有任务真正完成时才写，中断路径不写中间态。
 
-	// 12. 发送 OpenAI 兼容的流式结束标记，告知客户端 stream 已完成。
+	// 13. 发送 OpenAI 兼容的流式结束标记，告知客户端 stream 已完成。
 	_ = chunkEmitter.EmitDone()
 
-	// 13. 异步生成会话标题。
+	// 14. 异步生成会话标题。
 	s.ensureConversationTitleAsync(userID, chatID)
 }
 

backend/service/agentsvc/agent_task_query.go

@@ -67,6 +67,7 @@ func (s *AgentService) QueryTasksForTool(ctx context.Context, req newagentmodel.
 			ID:                 task.ID,
 			Title:              task.Title,
 			PriorityGroup:      task.Priority,
+			EstimatedSections:  model.NormalizeEstimatedSections(&task.EstimatedSections),
 			IsCompleted:        task.IsCompleted,
 			DeadlineAt:         task.DeadlineAt,
 			UrgencyThresholdAt: task.UrgencyThresholdAt,