Version: 0.9.4.dev.260407

后端：
1.粗排结果/预览语义修复（task_item suggested 保真 + existing/嵌入识别补全）
- 更新conv/schedule_state.go：LoadScheduleState 补齐 event.rel_id / schedules.embedded_task_id / task_item.embedded_time 三种“已落位”信号；嵌入任务强制 existing + 继承 host slots；补充 task_item duration/name/slot helper；Diff 相关英文注释改中文
- 更新conv/schedule_preview.go：预览层新增 shouldMarkSuggestedInPreview，pending 任务与 source=task_item 的建议态任务统一输出 suggested
2.newAgent 状态快照增强（ScheduleState/OriginalScheduleState 跨轮恢复）
- 更新model/state_store.go：AgentStateSnapshot 新增 ScheduleState / OriginalScheduleState
- 更新model/graph_run_state.go：AgentGraphRunInput/AgentGraphState 接入两份 schedule 状态；恢复旧快照时自动补 original clone
- 更新service/agentsvc/agent_newagent.go：loadOrCreateRuntimeState 返回并恢复 schedule/original；runNewAgentGraph 透传到 graph
- 更新node/agent_nodes.go：saveAgentState 一并保存 schedule/original 到 Redis 快照 3.Execute 链路纠偏（只写内存不落库 + 完整打点 + 恢复消息去重）
- 更新node/execute.go：AlwaysExecute/confirm resume 路径取消 PersistScheduleChanges，仅保留内存写；新增 execute LLM 完整上下文日志；新增工具调用前后 state 摘要日志；thinking 模式改为 enabled
- 更新node/chat.go：pending resume 不再重复写入同一轮 user message
- 更新service/agentsvc/agent_newagent.go：新增 deliver preview write/state 摘要日志，便于排查 suggested 丢失问题
4.AlwaysExecute 贯通 Plan→Graph→Execute
- 更新node/plan.go：PlanNodeInput 新增 AlwaysExecute；plan_done 后支持自动确认直接进入执行
- 更新graph/common_graph.go：branchAfterPlan 支持 PhaseExecuting/PhaseDone 分支
5.排课上下文补强（显式注入 task_class_ids，减少 Execute 误 ask_user）
- 更新prompt/execute.go：Plan/ReAct 两种 execute prompt 都显式写入任务类 ID，声明“上下文已完整，无需追问”
- 更新node/rough_build.go：粗排完成 pinned block 显式标注任务类 ID，避免 Execute 找不到 ID 来源
6.流式输出与预览调试工具修复
- 更新stream/emitter.go：保留换行，修复 pseudo stream 分片后文本黏连/双换行问题
- 更新infra/schedule_preview_viewer.html：升级预览工具，支持 candidate_plans / hybrid_entries

前端：无
仓库：
1.更新了infra内的html，适应了获取日程接口

backend/newAgent/HANDOFF_粗排修复与Prompt重构.md

@@ -0,0 +1,322 @@
+# Handoff
+
+以下内容可直接交给下一位助理继续做。
+
+## 目标
+
+当前有两条主线要继续推进：
+
+1. 粗排算法修复与链路纠偏  
+目标：粗排完成后，不应该再把 LLM 引导到“手动一个个 `place` 补洞”。如果粗排后仍有 `pending`，按当前业务理解，这属于异常，应直接终止并报错，而不是继续优化或补排。
+
+2. `execute` 上下文瘦身 + 可插拔 prompt 重构  
+目标：把现在的“消息流水账堆砌”改成“结构化执行简报”，并且 prompt 不能写死成排程专用，要能复用于排程、加任务、学习计划等不同任务域。
+
+## 用户已经明确确认的业务结论
+
+- `always_execute`、后端是否自动放行、是否写库，这些是后端执行层语义，不应写进 prompt。
+- LLM 只需要按统一协议产出 `continue / confirm / ask_user / done / abort` 这类动作；后端怎么处理是后端自己的事。
+- 对排程场景，LLM 的主要职责是“粗排后的优化器”，不是“粗排补洞工”。
+- 如果“粗排完成后仍有 pending 任务”，这不是要让 LLM 手工 `place` 的正常状态，而是异常状态。
+- prompt 需要明显的文字引导，必须有编号和子编号，让 LLM 每轮都收到一份规范文本。
+- prompt 必须是可插拔的，不能写死成“排程优化”专用。
+
+## 已经完成的改动
+
+- 已修复“同一轮 user message 重复写入上下文”的问题。  
+实现位置：`backend/newAgent/node/chat.go`  
+改动点：`handleChatResume` 不再重复 `AppendHistory(schema.UserMessage(...))`，现在 user message 只在 service 层统一写入一次。
+
+- 已经给 `execute` 节点加了完整上下文调试打点。  
+实现位置：`backend/newAgent/node/execute.go`  
+关键函数：`formatExecuteLLMMessagesForDebug`
+
+- 之前已经做过一轮粗排结果接入修复：`makeRoughBuildFunc` 改为使用 `HybridScheduleWithPlanMultiFunc` 的 `entries` 结果，而不是只看 `[]TaskClassItem`。  
+实现位置：`backend/service/agentsvc/agent_newagent.go`
+
+## 当前上下文链路的真实现状
+
+`execute` 真正喂给 LLM 的消息来自：
+
+- `backend/newAgent/node/execute.go`
+- `backend/newAgent/prompt/execute.go`
+- `backend/newAgent/prompt/base.go`
+
+当前拼装顺序是：
+
+- `system`：基础 persona + execute 阶段规则
+- `system`：工具摘要
+- `history`：完整历史消息
+- `system`：pinned blocks
+- `user`：运行时执行提示词
+
+这套链路的核心问题不是“少了什么”，而是“保留了太多不该保留的东西”。
+
+## 已确认的上下文膨胀问题
+
+基于用户提供的第 13 轮上下文样本，当前冗余主要有这些：
+
+- 大型 `tool result` 长期保留。  
+典型是 `get_overview`、`list_tasks`、`find_free` 的超长结果被反复塞进 history。
+
+- 同工具同参数的重复查询长期保留。  
+例如 `find_free(duration=2)` 连续多次查询，主体内容几乎相同；`list_tasks(all)` 与 `get_overview` 也重复大量信息。
+
+- 大量 assistant 过程性话术进入 history。  
+例如“我先查一下”“我需要先获取”“我将安排……请确认”这类文本，对后续决策价值很低，却持续吃 token。
+
+- 失败回合被原样保留。  
+例如 `place` 缺 `task_id`、`find_free` 缺 `duration` 的失败记录，不需要完整原文链路，只需要摘要化保留“最近失败模式”。
+
+- 指令层重复。  
+`renderStateSummary`、pinned blocks、运行时 user prompt 存在明显重叠。
+
+- `newAgent` 目前没有接旧链路那套历史 token budget 裁剪。  
+对照位置：
+  - 新链路：`backend/service/agentsvc/agent_newagent.go`
+  - 旧链路：`backend/service/agentsvc/agent.go`
+  - token budget 工具：`backend/pkg/token_budget.go`
+
+## 当前排程链路里最需要纠偏的错误引导
+
+当前这段逻辑已经不符合用户现在确认的业务前提：
+
+- `backend/newAgent/node/rough_build.go`
+
+这里现在会在粗排后写入一段 pinned 文本，大意是：
+
+- 如果还有 `pending`，就让 LLM 去 `get_overview/find_free/place`
+- 重复 place，直到 pending 归零
+
+这段引导现在应视为错误业务语义。下一位助理需要重点改掉它。
+
+## 粗排算法主线的交接意见
+
+下一位助理要继续查两件事：
+
+- 粗排算法本体是否真的仍会漏排。  
+重点排查：
+  - `makeRoughBuildFunc`
+  - `RunRoughBuildNode`
+  - `placements` 写入 `ScheduleState` 后，是否所有目标任务都应有初始落位
+
+- 如果业务上“粗排不应漏排”已经成立，那么链路要改成：
+  - 粗排完成且 `pending > 0`：直接异常结束
+  - 不再把 LLM 引导成“手工补排”
+  - 最好在执行层支持 `abort` 语义，而不是让模型继续乱试
+
+## prompt 重构主线的交接意见
+
+用户已经认可的新方向是：把 prompt 改成“通用执行内核 + 可插拔领域模块 + 当前任务简报”。
+
+推荐的 3-message 结构如下。
+
+### 第一条消息：通用执行内核
+
+职责：
+
+- 定义 agent 身份
+- 定义通用规则
+- 定义通用动作协议
+- 提供最小必要的 JSON 示例
+
+### 第二条消息：领域模块
+
+职责：
+
+- 注入当前领域名称、职责边界、目标、非目标
+- 注入领域工具简表
+- 注入领域硬约束、软目标
+- 注入异常定义与完成判定
+
+### 第三条消息：运行时任务简报
+
+职责：
+
+- 给出用户原始目标与最新补充
+- 给出当前实例级约束
+- 给出最新状态快照
+- 给出最近操作摘要
+- 给出上一次工具调用结果
+- 给出本轮目标
+
+## 用户已经认可的 prompt 设计原则
+
+- 必须保留 JSON 示例，否则 LLM 容易不会按协议输出。
+- prompt 必须有显式编号和子编号，例如 `1. / 1.1 / 2.1`。
+- prompt 不能写死成排程专用。
+- 排程只是一个领域模块示例，不是通用内核的一部分。
+- 对排程领域来说，应明确：
+  - 这是“粗排后的优化器”
+  - 不是“补排器”
+  - `pending > 0` 是异常条件，不是待办事项
+- 对不同领域，应通过占位参数注入，不要把具体业务写进通用层。
+
+## 已产出的可插拔 prompt 方案要点
+
+建议最终落地成这三层：
+
+### 通用执行内核
+
+- 身份
+- 通用规则
+- 通用动作协议
+- 输出字段定义
+- 最小 JSON 示例
+
+### 领域模块
+
+- `domain_name`
+- `task_type`
+- `domain_primary_responsibility`
+- `domain_out_of_scope`
+- `domain_goals`
+- `domain_non_goals`
+- `tool_catalog_brief`
+- `tool_usage_rules`
+- `tool_required_args_rules`
+- `tool_common_failures`
+- `hard_constraints`
+- `soft_objectives`
+- `abort_conditions`
+- `abort_handling_rules`
+- `done_conditions`
+- `abort_output_conditions`
+
+### 运行时任务简报
+
+- `original_user_goal`
+- `latest_user_instruction`
+- `current_effective_goal`
+- `current_phase`
+- `current_round`
+- `instance_constraints`
+- `latest_state_summary`
+- `latest_state_delta`
+- `latest_risks`
+- `recent_operation_summary`
+- `recent_failure_patterns`
+- `last_tool_name`
+- `last_tool_arguments_summary`
+- `last_tool_result_summary`
+- `last_tool_success`
+- `last_tool_state_change`
+- `last_tool_takeaway`
+- `current_round_goal`
+- `recommended_next_action`
+
+## 排程领域的具体模块语义
+
+如果当前领域是“粗排后的排程优化”，建议这样填：
+
+- `domain_name = schedule_optimization`
+- `domain_primary_responsibility = 在粗排结果基础上优化排程质量`
+- `domain_out_of_scope = 手工补排粗排遗漏任务`
+- `domain_goals = 更均匀、更符合学习规律、更平衡每日负载`
+- `domain_non_goals = 把 pending 任务一个个 place 进去`
+- `abort_conditions = 粗排完成后仍有 pending 任务`
+- `abort_handling_rules = 不再继续优化，不再 place，直接 abort`
+- `done_conditions = 方案满足硬约束且整体分布合理`
+
+## 代码层建议的实施顺序
+
+建议下一位助理按这个顺序做，风险最低：
+
+1. 先改粗排后 pinned 引导  
+重点文件：`backend/newAgent/node/rough_build.go`  
+目标：删掉“pending 继续 place”的提示，换成“pending 是异常”的提示。
+
+2. 再补 `abort` 动作语义  
+重点文件：
+  - `backend/newAgent/node/execute.go`
+  - 相关 decision model 定义文件
+  - 可能涉及 deliver / graph 分支  
+目标：让 LLM 可以正规地终止异常流程，而不是只能 continue / done / ask_user / confirm。
+
+3. 再做 prompt 结构重构  
+重点文件：
+  - `backend/newAgent/prompt/base.go`
+  - `backend/newAgent/prompt/execute.go`
+  - 如有必要，可新增一个领域模块文件  
+目标：把目前“system/tool/history/pinned/runtime prompt”重组为“通用内核 + 领域模块 + 任务简报”。
+
+4. 最后再做历史瘦身  
+目标：
+  - 同工具同参数结果只保留最近一份原文
+  - 更早历史改摘要
+  - assistant 废话不入 history
+  - 失败模式摘要化
+  - 必要时接入 token budget
+
+## 关于历史瘦身，已达成的结论
+
+下一位助理可以直接照这个原则做：
+
+- 不再把几十条 `assistant/tool` 原始流水账直接喂给模型
+- 把历史改成“状态快照 + 最近摘要 + 上一次结果 + 本轮目标”
+- `tool result` 只保留：
+  - 最新一条原文
+  - 更早的同类结果摘要
+- 重复查询要压缩：
+  - 同工具同参数只保留最新一条
+- assistant 过程话术要剔除：
+  - “我先查一下”“我将继续……”之类原则上不入模型历史
+- 保留最近失败模式：
+  - 例如 `place` 缺 `task_id`
+  - 例如 `find_free` 缺 `duration`
+
+## 测试与验证注意事项
+
+- 运行 `go test` 后，必须清理项目根目录 `.gocache`。
+- 当前环境可能会因为网络限制导致 `go test` 拉依赖失败；之前已经出现过这种情况。
+- 项目要求：
+  - 注释、接口文案、说明、评审反馈都用中文
+  - 文件编码 UTF-8（无 BOM）
+  - 不要把 agent 改回写库逻辑；当前用户明确要求 agent 操作只写内存，不写数据库
+- 代码中若改动复杂逻辑，注释要同步更新，且注释必须用中文
+
+## 关键文件清单
+
+- 执行节点与上下文打点：`backend/newAgent/node/execute.go`
+- prompt 拼装基础：`backend/newAgent/prompt/base.go`
+- execute prompt：`backend/newAgent/prompt/execute.go`
+- 粗排节点：`backend/newAgent/node/rough_build.go`
+- graph 节点装配：`backend/newAgent/node/agent_nodes.go`
+- newAgent service 入口：`backend/service/agentsvc/agent_newagent.go`
+- 旧链路 token budget 参考：`backend/service/agentsvc/agent.go`
+- token budget 工具：`backend/pkg/token_budget.go`
+
+## 一句话总结给下一位助理
+
+当前要做的，不是继续 patch 某个 prompt 文案，而是同时完成两件事：
+
+- 把“粗排后 pending 还让 LLM 手工补排”的错误业务语义彻底清掉
+- 把 `execute` 从“消息流水账喂模”重构成“通用执行内核 + 可插拔领域模块 + 运行时任务简报”的结构化 prompt
+
+## TODO Checklist
+
+### 粗排算法与异常语义
+
+- [ ] 确认粗排算法本体是否真的会漏排
+- [ ] 确认 `placements` 写入 `ScheduleState` 后是否所有目标任务都已有初始落位
+- [ ] 删除 `rough_build` 节点里“pending 继续 place”的错误提示
+- [ ] 改成“粗排后 pending > 0 即异常”的提示语义
+- [ ] 在执行决策层补齐 `abort` 动作语义
+
+### Prompt 重构
+
+- [ ] 抽出通用执行内核 prompt
+- [ ] 抽出领域模块 prompt
+- [ ] 抽出运行时任务简报拼装逻辑
+- [ ] 保留最小必要 JSON 示例
+- [ ] 清除后端执行层语义对 LLM 的干扰
+- [ ] 让排程领域以模块方式接入，而不是写死在内核
+
+### 历史瘦身
+
+- [ ] 同工具同参数仅保留最新一条原文
+- [ ] 更早同类结果改为摘要
+- [ ] assistant 过程性废话不再进入模型历史
+- [ ] 最近失败模式摘要化保留
+- [ ] 必要时接入 token budget
+

backend/newAgent/graph/common_graph.go

@@ -189,6 +189,15 @@ func branchAfterPlan(_ context.Context, st *newagentmodel.AgentGraphState) (stri
 	if flowState.Phase == newagentmodel.PhaseWaitingConfirm {
 		return NodeConfirm, nil
 	}
+	if flowState.Phase == newagentmodel.PhaseExecuting {
+		if flowState.NeedsRoughBuild && st.Deps.RoughBuildFunc != nil {
+			return NodeRoughBuild, nil
+		}
+		return NodeExecute, nil
+	}
+	if flowState.Phase == newagentmodel.PhaseDone {
+		return NodeDeliver, nil
+	}
 	return NodePlan, nil
 }
 

backend/newAgent/model/graph_run_state.go

@@ -147,10 +147,12 @@ func (d *AgentGraphDeps) ResolveDeliverClient() *newagentllm.Client {
 // 3. Request：当前这次请求的轻量输入；
 // 4. Deps：graph/node 层真正依赖的可插拔能力。
 type AgentGraphRunInput struct {
-	RuntimeState        *AgentRuntimeState
-	ConversationContext *ConversationContext
-	Request             AgentGraphRequest
-	Deps                AgentGraphDeps
+	RuntimeState          *AgentRuntimeState
+	ConversationContext   *ConversationContext
+	ScheduleState         *newagenttools.ScheduleState
+	OriginalScheduleState *newagenttools.ScheduleState
+	Request               AgentGraphRequest
+	Deps                  AgentGraphDeps
 }
 
 // AgentGraphState 是 graph 内部真正流转的运行态容器。
@@ -171,10 +173,12 @@ type AgentGraphState struct {
 // NewAgentGraphState 把入口参数整理成 graph 内部状态。
 func NewAgentGraphState(input AgentGraphRunInput) *AgentGraphState {
 	st := &AgentGraphState{
-		RuntimeState:        input.RuntimeState,
-		ConversationContext: input.ConversationContext,
-		Request:             input.Request,
-		Deps:                input.Deps,
+		RuntimeState:          input.RuntimeState,
+		ConversationContext:   input.ConversationContext,
+		Request:               input.Request,
+		Deps:                  input.Deps,
+		ScheduleState:         input.ScheduleState,
+		OriginalScheduleState: input.OriginalScheduleState,
 	}
 	st.Request.Normalize()
 	st.EnsureRuntimeState()
@@ -238,6 +242,12 @@ func (s *AgentGraphState) EnsureScheduleState(ctx context.Context) (*newagenttoo
 		return nil, nil
 	}
 	if s.ScheduleState != nil {
+		if s.OriginalScheduleState == nil {
+			// 1. 兼容老快照：历史 Redis 快照里可能还没带 original_state。
+			// 2. 当前阶段虽然已经不落库，但后续若重新接回 diff 链，仍需要稳定的原始快照。
+			// 3. 因此这里在“已恢复出 ScheduleState、但缺 original”时补一份克隆兜底。
+			s.OriginalScheduleState = s.ScheduleState.Clone()
+		}
 		return s.ScheduleState, nil
 	}
 	if s.Deps.ScheduleProvider == nil {

backend/newAgent/model/state_store.go

@@ -14,8 +14,10 @@ import (
 // 3. 不保存 Deps（依赖注入，每次由 Service 层重建）；
 // 4. 不保存 ToolSchemas（每次请求由 Service 层重新注入）。
 type AgentStateSnapshot struct {
-	RuntimeState        *AgentRuntimeState   `json:"runtime_state"`
-	ConversationContext *ConversationContext `json:"conversation_context"`
+	RuntimeState          *AgentRuntimeState           `json:"runtime_state"`
+	ConversationContext   *ConversationContext         `json:"conversation_context"`
+	ScheduleState         *newagenttools.ScheduleState `json:"schedule_state,omitempty"`
+	OriginalScheduleState *newagenttools.ScheduleState `json:"original_schedule_state,omitempty"`
 }
 
 // AgentStateStore 定义 agent 状态持久化的最小接口。

backend/newAgent/node/agent_nodes.go

@@ -85,6 +85,9 @@ func (n *AgentNodes) Confirm(ctx context.Context, st *newagentmodel.AgentGraphSt
 		},
 	); err != nil {
 		return nil, err
+	} else if st.Deps.WriteSchedulePreview != nil && st.ScheduleState == nil {
+		flowState := st.EnsureFlowState()
+		log.Printf("[WARN] deliver: schedule state is nil, skip preview write chat=%s", flowState.ConversationID)
 	}
 
 	saveAgentState(ctx, st)
@@ -111,6 +114,7 @@ func (n *AgentNodes) Plan(ctx context.Context, st *newagentmodel.AgentGraphState
 			Client:              st.Deps.ResolvePlanClient(),
 			ChunkEmitter:        st.EnsureChunkEmitter(),
 			ResumeNode:          "plan",
+			AlwaysExecute:       st.Request.AlwaysExecute,
 		},
 	); err != nil {
 		return nil, err
@@ -293,8 +297,10 @@ func saveAgentState(ctx context.Context, st *newagentmodel.AgentGraphState) {
 	}
 
 	snapshot := &newagentmodel.AgentStateSnapshot{
-		RuntimeState:        runtimeState,
-		ConversationContext: st.EnsureConversationContext(),
+		RuntimeState:          runtimeState,
+		ConversationContext:   st.EnsureConversationContext(),
+		ScheduleState:         st.ScheduleState.Clone(),
+		OriginalScheduleState: st.OriginalScheduleState.Clone(),
 	}
 
 	_ = store.Save(ctx, flowState.ConversationID, snapshot)

backend/newAgent/node/chat.go

@@ -54,7 +54,7 @@ func RunChatNode(ctx context.Context, input ChatNodeInput) error {
 
 	// 1. 有 pending interaction → 纯状态传递，处理恢复。
 	if runtimeState.HasPendingInteraction() {
-		return handleChatResume(input, runtimeState, conversationContext, emitter)
+		return handleChatResume(input, runtimeState, emitter)
 	}
 
 	// 2. 无 pending → 路由决策（一次快速 LLM 调用，不开 thinking）。
@@ -263,16 +263,13 @@ func handleRoutePlan(
 func handleChatResume(
 	input ChatNodeInput,
 	runtimeState *newagentmodel.AgentRuntimeState,
-	conversationContext *newagentmodel.ConversationContext,
 	emitter *newagentstream.ChunkEmitter,
 ) error {
 	pending := runtimeState.PendingInteraction
 	flowState := runtimeState.EnsureCommonState()
 
-	// 把用户本轮输入写回历史（ask_user 回复、confirm 附言等）。
-	if strings.TrimSpace(input.UserInput) != "" {
-		conversationContext.AppendHistory(schema.UserMessage(input.UserInput))
-	}
+	// 用户输入在 service 层进入 graph 前已经统一追加到 ConversationContext。
+	// 这里不再二次写入，避免 pending 恢复路径把同一轮 user message 追加两次。
 
 	switch pending.Type {
 	case newagentmodel.PendingInteractionTypeAskUser:

backend/newAgent/node/execute.go

@@ -38,8 +38,8 @@ const (
 // 3. ConversationContext 提供历史对话与置顶上下文；
 // 4. ToolRegistry 提供工具注册表；
 // 5. ScheduleState 提供工具操作的内存数据源（可为 nil，由调用方按需加载）；
-// 6. SchedulePersistor 用于写工具执行后持久化变更；
-// 7. OriginalScheduleState 是首次加载时的原始快照，用于 diff。
+// 6. SchedulePersistor 仍保留注入位，但当前阶段不调用，避免写库；
+// 7. OriginalScheduleState 继续保留，供 Redis 快照恢复时维持“当前态/原始态”成对语义。
 type ExecuteNodeInput struct {
 	RuntimeState          *newagentmodel.AgentRuntimeState
 	ConversationContext   *newagentmodel.ConversationContext
@@ -138,6 +138,15 @@ func RunExecuteNode(ctx context.Context, input ExecuteNodeInput) error {
 
 	// 5. 构造本轮执行输入，请求 LLM 输出 ExecuteDecision。
 	messages := newagentprompt.BuildExecuteMessages(flowState, conversationContext)
+	log.Printf(
+		"[DEBUG] execute LLM context begin chat=%s round=%d message_count=%d\n%s\n[DEBUG] execute LLM context end chat=%s round=%d",
+		flowState.ConversationID,
+		flowState.RoundUsed,
+		len(messages),
+		formatExecuteLLMMessagesForDebug(messages),
+		flowState.ConversationID,
+		flowState.RoundUsed,
+	)
 	decision, rawResult, err := newagentllm.GenerateJSON[newagentmodel.ExecuteDecision](
 		ctx,
 		input.Client,
@@ -316,18 +325,9 @@ func RunExecuteNode(ctx context.Context, input ExecuteNodeInput) error {
 		return nil
 
 	case newagentmodel.ExecuteActionConfirm:
-		// AlwaysExecute=true：跳过确认闸门，直接执行写工具并持久化，不走 confirm 节点。
+		// AlwaysExecute=true：跳过确认闸门，直接执行内存写工具，不走 confirm 节点。
 		if input.AlwaysExecute && decision.ToolCall != nil {
-			if err := executeToolCall(ctx, flowState, conversationContext, decision.ToolCall, emitter, input.ToolRegistry, input.ScheduleState); err != nil {
-				return err
-			}
-			if input.SchedulePersistor != nil && input.OriginalScheduleState != nil {
-				cs := runtimeState.EnsureCommonState()
-				if persistErr := input.SchedulePersistor.PersistScheduleChanges(ctx, input.OriginalScheduleState, input.ScheduleState, cs.UserID); persistErr != nil {
-					log.Printf("[WARN] execute always-execute 持久化失败: %v", persistErr)
-				}
-			}
-			return nil
+			return executeToolCall(ctx, flowState, conversationContext, decision.ToolCall, emitter, input.ToolRegistry, input.ScheduleState)
 		}
 		// AlwaysExecute=false（默认）：暂存工具意图，设 Phase → 下游 confirm 节点接管。
 		return handleExecuteActionConfirm(decision, runtimeState, flowState)
@@ -504,7 +504,19 @@ func executeToolCall(
 	}
 
 	// 2. 执行工具。
+	beforeDigest := summarizeScheduleStateForDebug(scheduleState)
 	result := registry.Execute(scheduleState, toolName, toolCall.Arguments)
+	afterDigest := summarizeScheduleStateForDebug(scheduleState)
+	log.Printf(
+		"[DEBUG] execute tool chat=%s round=%d tool=%s args=%s before=%s after=%s result_preview=%.200s",
+		flowState.ConversationID,
+		flowState.RoundUsed,
+		toolName,
+		marshalArgsForDebug(toolCall.Arguments),
+		beforeDigest,
+		afterDigest,
+		flattenForLog(result),
+	)
 
 	// 2.5 截断过大的工具结果，防止上下文膨胀导致后续 LLM 调用返回空或超限。
 	const maxToolResultLen = 3000
@@ -558,7 +570,7 @@ func executeToolCall(
 // 1. 从 PendingConfirmTool 读取工具名和参数（已序列化）；
 // 2. 反序列化参数后调用工具执行；
 // 3. 将结果追加到历史，清空 PendingConfirmTool；
-// 4. 执行成功后调用 persistor 持久化变更；
+// 4. 当前阶段只保留内存修改，不在这里落库；
 // 5. 不调用 LLM，直接返回让下一轮继续。
 func executePendingTool(
 	ctx context.Context,
@@ -598,7 +610,20 @@ func executePendingTool(
 	}
 
 	// 4. 执行工具。
+	beforeDigest := summarizeScheduleStateForDebug(scheduleState)
 	result := registry.Execute(scheduleState, pending.ToolName, args)
+	afterDigest := summarizeScheduleStateForDebug(scheduleState)
+	flowState := runtimeState.EnsureCommonState()
+	log.Printf(
+		"[DEBUG] execute pending tool chat=%s round=%d tool=%s args=%s before=%s after=%s result_preview=%.200s",
+		flowState.ConversationID,
+		flowState.RoundUsed,
+		pending.ToolName,
+		marshalArgsForDebug(args),
+		beforeDigest,
+		afterDigest,
+		flattenForLog(result),
+	)
 
 	// 5. 将工具调用和结果以合法的 assistant+tool 消息对追加到历史。
 	//
@@ -630,13 +655,6 @@ func executePendingTool(
 	// 6. 清空临时邮箱，避免重复执行。
 	runtimeState.PendingConfirmTool = nil
 
-	// 7. 持久化变更（如果有 persistor）。
-	if persistor != nil && originalState != nil {
-		if err := persistor.PersistScheduleChanges(ctx, originalState, scheduleState, runtimeState.UserID); err != nil {
-			return fmt.Errorf("持久化日程变更失败: %w", err)
-		}
-	}
-
 	return nil
 }
 
@@ -671,3 +689,147 @@ func truncateText(text string, maxLen int) string {
 	}
 	return text[:maxLen-3] + "..."
 }
+
+// summarizeScheduleStateForDebug 返回内存日程状态的关键计数，用于判断工具是否真的修改了 state。
+func summarizeScheduleStateForDebug(state *newagenttools.ScheduleState) string {
+	if state == nil {
+		return "state=nil"
+	}
+
+	total := len(state.Tasks)
+	pendingNoSlot := 0
+	pendingWithSlot := 0
+	existingTotal := 0
+	taskItemWithSlot := 0
+	eventWithSlot := 0
+
+	for i := range state.Tasks {
+		t := &state.Tasks[i]
+		hasSlot := len(t.Slots) > 0
+
+		switch t.Status {
+		case "pending":
+			if hasSlot {
+				pendingWithSlot++
+			} else {
+				pendingNoSlot++
+			}
+		case "existing":
+			existingTotal++
+		}
+
+		if hasSlot {
+			if t.Source == "task_item" {
+				taskItemWithSlot++
+			}
+			if t.Source == "event" {
+				eventWithSlot++
+			}
+		}
+	}
+
+	return fmt.Sprintf(
+		"tasks=%d pending_no_slot=%d pending_with_slot=%d existing=%d task_item_with_slot=%d event_with_slot=%d",
+		total,
+		pendingNoSlot,
+		pendingWithSlot,
+		existingTotal,
+		taskItemWithSlot,
+		eventWithSlot,
+	)
+}
+
+// marshalArgsForDebug 将工具参数序列化为日志可读的短文本。
+func marshalArgsForDebug(args map[string]any) string {
+	if len(args) == 0 {
+		return "{}"
+	}
+	raw, err := json.Marshal(args)
+	if err != nil {
+		return "<marshal_error>"
+	}
+	return string(raw)
+}
+
+// flattenForLog 将多行文本压成单行，避免日志换行影响排查。
+func flattenForLog(text string) string {
+	text = strings.ReplaceAll(text, "\n", " ")
+	text = strings.ReplaceAll(text, "\r", " ")
+	return strings.TrimSpace(text)
+}
+
+// formatExecuteLLMMessagesForDebug 将本轮送入 LLM 的完整消息上下文展开成可读多行日志。
+//
+// 说明：
+// 1. 按消息索引逐条输出，便于和上游上下文构造步骤逐项对齐；
+// 2. 完整输出 content / reasoning_content / tool_calls / extra，不做截断；
+// 3. 仅用于调试打点，不参与业务决策。
+func formatExecuteLLMMessagesForDebug(messages []*schema.Message) string {
+	if len(messages) == 0 {
+		return "(empty messages)"
+	}
+
+	var sb strings.Builder
+	for i, msg := range messages {
+		sb.WriteString(fmt.Sprintf("----- message[%d] -----\n", i))
+		if msg == nil {
+			sb.WriteString("role: <nil>\n\n")
+			continue
+		}
+
+		sb.WriteString(fmt.Sprintf("role: %s\n", msg.Role))
+
+		if strings.TrimSpace(msg.ToolCallID) != "" {
+			sb.WriteString(fmt.Sprintf("tool_call_id: %s\n", msg.ToolCallID))
+		}
+		if strings.TrimSpace(msg.ToolName) != "" {
+			sb.WriteString(fmt.Sprintf("tool_name: %s\n", msg.ToolName))
+		}
+
+		if len(msg.ToolCalls) > 0 {
+			sb.WriteString("tool_calls:\n")
+			for j, call := range msg.ToolCalls {
+				sb.WriteString(fmt.Sprintf("  - [%d] id=%s type=%s function=%s\n", j, call.ID, call.Type, call.Function.Name))
+				sb.WriteString("    arguments:\n")
+				sb.WriteString(indentMultilineForDebug(call.Function.Arguments, "      "))
+				sb.WriteString("\n")
+			}
+		}
+
+		if strings.TrimSpace(msg.ReasoningContent) != "" {
+			sb.WriteString("reasoning_content:\n")
+			sb.WriteString(indentMultilineForDebug(msg.ReasoningContent, "  "))
+			sb.WriteString("\n")
+		}
+
+		sb.WriteString("content:\n")
+		sb.WriteString(indentMultilineForDebug(msg.Content, "  "))
+		sb.WriteString("\n")
+
+		if len(msg.Extra) > 0 {
+			sb.WriteString("extra:\n")
+			raw, err := json.MarshalIndent(msg.Extra, "", "  ")
+			if err != nil {
+				sb.WriteString(indentMultilineForDebug("<marshal_error>", "  "))
+			} else {
+				sb.WriteString(indentMultilineForDebug(string(raw), "  "))
+			}
+			sb.WriteString("\n")
+		}
+
+		sb.WriteString("\n")
+	}
+	return sb.String()
+}
+
+// indentMultilineForDebug 为多行文本统一添加前缀缩进，避免日志折行后难以阅读。
+func indentMultilineForDebug(text, prefix string) string {
+	if text == "" {
+		return prefix + "<empty>"
+	}
+	lines := strings.Split(text, "\n")
+	for i := range lines {
+		lines[i] = prefix + lines[i]
+	}
+	return strings.Join(lines, "\n")
+}

backend/newAgent/node/plan.go

@@ -33,6 +33,7 @@ type PlanNodeInput struct {
 	Client              *newagentllm.Client
 	ChunkEmitter        *newagentstream.ChunkEmitter
 	ResumeNode          string
+	AlwaysExecute       bool // true 时计划生成后自动确认，不进入 confirm 节点
 }
 
 // RunPlanNode 执行一轮规划节点逻辑。
@@ -166,6 +167,18 @@ func RunPlanNode(ctx context.Context, input PlanNodeInput) error {
 				flowState.TaskClassIDs = decision.TaskClassIDs
 			}
 		}
+		// always_execute 开启时，计划层跳过确认闸门，直接进入执行阶段。
+		// 这样可以与 Execute 节点的“写工具跳过确认”语义保持一致。
+		if input.AlwaysExecute {
+			flowState.ConfirmPlan()
+			_ = emitter.EmitStatus(
+				planStatusBlockID,
+				planStageName,
+				"plan_auto_confirmed",
+				"计划已自动确认，开始执行。",
+				false,
+			)
+		}
 		return nil
 	default:
 		// 1. LLM 输出了不支持的 action，不应直接报错终止，而应给它修正机会。

backend/newAgent/node/rough_build.go

@@ -3,6 +3,8 @@ package newagentnode
 import (
 	"context"
 	"fmt"
+	"strconv"
+	"strings"
 
 	newagentmodel "github.com/LoveLosita/smartflow/backend/newAgent/model"
 	newagenttools "github.com/LoveLosita/smartflow/backend/newAgent/tools"
@@ -82,10 +84,18 @@ func RunRoughBuildNode(ctx context.Context, st *newagentmodel.AgentGraphState) e
 
 	// 8. 把粗排完成信息写入 pinned context，让 Execute 阶段的 LLM 直接进入验证和微调。
 	stillPending := countPendingTasks(scheduleState)
+
+	// 构造任务类 ID 字符串，供 pinned block 明确标注，避免 Execute LLM 因找不到 task_class_id 来源而 ask_user。
+	idParts := make([]string, len(taskClassIDs))
+	for i, id := range taskClassIDs {
+		idParts[i] = strconv.Itoa(id)
+	}
+	idStr := strings.Join(idParts, ", ")
+
 	var pinnedContent string
 	if stillPending > 0 {
 		pinnedContent = fmt.Sprintf(
-			"后端已自动运行粗排算法，初始排课方案已写入日程状态（共 %d 个任务已预排）。\n"+
+			"后端已自动运行粗排算法（任务类 ID：[%s]），初始排课方案已写入日程状态（共 %d 个任务已预排）。\n"+
 				"注意：仍有 %d 个任务未被粗排覆盖，处于待安排（pending）状态，必须在微调阶段手动安排完毕。\n\n"+
 				"处理 pending 任务的正确操作顺序：\n"+
 				"1. 调用 get_overview 或 find_free 确认可用空位（不要反复调用 list_tasks，list_tasks 只能看任务列表，看不出空位）\n"+
@@ -93,14 +103,14 @@ func RunRoughBuildNode(ctx context.Context, st *newagentmodel.AgentGraphState) e
 				"3. 重复上述步骤，直到 get_overview 显示待安排任务剩余为 0\n\n"+
 				"微调完成的判定标准：所有 pending 任务均已 place（待安排任务剩余=0），且现有排课无明显失衡。\n"+
 				"无需再次触发粗排。",
-			len(placements), stillPending,
+			idStr, len(placements), stillPending,
 		)
 	} else {
 		pinnedContent = fmt.Sprintf(
-			"后端已自动运行粗排算法，初始排课方案已写入日程状态（共 %d 个任务已预排，无待安排任务）。\n"+
+			"后端已自动运行粗排算法（任务类 ID：[%s]），初始排课方案已写入日程状态（共 %d 个任务已预排，无待安排任务）。\n"+
 				"请直接调用 get_overview 查看预排结果，然后用 move/swap 微调不合理的位置。\n"+
 				"无需再次触发粗排。",
-			len(placements),
+			idStr, len(placements),
 		)
 	}
 	st.EnsureConversationContext().UpsertPinnedBlock(newagentmodel.ContextBlock{

backend/newAgent/prompt/execute.go

@@ -2,6 +2,7 @@ package newagentprompt
 
 import (
 	"fmt"
+	"strconv"
 	"strings"
 
 	newagentmodel "github.com/LoveLosita/smartflow/backend/newAgent/model"
@@ -191,6 +192,17 @@ func BuildExecuteUserPrompt(state *newagentmodel.CommonState) string {
 	sb.WriteString(renderStateSummary(state))
 	sb.WriteString("\n")
 
+	// 明确列出任务类 IDs，与 Plan 阶段保持信息对称，避免 LLM 因 plan 步骤中引用了 ID
+	// 而在 Execute 阶段找不到显式来源，误触 rule 5（缺少关键上下文）→ ask_user。
+	if state != nil && len(state.TaskClassIDs) > 0 {
+		parts := make([]string, len(state.TaskClassIDs))
+		for i, id := range state.TaskClassIDs {
+			parts[i] = strconv.Itoa(id)
+		}
+		sb.WriteString(fmt.Sprintf("本次排课请求涉及的任务类 ID：[%s]（上下文已完整，无需向用户追问）\n", strings.Join(parts, ", ")))
+		sb.WriteString("\n")
+	}
+
 	if state == nil || !state.HasPlan() {
 		sb.WriteString("当前没有可执行的完整 plan，请不要盲目进入执行；如有需要请回退到规划阶段。\n")
 		return strings.TrimSpace(sb.String())
@@ -221,7 +233,16 @@ func BuildExecuteReActUserPrompt(state *newagentmodel.CommonState) string {
 	sb.WriteString("请根据用户意图直接使用工具完成请求。\n\n")
 
 	sb.WriteString(renderStateSummary(state))
-	sb.WriteString("\n\n")
+	sb.WriteString("\n")
+
+	if state != nil && len(state.TaskClassIDs) > 0 {
+		parts := make([]string, len(state.TaskClassIDs))
+		for i, id := range state.TaskClassIDs {
+			parts[i] = strconv.Itoa(id)
+		}
+		sb.WriteString(fmt.Sprintf("本次排课请求涉及的任务类 ID：[%s]（上下文已完整，无需向用户追问）\n", strings.Join(parts, ", ")))
+	}
+	sb.WriteString("\n")
 
 	sb.WriteString("判断规则：\n")
 	sb.WriteString("- 需要查询/读取数据 → action=continue + tool_call（读工具）\n")

backend/newAgent/stream/emitter.go

@@ -139,8 +139,8 @@ func (e *ChunkEmitter) EmitAssistantText(blockID, stage, text string, includeRol
 	if e == nil || e.emit == nil {
 		return nil
 	}
-
-	text = strings.TrimSpace(text)
+	//这里如果不删掉，换行符会被吞了，导致文字黏连
+	/*	text = strings.TrimSpace(text)*/
 	if text == "" {
 		return nil
 	}
@@ -509,9 +509,7 @@ func SplitPseudoStreamText(text string, options PseudoStreamOptions) []string {
 	options = normalizePseudoStreamOptions(options)
 	runes := []rune(text)
 	if len(runes) <= options.MaxChunkRunes {
-		if hasTrailingNewline {
-			return []string{text + "\n"}
-		}
+		// text 经 TrimRight(" \t\r") 已保留结尾 \n，直接返回，不再追加。
 		return []string{text}
 	}
 
@@ -532,7 +530,9 @@ func SplitPseudoStreamText(text string, options PseudoStreamOptions) []string {
 			continue
 		}
 
-		chunk := strings.TrimSpace(string(runes[start : i+1]))
+		// 用 Trim(" \t\r") 代替 TrimSpace：保留 chunk 内的 \n（段落分隔符）。
+		// TrimSpace 会把 flush 在 \n 边界时结尾的 \n、以及下一段开头的 \n 全部删掉，导致黏连。
+		chunk := strings.Trim(string(runes[start:i+1]), " \t\r")
 		if chunk != "" {
 			chunks = append(chunks, chunk)
 		}
@@ -541,19 +541,17 @@ func SplitPseudoStreamText(text string, options PseudoStreamOptions) []string {
 	}
 
 	if start < len(runes) {
-		chunk := strings.TrimSpace(string(runes[start:]))
+		chunk := strings.Trim(string(runes[start:]), " \t\r")
 		if chunk != "" {
 			chunks = append(chunks, chunk)
 		}
 	}
 
 	if len(chunks) == 0 {
-		if hasTrailingNewline {
-			return []string{text + "\n"}
-		}
 		return []string{text}
 	}
-	if hasTrailingNewline {
+	// 仅当最后一个 chunk 尚未以 \n 结尾时才追加，避免 Trim 修复后出现双换行。
+	if hasTrailingNewline && !strings.HasSuffix(chunks[len(chunks)-1], "\n") {
 		chunks[len(chunks)-1] += "\n"
 	}
 	return chunks