重构: 巨函数拆分 + 清理历史标记注释 + custom_prompt/停止按钮/tunnel 改进

crates/df-nodes/src/ai_node.rs

@@ -45,7 +45,7 @@ impl Node for AiNode {
     async fn execute(&self, ctx: NodeContext) -> NodeResult {
         tracing::info!("AiNode 执行: node_id={}", ctx.node_id);
 
-        // FR-S1 注入链：provider 经 df_storage::secret 在 AiNode 内存解析，api_key 不进 config。
+        // provider 经 df_storage::secret 在 AiNode 内存解析，api_key 不进 config。
         let p = resolve_and_parse(&self.db, &ctx.config, &ctx.inputs).await?;
         let provider: Box<dyn LlmProvider> = provider_from_params(&p);
 
@@ -117,12 +117,12 @@ impl Node for AiNode {
                 "properties": {
                     "prompt": { "type": "string", "description": "用户提示词（若无则取上游 prompt 输出）" },
                     "system_prompt": { "type": "string", "description": "系统提示词（可选）" },
-                    "provider_id": { "type": "string", "description": "AI Provider ID（FR-S1：密钥经 df_storage::secret 解析，不进 config；留空走默认 provider）" },
+                    "provider_id": { "type": "string", "description": "AI Provider ID（密钥经 df_storage::secret 解析，不进 config；留空走默认 provider）" },
                     "model": { "type": "string", "description": "模型名（可选，留空用 record.default_model）" },
                     "temperature": { "type": "number", "description": "温度 0.0~2.0（可选）" },
                     "max_tokens": { "type": "integer", "description": "最大生成 token（可选，anthropic 协议无值时默认 4096）" },
                     "base_url": { "type": "string", "description": "（已废弃过渡）明文 API 地址，改用 provider_id" },
-                    "api_key": { "type": "string", "description": "（已废弃过渡）明文 API 密钥，改用 provider_id；FR-S1 下经 secret 解析" }
+                    "api_key": { "type": "string", "description": "（已废弃过渡）明文 API 密钥，改用 provider_id；密钥经 secret 解析" }
                 },
                 // SW-260618-15: prompt/provider_id 均"留空走兜底"(prompt 取上游、provider_id 走默认 provider),与 required 矛盾。改 required=[] 对齐 execute 运行时,防前端按 schema 误拒合法配置。
                 "required": []
@@ -231,7 +231,7 @@ mod tests {
     }
 
     // ============================================================
-    // resolve_provider 双路径测试(FR-S1 注入链核心)
+    // resolve_provider 双路径测试(注入链核心)
     // ============================================================
 
     /// 内存 DB 插 provider(可选 is_default)，返回 (db, provider_id)。

crates/df-nodes/src/ai_node_helpers.rs

@@ -10,7 +10,7 @@ use std::sync::Arc;
 
 use df_ai::df_ai_core::model::{Modality, ModelConfig};
 use df_ai::provider::LlmProvider;
-// F-01 阶段5: AiNode 路由 — 节点 config.model_id 优先;否则按 TaskRequirements 路由
+// AiNode 路由 — 节点 config.model_id 优先;否则按 TaskRequirements 路由
 // (默认 Standard + needs_tool_use=true)。池空/无匹配兜底 record.default_model。
 use df_ai::router::{select_model_id, TaskRequirements};
 use df_storage::crud::AiProviderRepo;
@@ -22,7 +22,7 @@ use df_workflow::node::{NodeOutput};
 /// AI 节点解析后的参数（execute 与参数解析解耦，便于单测覆盖取值/默认/校验逻辑）
 ///
 /// provider 配置（base_url/api_key/protocol/default_model）经 `resolve_provider` 从 DB
-/// ai_providers 表查 record + 经 df_storage::secret 解析密钥得到，**不进 config（FR-S1）**。
+/// ai_providers 表查 record + 经 df_storage::secret 解析密钥得到，**不进 config**。
 /// api_key 仅存于本结构体内存（AiNode 进程内存），不落 NodeContext.config / NodeOutput.data。
 #[derive(Debug)]
 pub(crate) struct AiNodeParams {
@@ -37,7 +37,7 @@ pub(crate) struct AiNodeParams {
 
 /// 经 `resolve_provider` 从 ai_providers 表 + df_storage::secret 解析后的 provider 构造要素。
 ///
-/// api_key 字段：明文，FR-S1 下全程不出 AiNode 进程内存（不进 config/output/schema）。
+/// api_key 字段：明文，全程不出 AiNode 进程内存（不进 config/output/schema）。
 #[derive(Debug, Clone)]
 pub(crate) struct ResolvedProvider {
     /// 协议类型：openai_compat（默认）/ anthropic（GLM 订阅 / Claude 官方）— 从 record.provider_type 映射
@@ -47,12 +47,12 @@ pub(crate) struct ResolvedProvider {
     pub api_key: String,
     /// model 为空时的占位（record.default_model 或 "gpt-4o-mini"），避免 provider 构造 panic
     pub default_model: String,
-    /// F-01 阶段5: 候选模型池(来自 record.model_configs)。parse_params 路由用:
+    /// 候选模型池(来自 record.model_configs)。parse_params 路由用:
     /// config.model 留空时经 select_model_id 选最优;池空兜底 default_model。
     pub model_pool: Vec<ModelConfig>,
 }
 
-/// 经 ai_providers 表 + df_storage::secret 解析 provider 构造要素（FR-S1 注入链核心）。
+/// 经 ai_providers 表 + df_storage::secret 解析 provider 构造要素（注入链核心）。
 ///
 /// 三路径（优先级从高到低）：
 /// 1. **provider_id 优先**：config["provider_id"] 存在 → `AiProviderRepo::get_by_id` 查 record →
@@ -114,7 +114,7 @@ pub(crate) async fn resolve_provider(
     let plain_key = config.get("api_key").and_then(|v| v.as_str());
     if let (Some(base_url_str), Some(api_key_str)) = (plain_base, plain_key) {
         tracing::warn!(
-            "AiNode 明文 api_key/base_url 经 config 注入已废弃, 改用 provider_id (FR-S1). \
+            "AiNode 明文 api_key/base_url 经 config 注入已废弃, 改用 provider_id. \
              老路径将在后续版本移除"
         );
         let base_url = base_url_str.to_string();
@@ -201,7 +201,7 @@ pub(crate) fn parse_params(
         .ok_or_else(|| anyhow::anyhow!("AiNode 缺少必填参数: prompt（config 或上游输入均无）"))?;
 
     // ── 可选参数 ──
-    // model 解析优先级(F-01 阶段5):config.model 显式指定 > 路由选优(provider.model_pool 非空时)
+    // model 解析优先级:config.model 显式指定 > 路由选优(provider.model_pool 非空时)
     //   > 空(CompletionRequest.model 留空由 provider impl 回填 default_model,行为不变)。
     //   注:provider.model_pool 在 provider move 进 AiNodeParams 前先借引用路由,选中的 model_id
     //   填入 CompletionRequest.model;provider.default_model 仍是 build_provider 兜底用。
@@ -213,7 +213,7 @@ pub(crate) fn parse_params(
     let model = if !config_model.is_empty() {
         config_model
     } else {
-        // F-01 阶段5: AiNode 默认路由 — needs_tool_use=true(工作流无人值守 AI 步骤
+        // AiNode 默认路由 — needs_tool_use=true(工作流无人值守 AI 步骤
         // 常含工具调用,如检索/生成;无需工具的节点应在 config 显式指定 model)。
         // select_model_id None(池空/无匹配)→ 空串(由 provider impl 回填 default_model)。
         let node_req = TaskRequirements {
@@ -289,10 +289,10 @@ pub(crate) fn truncate_for_summary(s: &str) -> String {
     format!("{truncated}…")
 }
 
-/// 阶段3 自审闸门决策(纯函数,便于单测覆盖各 verdict/gate 组合)。
+/// 自审闸门决策(纯函数,便于单测覆盖各 verdict/gate 组合)。
 ///
 /// 仅当 `gate==true` 且 `verdict=="fail"` 时阻断。verdict="unknown"(LLM 输出不可靠)
-/// 与 "pass" 均不阻断 —— unknown 保持人定权(阶段2 保守语义不变)。
+/// 与 "pass" 均不阻断 —— unknown 保持人定权(保守语义不变)。
 pub(crate) fn gate_should_block(gate: bool, verdict: &str) -> bool {
     gate && verdict == "fail"
 }

crates/df-nodes/src/ai_self_review_node.rs

@@ -74,7 +74,7 @@ impl Node for AiSelfReviewNode {
     async fn execute(&self, ctx: NodeContext) -> NodeResult {
         tracing::info!("AiSelfReviewNode 执行: node_id={}", ctx.node_id);
 
-        // FR-S1 注入链：provider 经 df_storage::secret 在 AiNode 内存解析，api_key 不进 config。
+        // provider 经 df_storage::secret 在 AiNode 内存解析，api_key 不进 config。
         let p = resolve_and_parse(&self.db, &ctx.config, &ctx.inputs).await?;
 
         // ── 读任务(需求 + 产出) ──
@@ -195,7 +195,7 @@ impl Node for AiSelfReviewNode {
             "model": response.model,
         }));
 
-        // ── 阶段3: 自审闸门(F-260616-07 决策 a 步骤③) ──
+        // ── 自审闸门 ──
         // config["gate"]==true 时,AiSelfReviewNode 从「自审辅助」升级为「DAG 节点闸门」:
         //   verdict="fail"   → 返回 Err → executor first_err 中止后续层(下游 human_review 不跑)
         //                       → 工作流 failed → ②-4 回调退回 in_review(对齐工作流失败语义)
@@ -214,7 +214,7 @@ impl Node for AiSelfReviewNode {
         //   C) executor 闸门检查钩子(节点 execute 后 executor 读 output.verdict):改 DagExecutor
         //      核心循环,牵动所有节点,风险/范围不符「最简不破坏」。
         // 选 A:语义最贴近「自审结果作为闸门」(自审节点自行决定放行/阻断),且 gate 可按节点
-        // config 开关(默认 false = 阶段2 行为不变,模板/前端零强制改动,向后兼容)。
+        // config 开关(默认 false = 辅助模式行为不变,模板/前端零强制改动,向后兼容)。
         let gate_enabled = ctx
             .config
             .get("gate")
@@ -241,10 +241,10 @@ impl Node for AiSelfReviewNode {
                 "type": "object",
                 "properties": {
                     "task_id": { "type": "string", "description": "自审目标任务 ID(必填)" },
-                    "provider_id": { "type": "string", "description": "AI Provider ID(FR-S1:密钥经 secret 解析不进 config;留空走默认 provider)" },
+                    "provider_id": { "type": "string", "description": "AI Provider ID(密钥经 secret 解析不进 config;留空走默认 provider)" },
                     "model": { "type": "string", "description": "模型名(可选,留空用 record.default_model)" },
                     "max_tokens": { "type": "integer" },
-                    "gate": { "type": "boolean", "description": "阶段3 闸门开关:false(默认)=自审辅助,verdict 仅透传展示;true=自审结果作 DAG 闸门,verdict=fail 返回 Err 阻断下游(工作流 failed → ②-4 退回),verdict=unknown/pass 放行" }
+                    "gate": { "type": "boolean", "description": "闸门开关:false(默认)=自审辅助,verdict 仅透传展示;true=自审结果作 DAG 闸门,verdict=fail 返回 Err 阻断下游(工作流 failed → ②-4 退回),verdict=unknown/pass 放行" }
                 },
                 "required": ["task_id", "provider_id"]
             }),
@@ -411,18 +411,18 @@ mod tests {
     }
 
     // ============================================================
-    // 阶段3 自审闸门(gate_should_block)单测
+    // 自审闸门(gate_should_block)单测
     // ============================================================
     //
     // gate 决策矩阵:
-    //   gate=false(默认,阶段2 行为) → 任何 verdict 都放行(辅助模式)
+    //   gate=false(默认,辅助模式行为) → 任何 verdict 都放行(辅助模式)
     //   gate=true + verdict=pass     → 放行
     //   gate=true + verdict=unknown  → 放行(LLM 不可靠时不阻断,人定权)
     //   gate=true + verdict=fail     → 阻断(返回 Err,工作流 failed)
 
     #[test]
     fn gate_disabled_never_blocks_any_verdict() {
-        // gate 默认 false(阶段2 兼容):无论 verdict 如何都不阻断,自审仅辅助展示
+        // gate 默认 false:无论 verdict 如何都不阻断,自审仅辅助展示
         assert!(!gate_should_block(false, "fail"), "gate 关闭时 fail 也不阻断");
         assert!(!gate_should_block(false, "pass"), "gate 关闭时 pass 放行");
         assert!(!gate_should_block(false, "unknown"), "gate 关闭时 unknown 放行");

crates/df-nodes/src/human_node.rs

@@ -40,7 +40,7 @@ impl Node for HumanNode {
             .and_then(|v| v.as_u64())
             .unwrap_or(3600);
 
-        // F-260615-01: 解析 select_type(缺省 Single,向后兼容)。非 "multiple" 一律按 Single 处理。
+        // 解析 select_type(缺省 Single,向后兼容)。非 "multiple" 一律按 Single 处理。
         let select_type = match config.get("select_type").and_then(|v| v.as_str()) {
             Some("multiple") => SelectType::Multiple,
             _ => SelectType::Single,
@@ -74,7 +74,7 @@ impl Node for HumanNode {
                     Ok(WorkflowEvent::HumanApprovalResponse {
                         execution_id, node_id, decision, decisions, comment,
                     }) if execution_id == ctx.execution_id && node_id == ctx.node_id => {
-                        // F-260615-01: 归一化决策集合(优先用 decisions 数组,空则回退兼容 decision 单值)
+                        // 归一化决策集合(优先用 decisions 数组,空则回退兼容 decision 单值)
                         //   select_type=Single → 决策数必须 =1
                         //   select_type=Multiple → 决策数必须 ≥1
                         //   options 空 → 允许自由文本(仅受数量约束);
@@ -91,24 +91,26 @@ impl Node for HumanNode {
                         let each_valid = picked.iter().all(|d| !d.is_empty())
                             && (options.is_empty() || picked.iter().all(|d| options.contains(d)));
                         if count_ok && each_valid {
-                            // F-260616-06 阶段2: 拒绝语义化。
+                            // 拒绝语义化。
                             //   审批拒绝此前与同意一样返 Ok —— 语义反转(审批被拒却报"成功"),
                             //   下游无法据 failed 触发退回/重做。
                             //   现:decision 命中拒绝关键字(见 REJECT_KEYWORDS)→ 返 Err
                             //   "人工审批被拒绝(用户选择: <decision>)",executor Err 分支 set_failed
-                            //   → 工作流 failed 状态 → 阶段2 推进链可据 failed 触发退回。
+                            //   → 工作流 failed 状态 → 推进链可据 failed 触发退回。
                             // 行为变更:审批拒绝从 Ok → Err,标注(同步通知主代理)。
                             if contains_reject(&picked) {
                                 let primary = picked.first().cloned().unwrap_or_default();
                                 let comment_str = comment.unwrap_or_default();
+                                // 意见后缀:空 comment 不拼接,非空才追加(避免空括号)
+                                let suffix = if comment_str.is_empty() {
+                                    String::new()
+                                } else {
+                                    format!("；意见: {}", comment_str)
+                                };
                                 return Err(anyhow::anyhow!(
                                     "人工审批被拒绝(用户选择: {}){}",
                                     primary,
-                                    if comment_str.is_empty() {
-                                        String::new()
-                                    } else {
-                                        format!("；意见: {}", comment_str)
-                                    }
+                                    suffix,
                                 ));
                             }
                             // 输出统一含 decisions 数组;保留 decision 取首项(向后兼容下游消费者)
@@ -225,7 +227,7 @@ mod tests {
     }
 
     /// 发一条审批响应到事件总线（模拟前端 approve_human_approval IPC 走完后的链路）。
-    /// F-260615-01: 单选调用方仅填 decision;多选调用方填 decisions。
+    /// 单选调用方仅填 decision;多选调用方填 decisions。
     async fn send_response(
         event_bus: &EventBus,
         execution_id: &str,
@@ -244,7 +246,7 @@ mod tests {
             .await;
     }
 
-    /// F-260615-01: 多选响应发送助手(填 decisions 数组,decision 留空)
+    /// 多选响应发送助手(填 decisions 数组,decision 留空)
     async fn send_response_multi(
         event_bus: &EventBus,
         execution_id: &str,
@@ -568,9 +570,9 @@ mod tests {
         assert_eq!(sm.get(&"h".to_string()), NodeStatus::Cancelled);
     }
 
-    // ===== F-260615-01: 多选审批覆盖 =====
+    // ===== 多选审批覆盖 =====
 
-    /// F-260615-01: select_type=multiple + 多 decisions(均∈options) → 返回 decisions 数组
+    /// select_type=multiple + 多 decisions(均∈options) → 返回 decisions 数组
     #[tokio::test]
     async fn multiple_select_returns_decisions_array() {
         let bus = EventBus::new();
@@ -596,7 +598,7 @@ mod tests {
         assert_eq!(out.data["comment"], json!("多选"));
     }
 
-    /// F-260615-01: select_type=single 缺省 + decisions 多个 → 校验失败(count!=1)忽略后超时
+    /// select_type=single 缺省 + decisions 多个 → 校验失败(count!=1)忽略后超时
     #[tokio::test]
     async fn single_select_rejects_multiple_decisions_then_timeout() {
         let bus = EventBus::new();
@@ -618,7 +620,7 @@ mod tests {
         assert!(err.contains("超时"), "single 下多 decisions 应被忽略后超时, 实际: {}", err);
     }
 
-    /// F-260615-01: select_type=multiple 但 decisions 含 ∉ options 的项 → 非法忽略后超时
+    /// select_type=multiple 但 decisions 含 ∉ options 的项 → 非法忽略后超时
     #[tokio::test]
     async fn multiple_select_invalid_option_ignored_then_timeout() {
         let bus = EventBus::new();
@@ -644,7 +646,7 @@ mod tests {
         assert!(err.contains("超时"), "含非法 option 应被忽略后超时, 实际: {}", err);
     }
 
-    /// F-260615-01: 兼容旧调用方 —— 不填 select_type(缺省 single) + 只填 decision 单值,应正常通过
+    /// 兼容旧调用方 —— 不填 select_type(缺省 single) + 只填 decision 单值,应正常通过
     /// (即所有未改造的现有 Request 均按 single 解析,零改动)
     #[tokio::test]
     async fn default_single_with_legacy_decision_single_value() {
@@ -664,10 +666,10 @@ mod tests {
         assert_eq!(out.data["decisions"], json!(["同意"]), "兼容回退后 decisions 应含单值");
     }
 
-    // ===== F-260616-06 阶段2: 审批拒绝语义化(行为变更: 拒绝从 Ok → Err) =====
+    // ===== 审批拒绝语义化(行为变更: 拒绝从 Ok → Err) =====
 
-    /// F-260616-06: 默认 options `["同意","拒绝"]` 下选「拒绝」→ Err（不再 Ok）。
-    /// 阶段2 推进链依赖工作流 failed 触发退回，故拒绝必须让节点返 Err → executor set_failed。
+    /// 默认 options `["同意","拒绝"]` 下选「拒绝」→ Err（不再 Ok）。
+    /// 推进链依赖工作流 failed 触发退回，故拒绝必须让节点返 Err → executor set_failed。
     #[tokio::test]
     async fn reject_decision_returns_error() {
         let bus = EventBus::new();
@@ -697,7 +699,7 @@ mod tests {
         );
     }
 
-    /// F-260616-06: 同一 options 下选「同意」→ Ok（通过路径不回归）。
+    /// 同一 options 下选「同意」→ Ok（通过路径不回归）。
     #[tokio::test]
     async fn approve_decision_still_ok() {
         let bus = EventBus::new();
@@ -718,7 +720,7 @@ mod tests {
         assert_eq!(out.data["decision"], json!("同意"));
     }
 
-    /// F-260616-06: 英文 reject 关键字同样识别为拒绝 → Err（归一化大小写/空白）。
+    /// 英文 reject 关键字同样识别为拒绝 → Err（归一化大小写/空白）。
     /// 多关键字覆盖走 reject_keyword_detection_normalized 纯单元测试,此处仅验证端到端一条。
     #[tokio::test]
     async fn english_reject_keyword_returns_error() {
@@ -744,7 +746,7 @@ mod tests {
         );
     }
 
-    /// F-260616-06: 多选场景,picked 含一项拒绝 → 整单拒绝 → Err
+    /// 多选场景,picked 含一项拒绝 → 整单拒绝 → Err
     /// （选了「驳回」即驳回,即便同时选了「同意」）。
     #[tokio::test]
     async fn multiple_select_with_one_reject_returns_error() {
@@ -776,7 +778,7 @@ mod tests {
         assert!(err.contains("拒绝"), "多选含拒绝项应返 Err, 实际: {}", err);
     }
 
-    /// F-260616-06: options 空的自由文本场景 —— 明确拒绝词("拒绝")仍返 Err,
+    /// options 空的自由文本场景 —— 明确拒绝词("拒绝")仍返 Err,
     /// 其余自由文本(非拒绝词)仍按通过处理(向后兼容,不阻断自由反馈)。
     #[tokio::test]
     async fn empty_options_free_text_reject_keyword_still_errors() {
@@ -793,7 +795,7 @@ mod tests {
         assert!(err.contains("拒绝"), "自由文本明确为拒绝词仍应 Err, 实际: {}", err);
     }
 
-    /// F-260616-06: options 空的自由文本场景 —— 非拒绝词自由文本仍返 Ok（不误伤自由反馈）。
+    /// options 空的自由文本场景 —— 非拒绝词自由文本仍返 Ok（不误伤自由反馈）。
     /// （empty_options_allows_free_text 已覆盖 "改成先做B方案" → Ok,此处补一条非拒绝中文短句。）
     #[tokio::test]
     async fn empty_options_non_reject_free_text_still_ok() {
@@ -810,7 +812,7 @@ mod tests {
         assert_eq!(out.data["decision"], json!("再讨论一下"));
     }
 
-    /// F-260616-06 单元: 关键字判定函数归一化(去空白+小写)与边界。
+    /// 单元: 关键字判定函数归一化(去空白+小写)与边界。
     #[test]
     fn reject_keyword_detection_normalized() {
         assert!(is_reject_decision("拒绝"));

crates/df-nodes/src/human_node_helpers.rs

@@ -3,9 +3,9 @@
 //! 从 human_node.rs 抽离的纯函数/常量(execute 与关键字判定解耦,便于单测覆盖)。
 //! HumanNode 的 struct + impl 仍保留在 human_node.rs(impl 块约束)。
 //!
-//! B-260615-05 / CR-260618-15: 拒绝语义化保留(executor set_failed → 推进链退回)。
+//! 拒绝语义化保留(executor set_failed → 推进链退回)。
 
-/// F-260616-06 阶段2: 拒绝语义化关键字。
+/// 拒绝语义化关键字。
 /// decision 归一化(去空白 + 小写)后命中此集合 → 审批拒绝 → 节点返 Err(触发工作流 failed)。
 ///
 /// 识别范围（避免误伤）：

crates/df-nodes/src/task_advance_node.rs

@@ -1,4 +1,4 @@
-//! 任务推进节点 — advance_task 推进链触发器(F-260616-02)
+//! 任务推进节点 — advance_task 推进链触发器。
 //!
 //! 实现推进链的唯一 status 写入路径(D-260616-03 落 df-nodes Node):
 //!   1. 读当前 TaskRecord(取 from status)

crates/df-nodes/src/task_state_machine.rs

@@ -1,8 +1,8 @@
-//! 任务推进状态机 — 7 态合法转换定义(F-260616-01)
+//! 任务推进状态机 — 7 态合法转换定义。
 //!
 //! 独立模块,非挂在 df-types::TaskStatus enum 上(对齐 D-260616-03「推进链业务逻辑落
 //! df-nodes」)。本模块只做「给定 from/to 是否合法」的纯函数判定,不触碰存储层
-//! (原子写 SQL 在 task_advance_node.rs 完成,见 F-260616-02)。
+//! (原子写 SQL 在 task_advance_node.rs 完成)。
 //!
 //! 7 态(与 df-types::TaskStatus / 前端对齐,D-260616-01):
 //!   todo / in_progress / in_review / testing / done / blocked / cancelled
@@ -124,7 +124,7 @@ pub fn is_regression(from: &str, to: &str) -> bool {
     matches!((from, to), (IN_REVIEW, IN_PROGRESS) | (TESTING, IN_REVIEW))
 }
 
-/// 工作流联动任务「失败退一步」的目标态映射(F-260616-06 ②-4)。
+/// 工作流联动任务「失败退一步」的目标态映射。
 ///
 /// 工作流失败时,任务不应停留在失败前向目标态,需回退到上一闸门重做。映射表:
 ///   - testing     → in_review(测试失败退回重审)

crates/df-nodes/src/task_workflow_templates.rs

@@ -1,4 +1,4 @@
-//! 任务推进链 DAG 模板(F-260616-06 阶段2 / D-260616-03)
+//! 任务推进链 DAG 模板。
 //!
 //! 推进链前向转换的工作流拓扑描述(声明式,纯数据)。DagDef 只描述节点与边,
 //! 执行逻辑靠 DagExecutor 驱动各 Node trait 的 execute —— 模板本身不跑逻辑。
@@ -51,7 +51,7 @@ fn in_progress_template() -> DagDef {
 
 /// in_review → testing:AiNode 自审 → HumanNode 核对。
 ///
-/// 拓扑:ai → human 串行。阶段3(本批)起 ai_self_review 启用 gate:true:
+/// 拓扑:ai → human 串行。ai_self_review 启用 gate:true:
 ///   - verdict=fail → AiSelfReviewNode 返回 Err → 工作流 failed(不经 human_review)
 ///     → ②-4 失败回调退回 in_review(review_rounds+=1)。
 ///   - verdict=unknown/pass → 放行 human_review,人定最终是否推进。
@@ -59,9 +59,9 @@ fn in_progress_template() -> DagDef {
 /// 通过则完成回调(②-3)推进 status 到 testing。
 fn testing_template() -> DagDef {
     let mut dag = DagDef::new();
-    // 决策 a 步骤③:ai_self_review 节点类型对齐 state.rs 注册的独立自审节点
+    // 决策:ai_self_review 节点类型对齐 state.rs 注册的独立自审节点
     // (四维度 prompt + JSON 解析兜底 + 写回 output_json 加 review 子字段)。
-    // 阶段3:gate=true 启用自审闸门(verdict=fail 阻断下游,工作流 failed)。
+    // gate=true 启用自审闸门(verdict=fail 阻断下游,工作流 failed)。
     dag.add_node(
         "ai_self_review",
         "ai_self_review",
@@ -135,13 +135,13 @@ mod tests {
         // 节点类型(决策 a 步骤③:ai_self_review 独立节点类型)
         let ai = dag.nodes.get("ai_self_review").expect("ai_self_review 存在");
         assert_eq!(ai.node_type, "ai_self_review");
-        // 阶段3:gate=true 启用自审闸门(verdict=fail 阻断下游)
+        // gate=true 启用自审闸门(verdict=fail 阻断下游)
         let gate = ai
             .config
             .get("gate")
             .and_then(|v| v.as_bool())
             .expect("ai_self_review config 应含 gate");
-        assert!(gate, "testing 模板 ai_self_review 应启用 gate:true(阶段3 闸门)");
+        assert!(gate, "testing 模板 ai_self_review 应启用 gate:true(闸门)");
         let human = dag.nodes.get("human_review").expect("human_review 存在");
         assert_eq!(human.node_type, "human");
         // 边方向:ai → human