Version: 0.7.1.dev.260320

🧠 agent智能编排：删除了落库相关逻辑。再次重申：agent智能编排旨在为用户预览排程结果，实际的落库由用户决定，并通过按钮触发常规接口进行落库。目前仅保留 ReAct 精排循环链路（待改进）。
📄 修改了 ReAct 智能精排决策文档相关内容。
🔄 undo：当前 agent 智能排程逻辑待改进。

backend/agent/scheduleplan/graph.go

@@ -14,14 +14,6 @@ const (
 	schedulePlanGraphNodePlan = "schedule_plan_plan"
 	// 图节点：调用粗排算法生成候选方案
 	schedulePlanGraphNodePreview = "schedule_plan_preview"
-	// 图节点：将候选方案转换为可落库结构
-	schedulePlanGraphNodeMaterialize = "schedule_plan_materialize"
-	// 图节点：执行落库
-	schedulePlanGraphNodeApply = "schedule_plan_apply"
-	// 图节点：分析失败原因并生成修补方案
-	schedulePlanGraphNodeReflect = "schedule_plan_reflect"
-	// 图节点：生成最终回复文案
-	schedulePlanGraphNodeFinalize = "schedule_plan_finalize"
 	// 图节点：退出（用于提前终止分支）
 	schedulePlanGraphNodeExit = "schedule_plan_exit"
 	// 图节点：构建混合日程（ReAct 精排前置）
@@ -55,13 +47,9 @@ type SchedulePlanGraphRunInput struct {
 //
 // 图结构：
 //
-//	START -> plan -> [branch] -> preview -> [branch] -> materialize -> [branch] -> apply -> [branch]
-//	                    |                      |                          |                     |
-//	                   exit                   exit                       exit               finalize (成功)
-//	                                                                                          |
-//	                                                                                       reflect -> [branch] -> apply (重试)
-//	                                                                                                      |
-//	                                                                                                   finalize (放弃)
+//	START -> plan -> [branch] -> preview -> [branch] -> hybridBuild -> [branch] -> reactRefine -> returnPreview -> END
+//	                    |                      |                          |
+//	                   exit                   exit                       exit
 //
 // 该文件只负责"连线与分支"，节点内部逻辑全部下沉到 nodes.go。
 func RunSchedulePlanGraph(ctx context.Context, input SchedulePlanGraphRunInput) (*SchedulePlanState, error) {
@@ -105,18 +93,6 @@ func RunSchedulePlanGraph(ctx context.Context, input SchedulePlanGraphRunInput)
 	if err := graph.AddLambdaNode(schedulePlanGraphNodePreview, compose.InvokableLambda(runner.previewNode)); err != nil {
 		return nil, err
 	}
-	if err := graph.AddLambdaNode(schedulePlanGraphNodeMaterialize, compose.InvokableLambda(runner.materializeNode)); err != nil {
-		return nil, err
-	}
-	if err := graph.AddLambdaNode(schedulePlanGraphNodeApply, compose.InvokableLambda(runner.applyNode)); err != nil {
-		return nil, err
-	}
-	if err := graph.AddLambdaNode(schedulePlanGraphNodeReflect, compose.InvokableLambda(runner.reflectNode)); err != nil {
-		return nil, err
-	}
-	if err := graph.AddLambdaNode(schedulePlanGraphNodeFinalize, compose.InvokableLambda(runner.finalizeNode)); err != nil {
-		return nil, err
-	}
 	if err := graph.AddLambdaNode(schedulePlanGraphNodeExit, compose.InvokableLambda(runner.exitNode)); err != nil {
 		return nil, err
 	}
@@ -148,19 +124,18 @@ func RunSchedulePlanGraph(ctx context.Context, input SchedulePlanGraphRunInput)
 		return nil, err
 	}
 
-	// 8. preview -> [branch] -> hybridBuild | materialize | exit
+	// 8. preview -> [branch] -> hybridBuild | exit
 	if err := graph.AddBranch(schedulePlanGraphNodePreview, compose.NewGraphBranch(
 		runner.nextAfterPreview,
 		map[string]bool{
 			schedulePlanGraphNodeHybridBuild: true,
-			schedulePlanGraphNodeMaterialize: true,
 			schedulePlanGraphNodeExit:        true,
 		},
 	)); err != nil {
 		return nil, err
 	}
 
-	// 8.1 hybridBuild -> [branch] -> reactRefine | exit
+	// 9. hybridBuild -> [branch] -> reactRefine | exit
 	if err := graph.AddBranch(schedulePlanGraphNodeHybridBuild, compose.NewGraphBranch(
 		runner.nextAfterHybridBuild,
 		map[string]bool{
@@ -171,62 +146,24 @@ func RunSchedulePlanGraph(ctx context.Context, input SchedulePlanGraphRunInput)
 		return nil, err
 	}
 
-	// 8.2 reactRefine -> returnPreview（固定边）
+	// 10. reactRefine -> returnPreview（固定边）
 	if err := graph.AddEdge(schedulePlanGraphNodeReactRefine, schedulePlanGraphNodeReturnPreview); err != nil {
 		return nil, err
 	}
 
-	// 8.3 returnPreview -> END
+	// 11. returnPreview -> END
 	if err := graph.AddEdge(schedulePlanGraphNodeReturnPreview, compose.END); err != nil {
 		return nil, err
 	}
 
-	// 9. materialize -> [branch] -> apply | exit
-	if err := graph.AddBranch(schedulePlanGraphNodeMaterialize, compose.NewGraphBranch(
-		runner.nextAfterMaterialize,
-		map[string]bool{
-			schedulePlanGraphNodeApply: true,
-			schedulePlanGraphNodeExit:  true,
-		},
-	)); err != nil {
-		return nil, err
-	}
-
-	// 10. apply -> [branch] -> finalize | reflect
-	if err := graph.AddBranch(schedulePlanGraphNodeApply, compose.NewGraphBranch(
-		runner.nextAfterApply,
-		map[string]bool{
-			schedulePlanGraphNodeFinalize: true,
-			schedulePlanGraphNodeReflect:  true,
-		},
-	)); err != nil {
-		return nil, err
-	}
-
-	// 11. reflect -> [branch] -> apply (重试) | finalize (放弃)
-	if err := graph.AddBranch(schedulePlanGraphNodeReflect, compose.NewGraphBranch(
-		runner.nextAfterReflect,
-		map[string]bool{
-			schedulePlanGraphNodeApply:    true,
-			schedulePlanGraphNodeFinalize: true,
-		},
-	)); err != nil {
-		return nil, err
-	}
-
-	// 12. finalize -> END
-	if err := graph.AddEdge(schedulePlanGraphNodeFinalize, compose.END); err != nil {
-		return nil, err
-	}
-
-	// 13. exit -> END
+	// 12. exit -> END
 	if err := graph.AddEdge(schedulePlanGraphNodeExit, compose.END); err != nil {
 		return nil, err
 	}
 
-	// 14. 运行步数上限：原有链路 ~10 步 + ReAct 精排（hybridBuild + reactRefine + returnPreview = 3）。
-	//     加余量到 25，防止异常分支导致无限循环。
-	maxSteps := 25
+	// 13. 运行步数上限：plan + preview + hybridBuild + reactRefine + returnPreview = 5 步，
+	//     加余量到 15，防止异常分支导致无限循环。
+	maxSteps := 15
 
 	// 15. 编译图得到可执行实例。
 	runnable, err := graph.Compile(ctx,