@guanlin4924/devflow-pi 0.1.16 → 0.1.18

package/README.md

@@ -34,6 +34,8 @@ devflow-pi
 /usage-stats
 ```
 
+`/devflow project-init` 会在边界确认时提供两种模式：`plan`（默认，只读规划）和 `apply`（写入初始化）。选择 `apply` 并确认后，只会创建 Devflow 的 `.planning/` 与 `.context/` 初始化产物，不会修改业务源码、依赖或项目配置。
+
 用量统计默认只读取当前项目的隔离会话：`/usage-stats`。需要明确查看历史 OMP 会话时，使用 `/usage-stats omp`，或加筛选条件：`/usage-stats omp --from 2026-08-01 --to 2026-08-10`。历史统计保留真实会话路径，不再把不同项目的长会话文件合并成 `main`；统计只使用 assistant message 的原始 usage，不虚构工具调用成本分摊。
 
 会话继续使用 `devflow-pi --resume`；也可用 `devflow-pi --resume <session-id>` 打开当前项目的指定 Session。OMP 17.2.7 退出时仍会显示上游硬编码的 `omp --resume` 提示，在专项发行版中应替换为这里的 `devflow-pi --resume`，不会去读取官方 OMP 的 Session 目录。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanlin4924/devflow-pi",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "type": "module",
   "description": "Devflow 专项研发 Pi，基于固定版本 OMP Runtime 组装研发状态机、代码智能、设计、实现与质量门禁。",
   "license": "UNLICENSED",

package/plugins/devflow-core/extensions/devflow-core.ts

@@ -16,6 +16,13 @@ export type SessionControlState = {
   label: string;
 };
 
+type ProjectInitializationMode = "plan" | "apply";
+
+type ProjectInitializationRequest = {
+  summary: string;
+  mode: ProjectInitializationMode;
+};
+
 type ActiveExecutionContract = {
   contractId: string;
   feature: string;
@@ -91,6 +98,13 @@ export function planningState(intent: "project-init" | "requirement-draft"): Ses
   };
 }
 
+function parseProjectInitializationMode(value: string): ProjectInitializationMode | null {
+  const normalized = value.trim().toLowerCase();
+  if (["", "plan", "readonly", "read-only", "只读", "规划"].includes(normalized)) return "plan";
+  if (["apply", "write", "写入", "执行"].includes(normalized)) return "apply";
+  return null;
+}
+
 export function executingState(label = "当前工作流步骤执行"): SessionControlState {
   return { intent: "workflow-execute", phase: "executing", label };
 }
@@ -731,7 +745,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       confirm(title: string, message: string): Promise<boolean>;
       notify(message: string, type?: "info" | "warning" | "error"): void;
     };
-  }): Promise<string | null> {
+  }): Promise<ProjectInitializationRequest | null> {
     const projectName = await ctx.ui.input("Devflow 项目初始化", "项目名称（留空则使用当前目录）");
     const frontendPath = await ctx.ui.input("前端边界", "前端目录；没有请填写 none");
     if (frontendPath === undefined) return null;
@@ -739,18 +753,30 @@ export default function devflowCore(pi: ExtensionAPI) {
     if (backendPath === undefined) return null;
     const buildIndex = await ctx.ui.input("代码索引", "建立索引？输入 yes 或 no");
     if (buildIndex === undefined) return null;
+    const initializationMode = await ctx.ui.input("初始化方式", "输入 plan（只读规划，默认）或 apply（写入初始化）");
+    if (initializationMode === undefined) return null;
+    const mode = parseProjectInitializationMode(initializationMode);
+    if (!mode) {
+      ctx.ui.notify("初始化方式只能是 plan（只读规划）或 apply（写入初始化）；未写入任何文件。", "error");
+      return null;
+    }
+    const modeSummary = mode === "apply" ? "写入初始化" : "只读规划";
     const summary = [
       `项目名：${projectName?.trim() || "当前目录"}`,
       `前端：${frontendPath.trim() || "未提供"}`,
       `后端：${backendPath.trim() || "未提供"}`,
       `建立代码索引：${buildIndex.trim() || "未提供"}`,
+      `初始化方式：${modeSummary}`,
     ].join("\n");
-    const confirmed = await ctx.ui.confirm("确认项目初始化范围", `${summary}\n\n确认后只进入只读规划，不会创建工作流或写入项目文件。`);
+    const consequence = mode === "apply"
+      ? "确认后会创建 Devflow 的 .planning/ 与 .context/ 初始化产物；不会修改业务源码、依赖或项目配置。"
+      : "确认后只进入只读规划，不会创建工作流或写入项目文件。";
+    const confirmed = await ctx.ui.confirm("确认项目初始化范围", `${summary}\n\n${consequence}`);
     if (!confirmed) {
       ctx.ui.notify("项目初始化已取消；未写入任何文件。", "info");
       return null;
     }
-    return summary;
+    return { summary, mode };
   }
 
   async function runRuby(cwd: string, relativeScript: string, args: string[]) {
@@ -952,7 +978,7 @@ export default function devflowCore(pi: ExtensionAPI) {
   }
 
   let activeWorkflowTurn = false;
-  let pendingProjectInitialization: string | undefined;
+  let pendingProjectInitialization: ProjectInitializationRequest | undefined;
 
   async function triggerWorkflow(snapshot: Record<string, unknown>, source: "start" | "approval", requirementDraft?: string) {
     activeWorkflowTurn = true;
@@ -1013,7 +1039,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         }
         setControlState(ctx, executingState("执行已批准的项目初始化"));
         activeWorkflowTurn = true;
-        return { text: projectInitializationDirective(pendingProjectInitialization), handled: false };
+        return { text: projectInitializationDirective(pendingProjectInitialization.summary), handled: false };
       }
       if (controlAction === "reject") {
         ctx.ui.notify("已保留初始化规划，未创建任何项目控制文件。请直接说明需要调整的初始化范围。", "info");
@@ -1070,9 +1096,14 @@ export default function devflowCore(pi: ExtensionAPI) {
       return { handled: true };
     }
     if (intent === "project-init") {
-      const summary = await collectProjectInitialization(ctx);
-      if (!summary) return { handled: true };
-      pendingProjectInitialization = summary;
+      const initialization = await collectProjectInitialization(ctx);
+      if (!initialization) return { handled: true };
+      pendingProjectInitialization = initialization;
+      if (initialization.mode === "apply") {
+        setControlState(ctx, executingState("执行已确认的项目初始化"));
+        activeWorkflowTurn = true;
+        return { text: projectInitializationDirective(initialization.summary), handled: false };
+      }
       const state = planningState("project-init");
       setControlState(ctx, state);
       return {
@@ -1081,7 +1112,7 @@ export default function devflowCore(pi: ExtensionAPI) {
           "用户已确认项目初始化的输入。你现在是 Planner，只允许只读分析和派发 project-scout / requirements-auditor / contract-auditor。",
           "不得创建 .planning 文件、不得调用状态迁移、不得执行实现。",
           "先输出：已知事实、待验证点、最少侦察任务和必须由用户决定的问题。没有证据时写 unknown。",
-          summary,
+          initialization.summary,
           "</devflow-planner-directive>",
         ].join("\n"),
       };
@@ -1310,7 +1341,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       read: z.boolean().optional(),
       delta: z.object({
         op: z.enum(["add", "link", "update"]),
-        kind: z.enum(["source", "code", "term", "object", "behavior", "requirement", "rule", "boundary", "slice", "risk", "decision", "acceptance", "api"]).optional(),
+        kind: z.enum(["source", "code", "term", "object", "behavior", "requirement", "rule", "boundary", "slice", "risk", "decision", "acceptance", "api", "workload_shape", "workload_constraint"]).optional(),
         id: z.string().min(1).optional(),
         data: z.record(z.string(), z.unknown()).optional(),
         from: z.string().min(1).optional(),
@@ -1340,6 +1371,36 @@ export default function devflowCore(pi: ExtensionAPI) {
           return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "confirm requires expectedRevision, nodeId and evidence" });
         }
         args.push("--write", "--expected-revision", String(params.expectedRevision), "--node-id", params.nodeId, "--evidence-json", JSON.stringify(params.evidence));
+        const inspected = parseJsonResult(
+          await runRuby(ctx.cwd, "workflow-orchestrator/scripts/requirement_graph.rb", ["inspect", "--feature", params.feature, "--json"]),
+        );
+        const node = Array.isArray(inspected?.graph?.nodes)
+          ? inspected.graph.nodes.find((candidate: unknown) => typeof candidate === "object" && candidate !== null && (candidate as { id?: unknown }).id === params.nodeId) as { kind?: unknown; data?: unknown } | undefined
+          : undefined;
+        const architectureDecision = node?.kind === "decision" && typeof node?.data === "object" && node.data !== null && (node.data as { decision_type?: unknown }).decision_type === "architecture_option_comparison";
+        const architectureRisk = node?.kind === "risk" && typeof node?.data === "object" && node.data !== null && (node.data as { risk_type?: unknown }).risk_type === "architecture_option_risk";
+        if (node?.kind === "workload_shape" || node?.kind === "workload_constraint" || architectureDecision || architectureRisk) {
+          const preview = JSON.stringify(node.data ?? {}, null, 2);
+          const decisionDialog = architectureDecision;
+          const riskDialog = architectureRisk;
+          const confirmed = await ctx.ui.confirm(
+            decisionDialog ? "确认架构方案取舍" : riskDialog ? "确认架构风险处理" : "确认工作负载事实或缺口",
+            [
+              `Feature：${params.feature}`,
+              `节点：${params.nodeId}`,
+              `类型：${decisionDialog ? "架构方案比较" : riskDialog ? "架构风险处理" : node.kind === "workload_shape" ? "工作负载形态" : "工作负载约束"}`,
+              decisionDialog
+                ? "确认的含义是：你已核对候选方案、证据与取舍，并接受其中 recommendation_option_id 作为本次架构选择。"
+                : riskDialog
+                  ? "确认的含义是：你已核对失败模式、影响、处理方式、负责人和复核条件；它不代表生产风险从此消失。"
+                : "确认的含义仅是：该事实或缺口、来源与责任归属已被你核对；它不代表容量已经满足，也不会替你选择实现方案。",
+              "待确认内容：",
+              preview.length > 8_000 ? `${preview.slice(0, 8_000)}\n…（内容过长，已截断）` : preview,
+            ].join("\n\n"),
+          );
+          if (!confirmed) return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "User declined workload confirmation; node remains candidate." });
+          args.push("--confirmed-interactively");
+        }
       }
       return renderResult(
         await runRuby(ctx.cwd, "workflow-orchestrator/scripts/requirement_graph.rb", args),
@@ -1348,6 +1409,222 @@ export default function devflowCore(pi: ExtensionAPI) {
     },
   });
 
+  pi.registerTool({
+    name: "devflow_runtime_context",
+    label: "Devflow Runtime Context",
+    description: "Collect or inspect the P0 repository-declared dependency snapshot and its coverage.",
+    parameters: z.object({
+      action: z.enum(["collect", "inspect"]),
+    }),
+    approval: (args) => args.action === "collect" ? "write" : "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/runtime_context_collector.rb", [params.action, "--json"]),
+        { action: params.action },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_static_runtime_context",
+    label: "Devflow Static Runtime Context",
+    description: "Collect or inspect the P1 static evidence snapshot. It records only repository declarations and references, never production health or capacity.",
+    parameters: z.object({
+      action: z.enum(["collect", "inspect"]),
+    }),
+    approval: (args) => args.action === "collect" ? "write" : "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/static_runtime_context_collector.rb", [params.action, "--json"]),
+        { action: params.action },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_architecture_assessment",
+    label: "Devflow Architecture Assessment",
+    description: "Confirm an immutable delta set through an explicit user dialog, then assess only that Core-owned manifest against a pinned runtime-context snapshot.",
+    parameters: z.object({
+      action: z.enum(["inspect", "assess", "write-manifest"]),
+      feature: z.string().min(1),
+      baseSnapshotRevision: z.number().int().min(0).optional(),
+      deltaSetId: z.string().min(1).optional(),
+      deltaJson: z.array(z.record(z.string(), z.unknown())).optional(),
+      sourceBundleRevision: z.string().min(1).optional(),
+      expectedAssessmentRevision: z.number().int().min(0).optional(),
+      write: z.boolean().optional(),
+    }),
+    approval: (args) => args.action === "write-manifest" || args.write ? "write" : "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      const args = [params.action, "--feature", params.feature, "--json"];
+      if (params.action === "inspect") {
+        if (params.deltaSetId) args.push("--delta-set-id", params.deltaSetId);
+        return renderResult(
+          await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_assessment.rb", args),
+          { action: params.action, feature: params.feature },
+        );
+      }
+      if (!params.deltaSetId) {
+        return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "deltaSetId is required" });
+      }
+      args.push("--delta-set-id", params.deltaSetId);
+      if (params.action === "assess") {
+        if (params.baseSnapshotRevision === undefined) {
+          return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "assess requires baseSnapshotRevision and deltaSetId; deltas and manifest are Core-owned" });
+        }
+        args.push("--base-snapshot-revision", String(params.baseSnapshotRevision));
+        if (params.write) {
+          const inspected = parseJsonResult(await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_assessment.rb", ["inspect", "--feature", params.feature, "--delta-set-id", params.deltaSetId, "--json"]));
+          const currentRevision = typeof inspected?.current_assessment_revision === "number" ? inspected.current_assessment_revision : undefined;
+          if (currentRevision === undefined) {
+            return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "Unable to read the current assessment revision for CAS." });
+          }
+          args.push("--write", "--expected-assessment-revision", String(currentRevision));
+        }
+      }
+      if (params.action === "write-manifest") {
+        if (!params.sourceBundleRevision || !params.deltaJson?.length) {
+          return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "write-manifest requires deltaSetId, sourceBundleRevision and a non-empty deltaJson" });
+        }
+        const preview = params.deltaJson.map((rawDelta, index) => {
+          const delta = rawDelta as Record<string, unknown>;
+          const source = delta.source && typeof delta.source === "object" ? delta.source as Record<string, unknown> : {};
+          return [
+            `${index + 1}. ID：${String(delta.id ?? "(缺失)")}`,
+            `依赖：${String(delta.subject ?? "(缺失)")}`,
+            `来源：${String(source.locator ?? "(缺失)")}`,
+            `来源 revision：${String(source.repository_revision ?? "(缺失)")}`,
+            `内容哈希：${String(source.input_hash ?? "(缺失)")}`,
+          ].join("\n");
+        }).join("\n\n");
+        const confirmed = await ctx.ui.confirm(
+          "确认架构评估 Delta 集合",
+          [
+            `Feature：${params.feature}`,
+            `Delta 集合：${params.deltaSetId}`,
+            `需求/方案 revision：${params.sourceBundleRevision}`,
+            "确认后 Core 会创建不可覆盖的 manifest；后续评估只能读取这一份确认内容。",
+            "请核对以下依赖、来源与哈希：",
+            preview,
+          ].join("\n\n"),
+        );
+        if (!confirmed) return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "User declined delta-set confirmation; no manifest was written." });
+        args.push("--source-bundle-revision", params.sourceBundleRevision, "--delta-json", JSON.stringify(params.deltaJson), "--confirmed-interactively", "--write");
+      }
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_assessment.rb", args),
+        { action: params.action, feature: params.feature },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_workload_constraint",
+    label: "Devflow Workload Constraint",
+    description: "Validate a workload constraint (NFR) against its source-status schema.",
+    parameters: z.object({
+      constraintJson: z.record(z.string(), z.unknown()),
+    }),
+    approval: "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/workload_constraint.rb", ["validate", "--constraint-json", JSON.stringify(params.constraintJson), "--json"]),
+        {},
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_architecture_constraint",
+    label: "Devflow Architecture Constraint",
+    description: "Validate candidate workload shape or workload constraint inputs without assigning confirmation, decisions, or gate status.",
+    parameters: z.object({
+      action: z.enum(["validate-shape", "validate-constraint"]),
+      shapeJson: z.record(z.string(), z.unknown()).optional(),
+      constraintJson: z.record(z.string(), z.unknown()).optional(),
+    }),
+    approval: "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      if (params.action === "validate-shape" && !params.shapeJson) {
+        return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "validate-shape requires shapeJson" });
+      }
+      if (params.action === "validate-constraint" && !params.constraintJson) {
+        return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "validate-constraint requires constraintJson" });
+      }
+      const args = [params.action, "--json"];
+      if (params.shapeJson) args.push("--shape-json", JSON.stringify(params.shapeJson));
+      if (params.constraintJson) args.push("--constraint-json", JSON.stringify(params.constraintJson));
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_constraints.rb", args),
+        { action: params.action },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_architecture_feasibility",
+    label: "Devflow Architecture Feasibility",
+    description: "Read confirmed workload facts and a pinned static-context snapshot to derive an advisory architecture assessment. It never selects an option or claims production capacity.",
+    parameters: z.object({
+      feature: z.string().min(1),
+    }),
+    approval: "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_feasibility.rb", ["assess", "--feature", params.feature, "--json"]),
+        { feature: params.feature },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_architecture_brief",
+    label: "Devflow Architecture Brief",
+    description: "Inspect or regenerate the Core-derived architecture brief from the current graph and static-context snapshot. The brief is a view, never an agent-authored source of truth.",
+    parameters: z.object({
+      action: z.enum(["inspect", "render"]),
+      feature: z.string().min(1),
+    }),
+    approval: (args) => args.action === "render" ? "write" : "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      if (params.action === "inspect") {
+        return renderResult(
+          await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_brief.rb", ["inspect", "--feature", params.feature, "--json"]),
+          { action: params.action, feature: params.feature },
+        );
+      }
+      const inspected = parseJsonResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_brief.rb", ["inspect", "--feature", params.feature, "--json"]),
+      );
+      const currentRevision = typeof inspected?.brief_revision === "number" ? inspected.brief_revision : undefined;
+      if (currentRevision === undefined) {
+        return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "Unable to read the current architecture brief revision for CAS." });
+      }
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_brief.rb", ["render", "--feature", params.feature, "--write", "--expected-brief-revision", String(currentRevision), "--json"]),
+        { action: params.action, feature: params.feature },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_stale_check",
+    label: "Devflow Stale Check",
+    description: "Check field-level staleness of consumed evidence against the current snapshot.",
+    parameters: z.object({
+      consumedRevision: z.number().int().min(0),
+      evidencePaths: z.array(z.string().min(1)),
+    }),
+    approval: "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/stale_check.rb", ["check", "--consumed-revision", String(params.consumedRevision), "--evidence-paths", JSON.stringify(params.evidencePaths), "--json"]),
+        {},
+      );
+    },
+  });
+
   pi.registerTool({
     name: "devflow_evidence",
     label: "Devflow Evidence Pack",
@@ -1780,9 +2057,15 @@ export default function devflowCore(pi: ExtensionAPI) {
         return;
       }
       if (trimmed === "project-init") {
-        const summary = await collectProjectInitialization(ctx);
-        if (!summary) return;
-        pendingProjectInitialization = summary;
+        const initialization = await collectProjectInitialization(ctx);
+        if (!initialization) return;
+        pendingProjectInitialization = initialization;
+        if (initialization.mode === "apply") {
+          setControlState(ctx, executingState("执行已确认的项目初始化"));
+          activeWorkflowTurn = true;
+          await pi.sendUserMessage(projectInitializationDirective(initialization.summary));
+          return;
+        }
         setControlState(ctx, planningState("project-init"));
         await pi.sendUserMessage(
           [
@@ -1790,7 +2073,7 @@ export default function devflowCore(pi: ExtensionAPI) {
             "用户已确认项目初始化的输入。你现在是 Planner，只允许只读分析和派发 project-scout / requirements-auditor / contract-auditor。",
             "不得创建 .planning 文件、不得调用状态迁移、不得执行实现。",
             "先输出：已知事实、待验证点、最少侦察任务和必须由用户决定的问题。没有证据时写 unknown。",
-            summary,
+            initialization.summary,
             "</devflow-planner-directive>",
           ].join("\n"),
         );

package/plugins/devflow-core/skills/workflow-orchestrator/SKILL.md

@@ -117,6 +117,7 @@ After each step completes, verify the step's gate before advancing:
 | requirement-feasibility-review | 可实现性审查.meta.json `status=ready_for_baseline`、`baseline_gate=pass`、`gap_count=0` 且无 critical finding | Reject advance to requirement-baseline |
 | requirement-baseline | baseline.md review conclusion is "通过" AND baseline.meta.json `review_status` / `traceability_status` are `passed` AND blocking counters are all 0 | Reject advance to api-contract |
 | api-contract | api-contract.meta.json `review_status` / `traceability_status` are `passed` AND `pending_contract_count` is 0 | Reject advance to dual tracks |
+| architecture-feasibility | Core-derived `architecture-brief.md` / meta exist. If `assessment_level=full`, require `assessment_status=ready` and `comparison_status=confirmed`; a lightweight incomplete result may proceed only as an explicitly unresolved downstream input. | Reject advance to dual tracks for an incomplete full assessment |
 | ui-spec | UI-SPEC.md review conclusion is "通过" | Reject advance to feature-breakdown |
 | feature-breakdown | 功能点梳理.md review conclusion is "通过" | Reject advance to tech-specs |
 | api-call-guide | api-call-guide.meta.json `frontend_consumable` and `mock_ready` are true, pending_items is empty | Reject merge gate |
@@ -161,8 +162,8 @@ When the inspector returns `route_failure_branch`:
 When the inspector returns `run_parallel_window`:
 
 0. **Track filtering**（新增）：读取 STATE.md 的 `active_track` 字段
-   - 如果 `active_track == "A"`：只路由完整需求主链及 Track A 步骤（requirement-triage、requirement-wayfinder、domain-modeling、requirement-feasibility-review、requirement-baseline、api-contract、backend-tech-spec、api-call-guide），完成后阻断在轨道边界
-   - 如果 `active_track == "B"`：新需求必须完成完整需求主链；前端设计步骤仍依赖 api-contract。允许步骤为 requirement-triage、requirement-wayfinder、domain-modeling、requirement-feasibility-review、requirement-baseline、api-contract、ui-spec、feature-breakdown、frontend-tech-spec、api-supplement，完成后阻断在轨道边界
+   - 如果 `active_track == "A"`：只路由完整需求主链及 Track A 步骤（requirement-triage、requirement-wayfinder、domain-modeling、requirement-feasibility-review、requirement-baseline、api-contract、architecture-feasibility、backend-tech-spec、api-call-guide），完成后阻断在轨道边界
+   - 如果 `active_track == "B"`：新需求必须完成完整需求主链；前端设计步骤仍依赖 api-contract 和 architecture-feasibility。允许步骤为 requirement-triage、requirement-wayfinder、domain-modeling、requirement-feasibility-review、requirement-baseline、api-contract、architecture-feasibility、ui-spec、feature-breakdown、frontend-tech-spec、api-supplement，完成后阻断在轨道边界
    - 如果未设置或无效：保留全部 branch_steps（双轨道）
    - 过滤后如果只剩一个步骤，退化为串行执行（不启动并行窗口）