Version: 0.9.8.dev.260408

后端：
1.execute 上下文瘦身第一版落地（固定 4 消息骨架 + ReAct 窗口压缩 + JSON 输出约束）
  - 新建 prompt/execute_context.go：
    execute 阶段改为 message[0..3] 固定结构；
    加入历史摘要、当轮 ReAct 绑定展示、同工具 observation 压缩（保留最新）与工具简表返回示例提示
  - 更新 prompt/execute.go：
    重写 plan/ReAct 执行提示词；
    补齐“可做/不可做”约束；
    统一严格 JSON 指令；
    补充 tool_call.arguments/abort/speak 非空等格式护栏
  - 更新 model/execute_contract.go：
    新增 ExecuteDecision/ToolCallIntent 自定义 Unmarshal；
    兼容空字符串占位与 tool_call.parameters→arguments 回退解析
  - 更新 node/correction.go：
    为 correction 注入 history kind 标记，避免被当作真实用户输入污染摘要
  - 更新 node/execute.go：
    补齐 continue/ask_user/confirm 的 speak 兜底；
    移除工具结果写入前 3000 字截断

2.工具层微调语义重构（任务视角概览 + 首个空位查询 + 移动权限收紧）
  - 更新 tools/read_tools.go：
    get_overview 改为任务视角全量输出（课程仅占位统计）；
    新增 find_first_free（首个命中位 + 当日负载明细）；
    find_free 保留兼容别名；
    list_tasks 增加 status/category 校验与空结果纠偏文案
  - 更新 tools/registry.go：
    注册 find_first_free；
    find_free 改兼容别名；
    同步 get_overview/list_tasks/move/batch_move 描述语义
  - 更新 tools/write_tools.go：
    move/batch_move 仅允许 suggested，existing/pending 明确拒绝并返回可读错误
  - 更新 tools/SCHEDULE_TOOLS.md：
    同步 get_overview/find_first_free/list_tasks/move/batch_move 的最新入参与返回示例
  - 更新 prompt/plan.go：
    读工具示例由 find_free 调整为 find_first_free

3.交接文档与阶段说明同步
  - 更新 newAgent/HANDOFF_粗排修复与Prompt重构.md：
    更新为 2026-04-08；
    补充“最新增量交接”章节（当前主矛盾、P0/P1、验证清单）
  - 更新 newAgent/阶段3_上下文瘦身设计.md：
    同步 existing/suggested 的 move/batch_move 约束口径
  - 更新 newAgent/Log.txt：
    追加本轮 execute 调试日志快照

前端：无
仓库：无

backend/newAgent/prompt/execute.go

@@ -2,7 +2,6 @@ package newagentprompt
 
 import (
 	"fmt"
-	"strconv"
 	"strings"
 
 	newagentmodel "github.com/LoveLosita/smartflow/backend/newAgent/model"
@@ -10,62 +9,73 @@ import (
 )
 
 const executeSystemPromptWithPlan = `
-你是 SmartFlow NewAgent 的执行器。
-你的职责是在"当前 plan 步骤"的约束下，进行思考、执行、观察，再决定下一步动作。
+你是 SmartFlow NewAgent 的执行器。你需要在“当前 plan 步骤”约束下推进任务。
 
-请遵守以下规则：
-1. 只围绕当前步骤行动，不要擅自跳到其他 plan 步骤。
-2. 只输出严格 JSON，不要输出 markdown，不要输出额外解释，不要在 JSON 外再补文字。
-3. 只有当你确认当前步骤已经完成时，才输出 action=next_plan，且必须在 goal_check 中逐条对照 done_when 说明完成依据。
-4. 只有当你确认整个任务已经完成时，才输出 action=done，且必须在 goal_check 中总结整体完成证据。
-5. 如果执行当前步骤缺少关键上下文，且无法通过已有历史或工具补齐，输出 action=ask_user。
-6. 不要伪造工具结果；如果尚未真正拿到观察结果，就不要假装已经完成。
-7. goal_check 是你输出 next_plan / done 时的强制字段，禁止为空；必须显式地逐条对照 done_when，说明"哪些条件已满足、依据是什么"。
+你可以做什么：
+1. 只围绕当前步骤推进，先读后写，逐步完成当前步骤。
+2. 可调用读工具补充事实，再决定下一步。
+3. 需要写操作时输出 action=confirm 并附带 tool_call，等待用户确认。
 
-你会看到：
-- 当前完整 plan
-- 当前步骤
-- 置顶上下文块
-- 工具摘要
-- 历史对话与历史观察
+你不要做什么：
+1. 不要跳到其他 plan 步骤，不要越级执行。
+2. 不要伪造工具结果。
+3. 如果上下文明确“粗排已完成/rough_build_done”，不要把任务当成未排入，不要重新逐个手动 place。
+4. 不要连续重复同类查询而没有推进；连续两轮同类读查询后，必须转入执行、ask_user，或明确阻塞原因。
+5. list_tasks 的 status 只允许单值：all / existing / suggested / pending。禁止使用 "existing,suggested" 这类拼接值。
+6. 若工具结果与已知事实明显冲突（如无写操作却从“有任务”变成“0任务”），先自我纠错并重查一次，不要直接 ask_user。
+7. 不要连续两轮调用“同一读工具 + 等价 arguments”；若上一轮已成功返回，下一轮必须换工具或进入 confirm。
+8. list_tasks.category 只接受任务类名称，不接受 task_class_ids（如 "1,2,3"）。
 
-请把注意力聚焦在"当前步骤是否完成，以及下一步最合理的执行动作"上。
-`
+执行规则：
+1. 只输出严格 JSON，不要输出 markdown，不要在 JSON 外补充文本。
+2. 读操作：action=continue + tool_call。
+3. 写操作：action=confirm + tool_call。
+4. 缺关键上下文且无法通过工具补齐：action=ask_user。
+5. 仅当当前步骤完成时输出 action=next_plan，并在 goal_check 对照 done_when 给出证据。
+6. 仅当整体任务完成时输出 action=done，并在 goal_check 总结完成证据。
+7. 流程应正式终止时输出 action=abort。`
 
 const executeSystemPromptReAct = `
-你是 SmartFlow NewAgent 的执行器，当前为自由执行模式（无预定义计划步骤）。
-你需要根据用户意图，自主决定使用哪些工具来完成任务。
+你是 SmartFlow NewAgent 的执行器，当前处于自由执行模式（无预定义 plan 步骤）。
 
-请遵守以下规则：
-1. 每轮先分析当前情况，决定下一步动作。
-2. 只输出严格 JSON，不要输出 markdown，不要输出额外解释，不要在 JSON 外再补文字。
-3. 需要查询数据 → 输出 action=continue 并附带 tool_call。
-4. 需要修改数据（写操作）→ 输出 action=confirm 并附带 tool_call，等待用户确认。
-5. 缺少关键信息且无法通过工具补齐 → 输出 action=ask_user。
-6. 任务完成 → 输出 action=done，并在 goal_check 中总结完成证据。
-7. 不要伪造工具结果；如果尚未真正拿到观察结果，就不要假装已经完成。
-8. 尽量高效：能用一次工具调用完成的，不要分多轮。
+阶段事实（强约束）：
+1. 若上下文给出“粗排已完成/rough_build_done”，表示目标任务类已经进入 suggested/existing，不是待排入状态。
+2. 当前阶段目标是“微调”，不是“重新粗排”。
 
-你会看到：
-- 用户原始请求
-- 置顶上下文块（粗排结果等）
-- 工具摘要
-- 历史对话与历史观察
+你可以做什么：
+1. 你可以基于科学排程原则（负载均衡、学习连贯性、冲突最小化）对 suggested 做微调。
+2. existing 属于已安排事实层，可用于冲突判断和参考，不作为 move/batch_move 的目标。
+3. 你可以先调用读工具补充必要事实（例如 get_overview/list_tasks/find_first_free/get_task_info）。
+4. 你可以在需要改动时提出 confirm（move/swap/unplace/batch_move）。
 
-请直接行动，不要犹豫，不要重复已经做过的操作。
-`
+你不要做什么：
+1. 不要假设任务还没排进去，然后改成逐个手动 place。
+2. 不要伪造工具结果。
+3. 不要重复做同类查询而没有新增结论；连续两轮同类读查询后，必须转入执行、ask_user，或明确阻塞原因。
+4. list_tasks 的 status 只允许单值：all / existing / suggested / pending。禁止使用 "existing,suggested" 这类拼接值。
+5. 若工具结果与已知事实明显冲突（如无写操作却从“有任务”变成“0任务”），先自我纠错并重查一次，不要直接 ask_user。
+6. 不要连续两轮调用“同一读工具 + 等价 arguments”；若上一轮已成功返回，下一轮必须换工具或进入 confirm。
+7. list_tasks.category 只接受任务类名称，不接受 task_class_ids（如 "1,2,3"）。
 
-// BuildExecuteSystemPrompt 返回执行阶段系统提示词。
+执行规则：
+1. 只输出严格 JSON，不要输出 markdown，不要在 JSON 外补充文本。
+2. 读操作：action=continue + tool_call。
+3. 写操作：action=confirm + tool_call。
+4. 缺关键上下文且无法通过工具补齐：action=ask_user。
+5. 任务完成：action=done，并在 goal_check 总结完成证据。
+6. 流程应正式终止：action=abort。`
+
+// BuildExecuteSystemPrompt 返回执行阶段系统提示词（有 plan 模式）。
 func BuildExecuteSystemPrompt() string {
-	return strings.TrimSpace(executeSystemPromptWithPlan)
+	return buildExecutePromptWithFormatGuard(executeSystemPromptWithPlan)
 }
 
-// BuildExecuteReActSystemPrompt 返回纯 ReAct 模式的系统提示词。
+// BuildExecuteReActSystemPrompt 返回执行阶段系统提示词（自由执行模式）。
 func BuildExecuteReActSystemPrompt() string {
-	return strings.TrimSpace(executeSystemPromptReAct)
+	return buildExecutePromptWithFormatGuard(executeSystemPromptReAct)
 }
 
-// BuildExecuteDecisionContractText 返回执行阶段的输出协议说明（有 plan 模式）。
+// BuildExecuteDecisionContractText 返回执行阶段输出协议（有 plan 模式）。
 func BuildExecuteDecisionContractText() string {
 	return strings.TrimSpace(fmt.Sprintf(`
 输出协议（严格 JSON）：
@@ -73,14 +83,14 @@ func BuildExecuteDecisionContractText() string {
 - action：只能是 %s / %s / %s / %s / %s
 - reason：给后端和日志看的简短说明
 - goal_check：输出 %s 或 %s 时必填，对照 done_when 逐条验证
-- tool_call：输出 %s 时可附带写工具意图（需 confirm），输出 %s 时可附带读工具调用
-- tool_call 格式：{"name": "工具名", "arguments": {...}}
+- tool_call：输出 %s（写操作，需 confirm）或 %s（读操作）时可附带
+- tool_call 格式：{"name":"工具名","arguments":{...}}
 
-合法示例：
+示例：
 {
-  "speak": "我来查一下本周的安排。",
+  "speak": "我先查看当前整体安排。",
   "action": "%s",
-  "reason": "需要先调用 get_overview 获取当前数据",
+  "reason": "需要先调用 get_overview 获取事实",
   "tool_call": {
     "name": "get_overview",
     "arguments": {}
@@ -88,16 +98,16 @@ func BuildExecuteDecisionContractText() string {
 }
 
 {
-  "speak": "查询完成。",
+  "speak": "当前步骤已完成。",
   "action": "%s",
-  "reason": "已拿到当前周课程列表",
-  "goal_check": "已通过 get_overview 确认本周课程列表，满足完成条件"
+  "reason": "已完成当前步骤所需查询与校验",
+  "goal_check": "已满足当前步骤 done_when 条件"
 }
 
 {
   "speak": "",
   "action": "%s",
-  "reason": "整个任务已完成"
+  "reason": "整体任务已完成"
 }
 `,
 		newagentmodel.ExecuteActionContinue,
@@ -115,22 +125,22 @@ func BuildExecuteDecisionContractText() string {
 	))
 }
 
-// BuildExecuteReActContractText 返回纯 ReAct 模式的输出协议说明。
+// BuildExecuteReActContractText 返回自由执行模式输出协议。
 func BuildExecuteReActContractText() string {
 	return strings.TrimSpace(fmt.Sprintf(`
 输出协议（严格 JSON）：
-- speak：给用户看的话（可以是分析结果、中间进展、或最终回复）
+- speak：给用户看的话
 - action：只能是 %s / %s / %s / %s
 - reason：给后端和日志看的简短说明
 - goal_check：输出 %s 时必填，总结任务完成证据
-- tool_call：输出 %s 时可附带写工具意图（需 confirm），输出 %s 时可附带读工具调用
-- tool_call 格式：{"name": "工具名", "arguments": {...}}
+- tool_call：输出 %s（写操作，需 confirm）或 %s（读操作）时可附带
+- tool_call 格式：{"name":"工具名","arguments":{...}}
 
-合法示例：
+示例：
 {
-  "speak": "我来查一下今天的安排。",
+  "speak": "我先看一下现在的安排分布。",
   "action": "%s",
-  "reason": "需要调用 get_overview 查询",
+  "reason": "先读取概览再决定微调方向",
   "tool_call": {
     "name": "get_overview",
     "arguments": {}
@@ -138,20 +148,20 @@ func BuildExecuteReActContractText() string {
 }
 
 {
-  "speak": "已将概率论移到周三第1-2节。",
+  "speak": "我准备把两项任务对调位置，你确认后执行。",
   "action": "%s",
-  "reason": "用户要求移动课程，写操作需确认",
+  "reason": "写操作需要确认",
   "tool_call": {
-    "name": "move",
-    "arguments": {"task_state_id": 5, "target_day": 3, "target_slot_start": 1, "target_slot_end": 2}
+    "name": "swap",
+    "arguments": {"task_a": 1, "task_b": 2}
   }
 }
 
 {
-  "speak": "今天共3节课，分别是...",
+  "speak": "已完成你的请求。",
   "action": "%s",
-  "reason": "查询完成，已回答用户",
-  "goal_check": "已通过 get_overview 查到今天的课程并展示给用户"
+  "reason": "微调执行完毕并已校验结果",
+  "goal_check": "目标任务类已完成微调，且关键约束满足"
 }
 `,
 		newagentmodel.ExecuteActionContinue,
@@ -167,23 +177,23 @@ func BuildExecuteReActContractText() string {
 	))
 }
 
-// BuildExecuteDecisionContractTextV2 返回第二轮 abort 协议补齐后的执行输出契约。
+// BuildExecuteDecisionContractTextV2 返回补齐 abort 协议后的执行输出契约（有 plan 模式）。
 func BuildExecuteDecisionContractTextV2() string {
 	return strings.TrimSpace(fmt.Sprintf(`
 输出协议（严格 JSON）：
-- speak：给用户看的话；若 action=%s，通常留空，最终收口交给 deliver
+- speak：给用户看的话；若 action=%s，通常留空
 - action：只能是 %s / %s / %s / %s / %s / %s
 - reason：给后端和日志看的简短说明
 - goal_check：输出 %s 或 %s 时必填，对照 done_when 逐条验证
-- tool_call：输出 %s 时可附带写工具意图（需 confirm），输出 %s 时可附带读工具调用
-- abort：仅在输出 %s 时必填，格式为 {"code":"稳定机器码","user_message":"给用户看的终止说明","internal_reason":"给日志看的原因"}
+- tool_call：输出 %s（写操作，需 confirm）或 %s（读操作）时可附带
+- abort：仅在 action=%s 时必填，格式为 {"code":"...","user_message":"...","internal_reason":"..."}
 - tool_call 与 abort 互斥，禁止同时出现
 
-合法示例：
+示例：
 {
-  "speak": "我来查一下本周的安排。",
+  "speak": "我先查看当前安排。",
   "action": "%s",
-  "reason": "需要先调用 get_overview 获取当前数据",
+  "reason": "先读取事实再决策",
   "tool_call": {
     "name": "get_overview",
     "arguments": {}
@@ -191,20 +201,20 @@ func BuildExecuteDecisionContractTextV2() string {
 }
 
 {
-  "speak": "查询完成。",
+  "speak": "当前步骤完成。",
   "action": "%s",
-  "reason": "已拿到当前周课程列表",
-  "goal_check": "已通过 get_overview 确认本周课程列表，满足完成条件"
+  "reason": "步骤完成条件满足",
+  "goal_check": "已满足当前步骤 done_when"
 }
 
 {
   "speak": "",
   "action": "%s",
-  "reason": "粗排结果存在业务异常，当前不应继续微调",
+  "reason": "流程不应继续执行",
   "abort": {
-    "code": "rough_build_pending_remaining",
-    "user_message": "初始排课方案构建异常：粗排后仍有任务未获得初始落位。本轮先终止，请检查粗排算法或任务数据。",
-    "internal_reason": "pending tasks remain after rough build"
+    "code": "execute_abort",
+    "user_message": "当前流程无法继续执行，本轮先终止。",
+    "internal_reason": "execute declared abort"
   }
 }
 `,
@@ -226,23 +236,23 @@ func BuildExecuteDecisionContractTextV2() string {
 	))
 }
 
-// BuildExecuteReActContractTextV2 返回第二轮 abort 协议补齐后的 ReAct 输出契约。
+// BuildExecuteReActContractTextV2 返回补齐 abort 协议后的自由执行输出契约。
 func BuildExecuteReActContractTextV2() string {
 	return strings.TrimSpace(fmt.Sprintf(`
 输出协议（严格 JSON）：
-- speak：给用户看的话（可以是分析结果、中间进展、或最终回复）；若 action=%s，通常留空
+- speak：给用户看的话；若 action=%s，通常留空
 - action：只能是 %s / %s / %s / %s / %s
 - reason：给后端和日志看的简短说明
 - goal_check：输出 %s 时必填，总结任务完成证据
-- tool_call：输出 %s 时可附带写工具意图（需 confirm），输出 %s 时可附带读工具调用
-- abort：仅在输出 %s 时必填，格式为 {"code":"稳定机器码","user_message":"给用户看的终止说明","internal_reason":"给日志看的原因"}
+- tool_call：输出 %s（写操作，需 confirm）或 %s（读操作）时可附带
+- abort：仅在 action=%s 时必填，格式为 {"code":"...","user_message":"...","internal_reason":"..."}
 - tool_call 与 abort 互斥，禁止同时出现
 
-合法示例：
+示例：
 {
-  "speak": "我来查一下今天的安排。",
+  "speak": "我先读取当前安排。",
   "action": "%s",
-  "reason": "需要调用 get_overview 查询",
+  "reason": "先获取事实再决策",
   "tool_call": {
     "name": "get_overview",
     "arguments": {}
@@ -250,9 +260,9 @@ func BuildExecuteReActContractTextV2() string {
 }
 
 {
-  "speak": "已将概率论移到周三第1-2节。",
+  "speak": "我准备执行写操作，等待你确认。",
   "action": "%s",
-  "reason": "用户要求移动课程，写操作需确认",
+  "reason": "写操作需要确认",
   "tool_call": {
     "name": "move",
     "arguments": {"task_id": 5, "new_day": 3, "new_slot_start": 1}
@@ -262,7 +272,7 @@ func BuildExecuteReActContractTextV2() string {
 {
   "speak": "",
   "action": "%s",
-  "reason": "当前流程不应继续执行，需要正式终止",
+  "reason": "当前流程不应继续执行",
   "abort": {
     "code": "domain_abort",
     "user_message": "当前流程无法继续执行，本轮先终止。",
@@ -286,92 +296,90 @@ func BuildExecuteReActContractTextV2() string {
 	))
 }
 
-// BuildExecuteMessages 组装执行阶段的 messages。
+// BuildExecuteMessages 组装执行阶段消息。
 func BuildExecuteMessages(state *newagentmodel.CommonState, ctx *newagentmodel.ConversationContext) []*schema.Message {
 	if state != nil && state.HasPlan() {
-		return buildStageMessages(
+		return buildExecuteStageMessages(
 			BuildExecuteSystemPrompt(),
+			state,
 			ctx,
-			BuildExecuteUserPrompt(state),
+			buildExecuteStrictJSONUserPrompt(),
 		)
 	}
-	// 无 plan：纯 ReAct 模式。
-	return buildStageMessages(
+
+	return buildExecuteStageMessages(
 		BuildExecuteReActSystemPrompt(),
+		state,
 		ctx,
-		BuildExecuteReActUserPrompt(state),
+		buildExecuteStrictJSONUserPrompt(),
 	)
 }
 
+// buildExecutePromptWithFormatGuard 统一补一层更硬的 JSON 输出约束。
+func buildExecutePromptWithFormatGuard(base string) string {
+	base = strings.TrimSpace(base)
+	guard := strings.TrimSpace(`
+补充 JSON 约束：
+1. 只输出当前 action 真正需要的字段；无关字段直接省略，不要用 ""、{}、[]、null 占位。
+2. 若输出 tool_call，参数字段名只能是 arguments，禁止写成 parameters。
+3. tool_call 只能是单个对象：{"name":"工具名","arguments":{...}}，不能输出数组。
+4. 只有 action=abort 时才允许输出 abort 字段；非 abort 动作不要输出 abort。
+5. action=continue / ask_user / confirm 时，speak 必须是非空自然语言。`)
+	if base == "" {
+		return guard
+	}
+	return base + "\n\n" + guard
+}
+
+// buildExecuteStrictJSONUserPrompt 统一构造 execute 阶段面向模型的最终用户指令。
+func buildExecuteStrictJSONUserPrompt() string {
+	return strings.TrimSpace(`
+请继续当前任务的执行阶段，严格输出 JSON。
+输出字段：
+- speak
+- action
+- reason
+- goal_check
+- tool_call
+- abort
+
+补充格式要求：
+- 与当前 action 无关的字段直接省略，不要输出空字符串、空对象、空数组或 null 占位
+- tool_call 只能写 {"name":"工具名","arguments":{...}}，且每轮最多一个
+- 不要写 {"tool_call":{"name":"工具名","parameters":{...}}}
+- 非 abort 动作不要输出 abort 字段
+- action 为 continue / ask_user / confirm 时，必须输出非空 speak
+- list_tasks.arguments.status 仅允许 all / existing / suggested / pending 的单值；如需看 existing+suggested，请用 all
+- list_tasks.arguments.category 仅接受任务类名称，不要传 task_class_ids（如 "1,2,3"）
+- 若读工具结果与已知事实明显冲突，先修正参数并重查一次，再决定是否 ask_user
+- 不要连续两轮调用“同一读工具 + 等价 arguments”；若上一轮已成功返回，下一轮必须换工具或进入 confirm
+`)
+}
+
 // BuildExecuteUserPrompt 构造有 plan 模式的用户提示词。
-func BuildExecuteUserPrompt(state *newagentmodel.CommonState) string {
-	var sb strings.Builder
-
-	sb.WriteString("请继续当前任务的执行阶段。\n")
-	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())
-	}
-
-	if _, ok := state.CurrentPlanStep(); ok {
-		sb.WriteString("执行要求：\n")
-		sb.WriteString("1. 始终围绕上方「当前步骤内容」行动。\n")
-		sb.WriteString("2. 若当前步骤未完成，请继续思考-执行-观察循环。\n")
-		sb.WriteString("3. 若当前步骤已完成，请输出 action=next_plan，并填写 goal_check 说明完成依据。\n")
-		sb.WriteString("4. 若整个任务已完成，请输出 action=done，并填写 goal_check 总结整体证据。\n")
-		sb.WriteString("5. 若缺少关键用户信息且现有上下文无法补足，请输出 action=ask_user。\n")
-		sb.WriteString("6. 若你判断当前流程应正式终止，而不是继续执行、追问或写工具，请输出 action=abort，并附带 abort 字段。\n")
-		sb.WriteString("7. 输出 next_plan 或 done 时，goal_check 不能为空，必须对照 done_when 逐条验证。\n")
-		sb.WriteString("\n")
-		sb.WriteString(BuildExecuteDecisionContractTextV2())
-	} else {
-		sb.WriteString("当前 plan 已存在，但当前步骤索引无效；请不要擅自执行其他步骤。\n")
-	}
-
-	return strings.TrimSpace(sb.String())
+func BuildExecuteUserPrompt(_ *newagentmodel.CommonState) string {
+	return strings.TrimSpace(`
+请继续当前任务的执行阶段，严格输出 JSON。
+输出字段：
+- speak
+- action
+- reason
+- goal_check
+- tool_call
+- abort
+`)
 }
 
-// BuildExecuteReActUserPrompt 构造纯 ReAct 模式的用户提示词。
-func BuildExecuteReActUserPrompt(state *newagentmodel.CommonState) string {
-	var sb strings.Builder
-
-	sb.WriteString("当前为自由执行模式，无预定义计划步骤。\n")
-	sb.WriteString("请根据用户意图直接使用工具完成请求。\n\n")
-
-	sb.WriteString(renderStateSummary(state))
-	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")
-	sb.WriteString("- 需要修改/写入数据 → action=confirm + tool_call（写工具，需用户确认）\n")
-	sb.WriteString("- 缺少关键信息 → action=ask_user\n")
-	sb.WriteString("- 任务完成 → action=done + goal_check\n")
-	sb.WriteString("- 当前流程应正式终止 → action=abort + abort\n\n")
-
-	sb.WriteString(BuildExecuteReActContractTextV2())
-
-	return strings.TrimSpace(sb.String())
+// BuildExecuteReActUserPrompt 构造自由执行模式的用户提示词。
+func BuildExecuteReActUserPrompt(_ *newagentmodel.CommonState) string {
+	return strings.TrimSpace(`
+请继续当前任务的执行阶段，严格输出 JSON。
+输出字段：
+- speak
+- action
+- reason
+- goal_check
+- tool_call
+- abort
+`)
 }

backend/newAgent/prompt/execute_context.go

@@ -0,0 +1,589 @@
+package newagentprompt
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	newagentmodel "github.com/LoveLosita/smartflow/backend/newAgent/model"
+	"github.com/cloudwego/eino/schema"
+)
+
+const (
+	executeHistoryKindKey            = "newagent_history_kind"
+	executeHistoryKindCorrectionUser = "llm_correction_prompt"
+
+	// executeLoopWindowLimit 控制“当轮 ReAct Loop 窗口”最多保留多少条记录。
+	// 采用固定窗口能避免上下文无上限增长，且可保持“最近行为”可追踪。
+	executeLoopWindowLimit = 8
+
+	// executeTrimmedObservationText 是重复工具压缩后的 observation 占位文案。
+	// 当同工具在窗口内出现多次时，只保留最新一条真实结果，其余旧结果统一替换为该文案。
+	executeTrimmedObservationText = "当前工具调用结果过于久远，已经被删除。"
+)
+
+type executeToolSchemaDoc struct {
+	Name       string         `json:"name"`
+	Parameters map[string]any `json:"parameters"`
+}
+
+type executeLoopRecord struct {
+	Thought     string
+	ToolName    string
+	ToolArgs    string
+	Observation string
+}
+
+// buildExecuteStageMessages 组装 execute 阶段 4 条消息骨架。
+//
+// 消息结构（固定）：
+// 1. message[0] 固定 prompt（规则 + 微调硬引导 + 输出约束 + 工具简表）
+// 2. message[1] 历史上下文（聊天摘要 + 早期 ReAct 摘要）
+// 3. message[2] 当轮 ReAct Loop 窗口（thought/reason + tool_call + observation 绑定展示）
+// 4. message[3] 当前执行状态（含初始目标、结束判断原则、非目标）
+func buildExecuteStageMessages(
+	stageSystemPrompt string,
+	state *newagentmodel.CommonState,
+	ctx *newagentmodel.ConversationContext,
+	runtimeUserPrompt string,
+) []*schema.Message {
+	msg0 := buildExecuteMessage0(stageSystemPrompt, ctx)
+	msg1 := buildExecuteMessage1(ctx)
+	msg2 := buildExecuteMessage2(ctx)
+	msg3 := buildExecuteMessage3(state, ctx, runtimeUserPrompt)
+
+	return []*schema.Message{
+		schema.SystemMessage(msg0),
+		{Role: schema.Assistant, Content: msg1},
+		{Role: schema.Assistant, Content: msg2},
+		schema.SystemMessage(msg3),
+	}
+}
+
+// buildExecuteMessage0 生成固定规则消息，并附带工具简表。
+func buildExecuteMessage0(stageSystemPrompt string, ctx *newagentmodel.ConversationContext) string {
+	base := strings.TrimSpace(mergeSystemPrompts(ctx, stageSystemPrompt))
+	if base == "" {
+		base = "你是 SmartFlow NewAgent 执行器，请继续 execute 阶段。"
+	}
+
+	toolCatalog := renderExecuteToolCatalogCompact(ctx)
+	if toolCatalog == "" {
+		return base
+	}
+	return base + "\n\n" + toolCatalog
+}
+
+// buildExecuteMessage1 生成历史上下文短摘要。
+func buildExecuteMessage1(ctx *newagentmodel.ConversationContext) string {
+	lines := []string{"历史上下文（仅供参考）："}
+	if ctx == nil {
+		lines = append(lines,
+			"- 用户目标：暂无可用历史输入。",
+			"- 阶段锚点：按当前工具事实推进执行。",
+			"- 早期 ReAct 摘要：暂无。",
+		)
+		return strings.Join(lines, "\n")
+	}
+
+	history := ctx.HistorySnapshot()
+	firstUser, lastUser := pickExecuteUserInputs(history)
+	switch {
+	case firstUser == "":
+		lines = append(lines, "- 用户目标：暂无可用历史输入。")
+	case lastUser != "" && lastUser != firstUser:
+		lines = append(lines, "- 用户目标："+firstUser+"；最近补充："+lastUser)
+	default:
+		lines = append(lines, "- 用户目标："+firstUser)
+	}
+
+	if hasExecuteRoughBuildDone(ctx) {
+		lines = append(lines, "- 阶段锚点：粗排已完成，本轮仅做微调，不重新 place。")
+	} else {
+		lines = append(lines, "- 阶段锚点：按当前工具事实推进，不做无依据操作。")
+	}
+
+	allLoops := collectExecuteLoopRecords(history)
+	lines = append(lines, "- 早期 ReAct 摘要："+buildEarlyExecuteReactSummary(allLoops, executeLoopWindowLimit))
+	return strings.Join(lines, "\n")
+}
+
+// buildExecuteMessage2 生成当轮 ReAct Loop 窗口。
+//
+// 规则：
+// 1. 每条记录都展示 thought/reason + tool_call + observation；
+// 2. 对窗口内重复工具应用压缩：同工具只保留最新一条真实 observation；
+// 3. 被压缩的旧 observation 统一替换为占位文案，避免语义断裂。
+func buildExecuteMessage2(ctx *newagentmodel.ConversationContext) string {
+	lines := []string{"当轮 ReAct Loop 记录（窗口）："}
+	if ctx == nil {
+		lines = append(lines, "- 暂无可用 ReAct 记录。")
+		return strings.Join(lines, "\n")
+	}
+
+	allLoops := collectExecuteLoopRecords(ctx.HistorySnapshot())
+	if len(allLoops) == 0 {
+		lines = append(lines, "- 暂无可用 ReAct 记录。")
+		return strings.Join(lines, "\n")
+	}
+
+	windowLoops := tailExecuteLoops(allLoops, executeLoopWindowLimit)
+	windowLoops = compressExecuteLoopObservationsByTool(windowLoops)
+	for i, loop := range windowLoops {
+		lines = append(lines, fmt.Sprintf("%d) thought/reason：%s", i+1, loop.Thought))
+		lines = append(lines, fmt.Sprintf("   tool_call：%s", renderExecuteToolCallText(loop.ToolName, loop.ToolArgs)))
+		lines = append(lines, fmt.Sprintf("   observation：%s", loop.Observation))
+	}
+	return strings.Join(lines, "\n")
+}
+
+// buildExecuteMessage3 生成当前执行状态与执行锚点。
+func buildExecuteMessage3(state *newagentmodel.CommonState, ctx *newagentmodel.ConversationContext, runtimeUserPrompt string) string {
+	lines := []string{"当前执行状态："}
+
+	roundUsed, maxRounds := 0, newagentmodel.DefaultMaxRounds
+	modeText := "自由执行（无预定义步骤）"
+	if state != nil {
+		roundUsed = state.RoundUsed
+		if state.MaxRounds > 0 {
+			maxRounds = state.MaxRounds
+		}
+		if state.HasPlan() {
+			modeText = "计划执行（有预定义步骤）"
+		}
+	}
+	lines = append(lines,
+		fmt.Sprintf("- 当前轮次：%d/%d", roundUsed, maxRounds),
+		"- 当前模式："+modeText,
+	)
+
+	goal := extractExecuteInitialGoal(ctx)
+	if goal == "" {
+		goal = "暂无可用目标描述，请按当前上下文稳步推进。"
+	}
+
+	lines = append(lines, "执行锚点：")
+	lines = append(lines, "- 初始用户目标："+goal)
+	if taskClassText := renderExecuteTaskClassIDs(state); taskClassText != "" {
+		lines = append(lines, "- 目标任务类："+taskClassText)
+	}
+	lines = append(lines, "- 啥时候结束Loop：你可以根据工具调用记录自行判断。")
+	lines = append(lines, "- 非目标：不重新粗排、不修改无关任务类。")
+	if hasExecuteRoughBuildDone(ctx) {
+		lines = append(lines, "- 阶段约束：粗排已完成，本轮只微调 suggested；existing 仅作已安排事实参考，不做 move/batch_move。")
+	}
+
+	// 兼容上层传入的执行指令；若为空则使用固定收口指令。
+	instruction := strings.TrimSpace(runtimeUserPrompt)
+	if instruction == "" {
+		instruction = "请继续当前任务执行阶段，严格输出 JSON。"
+	} else {
+		instruction = firstExecuteLine(instruction)
+	}
+	lines = append(lines, "本轮指令："+instruction)
+
+	return strings.Join(lines, "\n")
+}
+
+// renderExecuteToolCatalogCompact 将工具 schema 渲染成简表，避免大段 JSON 示例占用上下文。
+func renderExecuteToolCatalogCompact(ctx *newagentmodel.ConversationContext) string {
+	if ctx == nil {
+		return ""
+	}
+	schemas := ctx.ToolSchemasSnapshot()
+	if len(schemas) == 0 {
+		return ""
+	}
+
+	lines := []string{"可用工具（简表）："}
+	for i, schemaItem := range schemas {
+		name := strings.TrimSpace(schemaItem.Name)
+		desc := strings.TrimSpace(schemaItem.Desc)
+		if name == "" {
+			continue
+		}
+		if desc == "" {
+			desc = "无描述"
+		}
+		lines = append(lines, fmt.Sprintf("%d. %s：%s", i+1, name, desc))
+
+		doc := parseExecuteToolSchema(schemaItem.SchemaText)
+		paramSummary := renderExecuteToolParamSummary(doc.Parameters)
+		lines = append(lines, "   参数："+paramSummary)
+		returnType, returnSample := renderExecuteToolReturnHint(name)
+		lines = append(lines, "   返回类型："+returnType)
+		lines = append(lines, "   返回示例："+returnSample)
+	}
+
+	return strings.Join(lines, "\n")
+}
+
+// renderExecuteToolReturnHint 返回工具的“返回类型 + 最小示例”。
+//
+// 说明：
+// 1. 所有工具当前都返回 string（自然语言），这里主要补“内容形态示例”，减少模型盲猜；
+// 2. 示例只保留最小片段，避免工具说明过长挤占上下文窗口。
+func renderExecuteToolReturnHint(toolName string) (returnType string, sample string) {
+	returnType = "string（自然语言文本）"
+	switch strings.ToLower(strings.TrimSpace(toolName)) {
+	case "get_overview":
+		return returnType, "规划窗口共27天...课程占位条目34个...任务清单（全量，已过滤课程）..."
+	case "list_tasks":
+		return returnType, "已预排任务共24个： [35]第一章随机事件与概率 — 已预排至 第3天第5-6节..."
+	case "get_task_info":
+		return returnType, "[35]第一章随机事件与概率 | 状态：已预排(suggested) | 占用时段：第3天第5-6节"
+	case "find_first_free":
+		return returnType, "首个可用位置：第5天第1-2节（可直接放置）| 当日负载：总占6/12..."
+	case "find_free":
+		return returnType, "兼容别名，返回同 find_first_free。"
+	case "query_range":
+		return returnType, "第5天第3-6节：第3节空、第4节空..."
+	case "place":
+		return returnType, "已将 [35]... 预排到第5天第3-4节。"
+	case "move":
+		return returnType, "已将 [35]... 从第3天第5-6节移至第5天第3-4节。"
+	case "swap":
+		return returnType, "交换完成：[35]... ↔ [36]..."
+	case "batch_move":
+		return returnType, "批量移动完成，2个任务全部成功。"
+	case "unplace":
+		return returnType, "已将 [35]... 移除，恢复为待安排状态。"
+	default:
+		return returnType, "自然语言结果（成功/失败原因/关键数据摘要）。"
+	}
+}
+
+func parseExecuteToolSchema(schemaText string) executeToolSchemaDoc {
+	doc := executeToolSchemaDoc{Parameters: map[string]any{}}
+	schemaText = strings.TrimSpace(schemaText)
+	if schemaText == "" {
+		return doc
+	}
+	if err := json.Unmarshal([]byte(schemaText), &doc); err != nil {
+		return doc
+	}
+	if doc.Parameters == nil {
+		doc.Parameters = map[string]any{}
+	}
+	return doc
+}
+
+func renderExecuteToolParamSummary(parameters map[string]any) string {
+	if len(parameters) == 0 {
+		return "{}"
+	}
+
+	keys := make([]string, 0, len(parameters))
+	for key := range parameters {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	parts := make([]string, 0, len(keys))
+	for _, key := range keys {
+		status := "可选"
+		typeText := ""
+
+		switch typed := parameters[key].(type) {
+		case string:
+			status = "必填"
+			typeText = strings.TrimSpace(typed)
+		case map[string]any:
+			if required, ok := typed["required"].(bool); ok && required {
+				status = "必填"
+			}
+			typeText = strings.TrimSpace(asExecuteString(typed["type"]))
+			if enumRaw, ok := typed["enum"].([]any); ok && len(enumRaw) > 0 {
+				enumText := make([]string, 0, len(enumRaw))
+				for _, item := range enumRaw {
+					enumText = append(enumText, fmt.Sprintf("%v", item))
+				}
+				if typeText == "" {
+					typeText = "enum"
+				}
+				typeText += ":" + strings.Join(enumText, "/")
+			}
+		}
+
+		if typeText == "" {
+			parts = append(parts, fmt.Sprintf("%s(%s)", key, status))
+			continue
+		}
+		parts = append(parts, fmt.Sprintf("%s(%s,%s)", key, status, typeText))
+	}
+	return strings.Join(parts, "；")
+}
+
+// collectExecuteLoopRecords 从历史中提取 ReAct 记录。
+//
+// 提取策略：
+// 1. 以 assistant tool_call 消息为主键；
+// 2. 关联同 ToolCallID 的 tool result 作为 observation；
+// 3. 向前回溯最近一条 assistant 文本消息作为 thought/reason。
+func collectExecuteLoopRecords(history []*schema.Message) []executeLoopRecord {
+	if len(history) == 0 {
+		return nil
+	}
+
+	toolResultByCallID := make(map[string]*schema.Message, len(history))
+	for _, msg := range history {
+		if msg == nil || msg.Role != schema.Tool {
+			continue
+		}
+		callID := strings.TrimSpace(msg.ToolCallID)
+		if callID == "" {
+			continue
+		}
+		toolResultByCallID[callID] = msg
+	}
+
+	records := make([]executeLoopRecord, 0, len(history))
+	for i, msg := range history {
+		if msg == nil || msg.Role != schema.Assistant || len(msg.ToolCalls) == 0 {
+			continue
+		}
+		thought := findExecuteThoughtBefore(history, i)
+		for _, call := range msg.ToolCalls {
+			toolName := strings.TrimSpace(call.Function.Name)
+			if toolName == "" {
+				toolName = "unknown_tool"
+			}
+			toolArgs := compactExecuteText(call.Function.Arguments, 160)
+			if toolArgs == "" {
+				toolArgs = "{}"
+			}
+
+			observation := "该工具调用尚未返回结果。"
+			callID := strings.TrimSpace(call.ID)
+			if callID != "" {
+				if resultMsg, ok := toolResultByCallID[callID]; ok && resultMsg != nil {
+					text := strings.TrimSpace(resultMsg.Content)
+					if text != "" {
+						observation = text
+					}
+				}
+			}
+
+			records = append(records, executeLoopRecord{
+				Thought:     thought,
+				ToolName:    toolName,
+				ToolArgs:    toolArgs,
+				Observation: observation,
+			})
+		}
+	}
+	return records
+}
+
+func findExecuteThoughtBefore(history []*schema.Message, index int) string {
+	for i := index - 1; i >= 0; i-- {
+		msg := history[i]
+		if msg == nil || msg.Role != schema.Assistant {
+			continue
+		}
+		if len(msg.ToolCalls) > 0 {
+			continue
+		}
+		content := compactExecuteText(msg.Content, 140)
+		if content == "" {
+			continue
+		}
+		return content
+	}
+	return "（未记录）"
+}
+
+func tailExecuteLoops(records []executeLoopRecord, limit int) []executeLoopRecord {
+	if len(records) == 0 {
+		return nil
+	}
+	if limit <= 0 || len(records) <= limit {
+		result := make([]executeLoopRecord, len(records))
+		copy(result, records)
+		return result
+	}
+	result := make([]executeLoopRecord, limit)
+	copy(result, records[len(records)-limit:])
+	return result
+}
+
+// compressExecuteLoopObservationsByTool 对窗口内重复工具做 observation 压缩。
+//
+// 规则：
+// 1. 以“工具名”作为压缩键；
+// 2. 同工具仅保留最新一条 observation 原文；
+// 3. 旧记录保持 thought/tool_call，不丢记录，仅替换 observation。
+func compressExecuteLoopObservationsByTool(records []executeLoopRecord) []executeLoopRecord {
+	if len(records) == 0 {
+		return records
+	}
+
+	latestIndexByTool := make(map[string]int, len(records))
+	for i := len(records) - 1; i >= 0; i-- {
+		key := strings.ToLower(strings.TrimSpace(records[i].ToolName))
+		if key == "" {
+			key = "unknown_tool"
+		}
+		if _, exists := latestIndexByTool[key]; !exists {
+			latestIndexByTool[key] = i
+		}
+	}
+
+	result := make([]executeLoopRecord, len(records))
+	copy(result, records)
+	for i := range result {
+		key := strings.ToLower(strings.TrimSpace(result[i].ToolName))
+		if key == "" {
+			key = "unknown_tool"
+		}
+		if latestIndexByTool[key] != i {
+			result[i].Observation = executeTrimmedObservationText
+		}
+	}
+	return result
+}
+
+func renderExecuteToolCallText(toolName, toolArgs string) string {
+	toolName = strings.TrimSpace(toolName)
+	if toolName == "" {
+		toolName = "unknown_tool"
+	}
+	toolArgs = strings.TrimSpace(toolArgs)
+	if toolArgs == "" {
+		toolArgs = "{}"
+	}
+	return toolName + "(" + toolArgs + ")"
+}
+
+func buildEarlyExecuteReactSummary(records []executeLoopRecord, windowLimit int) string {
+	if len(records) == 0 {
+		return "暂无。"
+	}
+	if len(records) <= windowLimit {
+		return "无（当前窗口已覆盖全部 ReAct 记录）。"
+	}
+
+	early := records[:len(records)-windowLimit]
+	toolCounts := make(map[string]int, len(early))
+	for _, record := range early {
+		key := strings.TrimSpace(record.ToolName)
+		if key == "" {
+			key = "unknown_tool"
+		}
+		toolCounts[key]++
+	}
+
+	names := make([]string, 0, len(toolCounts))
+	for name := range toolCounts {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+
+	parts := make([]string, 0, len(names))
+	for _, name := range names {
+		parts = append(parts, fmt.Sprintf("%s×%d", name, toolCounts[name]))
+	}
+
+	return fmt.Sprintf("已折叠 %d 条旧记录，涉及：%s。", len(early), strings.Join(parts, "、"))
+}
+
+func extractExecuteInitialGoal(ctx *newagentmodel.ConversationContext) string {
+	if ctx == nil {
+		return ""
+	}
+	history := ctx.HistorySnapshot()
+	firstUser, _ := pickExecuteUserInputs(history)
+	return firstUser
+}
+
+func hasExecuteRoughBuildDone(ctx *newagentmodel.ConversationContext) bool {
+	if ctx == nil {
+		return false
+	}
+	for _, block := range ctx.PinnedBlocksSnapshot() {
+		if strings.TrimSpace(block.Key) == "rough_build_done" {
+			return true
+		}
+	}
+	return false
+}
+
+func pickExecuteUserInputs(history []*schema.Message) (first string, last string) {
+	realUsers := make([]string, 0, 2)
+	for _, msg := range history {
+		if msg == nil || msg.Role != schema.User {
+			continue
+		}
+		if isExecuteCorrectionPrompt(msg) {
+			continue
+		}
+		text := compactExecuteText(msg.Content, 120)
+		if text == "" {
+			continue
+		}
+		realUsers = append(realUsers, text)
+	}
+	if len(realUsers) == 0 {
+		return "", ""
+	}
+	return realUsers[0], realUsers[len(realUsers)-1]
+}
+
+func isExecuteCorrectionPrompt(msg *schema.Message) bool {
+	if msg == nil || msg.Role != schema.User {
+		return false
+	}
+	if msg.Extra != nil {
+		if kind, ok := msg.Extra[executeHistoryKindKey].(string); ok && strings.TrimSpace(kind) == executeHistoryKindCorrectionUser {
+			return true
+		}
+	}
+	content := strings.TrimSpace(msg.Content)
+	return strings.Contains(content, "请重新分析当前状态，输出正确的内容。")
+}
+
+func compactExecuteText(content string, maxLen int) string {
+	content = firstExecuteLine(content)
+	content = strings.TrimSpace(content)
+	if content == "" {
+		return ""
+	}
+	runes := []rune(content)
+	if len(runes) <= maxLen {
+		return content
+	}
+	if maxLen <= 3 {
+		return string(runes[:maxLen])
+	}
+	return string(runes[:maxLen-3]) + "..."
+}
+
+func firstExecuteLine(content string) string {
+	content = strings.TrimSpace(content)
+	if content == "" {
+		return ""
+	}
+	lines := strings.Split(content, "\n")
+	return strings.TrimSpace(lines[0])
+}
+
+func asExecuteString(value any) string {
+	if text, ok := value.(string); ok {
+		return text
+	}
+	return ""
+}
+
+func renderExecuteTaskClassIDs(state *newagentmodel.CommonState) string {
+	if state == nil || len(state.TaskClassIDs) == 0 {
+		return ""
+	}
+
+	parts := make([]string, len(state.TaskClassIDs))
+	for i, id := range state.TaskClassIDs {
+		parts[i] = strconv.Itoa(id)
+	}
+	return fmt.Sprintf("task_class_ids=[%s]", strings.Join(parts, ","))
+}

backend/newAgent/prompt/plan.go

@@ -27,7 +27,7 @@ const planSystemPrompt = `
    条件2：用户意图明确是"批量安排/帮我排课/把任务类排进日程"等批量调度需求。
    满足时：后端会在用户确认计划后自动运行粗排算法（硬性约束已由算法保证，无需 LLM 校验）。
    你的 plan_steps 应聚焦于"用读写工具优化方案"，建议两步：
-   第1步：用 get_overview / find_free 等读工具审视粗排结果，找出可优化的点（时段分布不均、空位未利用等）；
+   第1步：用 get_overview / find_first_free 等读工具审视粗排结果，找出可优化的点（时段分布不均、空位未利用等）；
    第2步：用 move / batch_move 等写工具微调后，将最终方案展示给用户确认。
    禁止安排任何"校验/验证约束"步骤——硬性约束由算法兜底，LLM 不需要操心。