@guanlin4924/devflow-pi 0.1.105 → 0.1.107

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

@@ -19,6 +19,7 @@ import { generateProjectDocuments } from "../../../src/project-documents.ts";
 import { preparedRolloverRevision } from "../../../src/session-rollover.ts";
 import { describeStartupIssue, renderStartupBriefing } from "../../../src/startup-briefing.ts";
 import { PRODUCT_VERSION } from "../../../src/constants.ts";
+import { dynamicWorkflowDirective, renderDynamicWorkflow } from "../../../src/dynamic-workflow.ts";
 import {
   FIX_LABELS,
   buildHelpBundle,
@@ -233,12 +234,13 @@ type ActiveExecutionContract = {
   stateRevision?: number;
   graphRevision?: number;
   workflowFingerprint?: string;
+  scope?: string;
+  branchContracts?: unknown[];
   allowedPaths: string[];
   allowedAgents: string[];
   allowedTools: string[];
   checkerIds: string[];
   toolBudget: number;
-  hardGateMode: "chain" | "core";
   frozenHash: string;
   contractPath?: string;
   acceptance: string[];
@@ -256,12 +258,13 @@ function contractFromRecord(record: Record<string, unknown>): ActiveExecutionCon
     stateRevision: typeof record.state_revision === "number" ? record.state_revision : undefined,
     graphRevision: typeof record.graph_revision === "number" ? record.graph_revision : undefined,
     workflowFingerprint: typeof record.workflow_fingerprint === "string" ? record.workflow_fingerprint : undefined,
+    scope: typeof record.scope === "string" ? record.scope : undefined,
+    branchContracts: Array.isArray(record.branch_contracts) ? record.branch_contracts : undefined,
     allowedPaths: strings("allowed_paths"),
     allowedAgents: strings("allowed_agents"),
     allowedTools: strings("allowed_tools"),
     checkerIds: strings("checker_ids"),
     toolBudget: typeof record.tool_budget === "number" ? record.tool_budget : 0,
-    hardGateMode: record.hard_gate_mode === "core" ? "core" : "chain",
     frozenHash: String(record.frozen_hash ?? ""),
     acceptance: strings("acceptance"),
     allowedGraphDelta: strings("allowed_graph_delta"),
@@ -271,10 +274,6 @@ function contractFromRecord(record: Record<string, unknown>): ActiveExecutionCon
   return contract;
 }
 
-function coreHardGatesEnabled(contract: ActiveExecutionContract | undefined): boolean {
-  return contract?.hardGateMode === "core";
-}
-
 const READ_ONLY_TOOLS = new Set([
   "read",
   "grep",
@@ -821,6 +820,7 @@ const REQUIRED_EXTENSION_TOOLS = [
 ];
 
 const REQUIRED_SKILLS = [
+  "workflow-dynamic",
   "code-index-query",
   "code-review",
   "requirement-feasibility-review",
@@ -878,6 +878,7 @@ const REQUIRED_MODEL_ROLES = ["@smol", "@task", "@slow"];
 const REQUIRED_AGENT_NAMES = new Set(Object.keys(REQUIRED_AGENTS));
 
 const REQUIRED_SCRIPTS = [
+  "workflow-orchestrator/scripts/dynamic_plan.rb",
   "workflow-orchestrator/scripts/init_workflow.rb",
   "workflow-orchestrator/scripts/init_state.rb",
   "workflow-orchestrator/scripts/phase_ownership.rb",
@@ -1316,7 +1317,7 @@ function selectedWorkflowStep(snapshot: Record<string, unknown>): Record<string,
  * completed step. This predicate lets the runtime re-arm approval handling
  * from the Core-owned snapshot without granting approval by itself.
  */
-function isReviewableWorkflowSnapshot(snapshot: Record<string, unknown>, options: { strictRegistry?: boolean } = {}): boolean {
+function isReviewableWorkflowSnapshot(snapshot: Record<string, unknown>, options: { strictRegistry?: boolean; allowAdvisory?: boolean } = {}): boolean {
   const status = snapshot.status;
   if (status !== "waiting_checkpoint" && status !== "not_started" && status !== "in_progress") return false;
   const step = snapshot.current_step;
@@ -1326,7 +1327,8 @@ function isReviewableWorkflowSnapshot(snapshot: Record<string, unknown>, options
   // Core-generated quality findings are advisory by default. Re-arm the AI
   // review even when an output is stale or its generated validity metadata is
   // incomplete; only the control-plane shape itself remains a hard boundary.
-  if (process.env.DEVFLOW_SOFT_GATES !== "0" && snapshot.action === "await_user_confirmation") return true;
+  if (snapshot.action !== "run_parallel_window" &&
+      (options.allowAdvisory || snapshot.action === "await_user_confirmation")) return true;
   const outputs = Array.isArray(stepRecord.outputs) ? stepRecord.outputs : [];
   const requiredOutputs = outputs.filter(output => {
     if (!output || typeof output !== "object") return false;
@@ -1386,7 +1388,7 @@ export function workflowResumeDisposition(snapshot: Record<string, unknown>): Wo
   return "blocked";
 }
 
-function workflowDirective(snapshot: Record<string, unknown>, source: "start" | "approval", requirementDraft?: string, briefing?: string): string {
+export function workflowDirective(snapshot: Record<string, unknown>, source: "start" | "approval", requirementDraft?: string, briefing?: string): string {
   const selectedStep = selectedWorkflowStep(snapshot);
   const reviewInstructions = selectedStep?.id === "code-review"
     ? [
@@ -1407,6 +1409,7 @@ function workflowDirective(snapshot: Record<string, unknown>, source: "start" |
     checkpoint: snapshot.checkpoint,
     step: selectedStep,
     parallel_window: snapshot.parallel_window,
+    parallel_run: snapshot.parallel_run,
     failure_branch: snapshot.failure_branch,
     reason: snapshot.reason,
     recovery: snapshot.recovery,
@@ -1414,7 +1417,8 @@ function workflowDirective(snapshot: Record<string, unknown>, source: "start" |
   };
   const parallelInstructions = snapshot.action === "run_parallel_window"
     ? [
-      "这是并行窗口：先按 parallel_run 中的 branch 记录逐个调用 task；一个 task 只能负责一个 workflow_step，不得把多个 step 合并到一个子 Agent。",
+      "当前合同 scope=parallel_window：current_step 只是汇合锚点，不要执行 integration-verify 或读取它的 Skill；按 parallel_window.branch_steps 中当前可运行的分支读取各自精确 skill，并遵守合同 branch_contracts 的逐分支权限。",
+      "这是并行窗口：仅派发 parallel_window.branch_steps 中当前可运行的分支，并从 parallel_run 中匹配 branch 记录逐个调用 task；一个 task 只能负责一个 workflow_step，不得把多个 step 合并到一个子 Agent。",
       "本窗口的 branch step（backend-tech-spec、api-call-guide、ui-spec、feature-breakdown、frontend-tech-spec、api-supplement）统一使用白名单 agent implementation-worker；不要把 workflow step 名称当作 agent 名称。",
       "只有执行验证类步骤才使用 verification-runner；project-scout、requirements-auditor、contract-auditor、devflow-code-reviewer 不属于本并行窗口的默认执行 agent。",
       "每个 task 的提示必须原样包含 DEVFLOW_BRANCH_ID、DEVFLOW_WORKFLOW_STEP、DEVFLOW_TRACK、DEVFLOW_ATTEMPT 和 DEVFLOW_BRANCH_REVISION，并只写该分支的白名单产物。",
@@ -1424,16 +1428,15 @@ function workflowDirective(snapshot: Record<string, unknown>, source: "start" |
     : [];
   return [
     "<devflow-runtime-directive>",
-    briefing
-      ? "Devflow Runtime 已完成开工预检（环境、交接、状态、合同、输入），以下开工简报中的事实已经核实；执行合同已激活，不要再次调用 devflow_state inspect 或 devflow_contract activate。读取 skill://workflow-pipeline，并只执行当前项目的一个工作流步骤。"
-      : "Devflow Runtime 已完成环境与状态检查。读取 skill://workflow-pipeline，并只执行当前项目的一个工作流步骤。",
+    ...(["当前为全软门禁模式：产物、索引、合同、质量、审查和恢复检查只提供诊断。缺失输入先利用已有证据尽力完成，未解决项写入报告；不得因检查未通过而停止整个流程，不得伪造测试通过或人工批准。CP 节点不强制审批，用户要求下一步即可继续。真实工具执行失败仍须如实报告。"]),
+    "读取 skill://workflow-pipeline，按当前步骤或并行分支执行；开工简报、执行合同与 Skill 中的门禁要求在本模式下均为建议。",
     ...(briefing
       ? ["<startup-briefing>", briefing, "</startup-briefing>"]
-      : ["先调用 devflow_state(action=\"inspect\") 重新确认 revision，再调用 devflow_contract(action=\"status\")；若没有匹配当前 feature/current_step 的 fresh contract，立即调用 devflow_contract(action=\"activate\", feature=<current_feature>, step=<current_step>)，激活成功后才能执行或写入。"]),
-    "只按 inspector 返回的当前 step 加载所需 Skill：step.skill 是精确 ID，必须读取 skill://<step.skill>，不得自行添加 workflow- 前缀或改写名称；本回合严禁读取或写入 xd://devflow_transition，严禁调用 devflow_transition，严禁执行 Skill 中的 complete-step/confirm-checkpoint，不得推进下一步骤；状态写回和会话切换由 Runtime 在用户确认后独占处理。",
-    ...reviewInstructions,
+      : ["可按需查看状态与合同；缺失或过期合同不阻止执行。"]),
+    "串行步骤按 inspector.current_step，并行窗口按可运行分支加载所需 Skill：step.skill 是精确 ID，必须读取 skill://<step.skill>，不得自行添加 workflow- 前缀或改写名称；本回合严禁读取或写入 xd://devflow_transition，严禁调用 devflow_transition，严禁执行 Skill 中的 complete-step/confirm-checkpoint，不得推进下一步骤；状态写回和会话切换由 Runtime 在用户确认后独占处理。",
+    ...([]),
     ...(parallelInstructions.length > 0 ? parallelInstructions : [
-      "完成本步骤的真实产物后，报告证据、未决项和验证结果并停止。请用户审查后明确回复“批准执行”才可推进；回复修改意见或“拒绝执行”则不得推进。",
+      "完成当前步骤后报告证据、未决项和检查警告。用户要求下一步即可继续；不要把质量检查失败当作流程阻塞，也不要自报未执行的检查已通过。",
     ]),
     "当前步骤信封：",
     JSON.stringify(envelope, null, 2),
@@ -1535,6 +1538,7 @@ export function isShellControlMutation(toolName: string, input: unknown): boolea
   }
   const command = String((input as Record<string, unknown>).command ?? (input as Record<string, unknown>).cmd ?? "");
   if (!command) return false;
+  if (/\bdynamic_plan\.rb\b/.test(command)) return true;
   const invokesWriter =
     /workflow-orchestrator\/scripts\/(?:advance_state|init_state|init_workflow|sync_artifacts|requirement_graph|machine_evidence|execution_contract)\.rb[^\n]*--write/.test(
       command,
@@ -1997,6 +2001,10 @@ export default function devflowCore(pi: ExtensionAPI) {
   const reviewBindingKey = randomBytes(32).toString("hex");
   const pendingReviewTasks = new Map<string, { feature: string; contractId: string }>();
   const completedReviewTasks = new Map<string, { feature: string; contractId: string; report: Record<string, unknown> }>();
+  const dynamicReviewBindings = new Map<string, { taskId: string; attempt: string; revision: number }>();
+  const dynamicReviewResults = new Map<string, { taskId: string; attempt: string; revision: number; report: Record<string, unknown> }>();
+  let dynamicTurnRevision: number | undefined;
+  let dynamicTurnProgress: string | undefined;
   let latestReviewTaskCallId: string | undefined;
   let projectRoot: string | undefined;
 
@@ -2109,6 +2117,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       const content = lines.map((line, index) => {
         if (index === 0) return theme.bold(theme.fg("accent", line));
         if (line.startsWith("──")) return theme.fg("accent", line);
+        if (line.startsWith("—")) return theme.fg("dim", line);
         return theme.fg("muted", line);
       }).join("\n");
       panel.addChild(new Text(content, 0, 0));
@@ -2160,7 +2169,12 @@ export default function devflowCore(pi: ExtensionAPI) {
       graph && typeof graph === "object" && typeof (graph as Record<string, unknown>).revision === "number"
         ? (graph as Record<string, number>).revision
         : undefined;
-    return stateRevision === contract.stateRevision && graphRevision === contract.graphRevision;
+    if (stateRevision !== contract.stateRevision || graphRevision !== contract.graphRevision) return false;
+    const inspected = parseJsonResult(await runRuby(cwd, "workflow-orchestrator/scripts/execution_contract.rb", [
+      "inspect", "--feature", contract.feature, "--step", contract.step, "--json",
+    ]));
+    const current = inspected?.contract as Record<string, unknown> | undefined;
+    return current?.frozen_hash === contract.frozenHash;
   }
 
   // A successful graph mutation is already constrained by the active contract's
@@ -2254,22 +2268,6 @@ export default function devflowCore(pi: ExtensionAPI) {
     }
     const contract = contractFromRecord(raw as Record<string, unknown>);
     if (!contract) return { ok: false, reason: "Core returned an invalid execution contract." };
-    const confirmed = await ctx.ui.confirm(
-      "激活 Devflow 执行合同",
-      [
-        `合同：${contract.contractId}`,
-        `Feature：${contract.feature}`,
-        `步骤：${contract.step}`,
-        `STATE revision：${contract.stateRevision ?? "未初始化"}`,
-        `图谱 revision：${contract.graphRevision ?? 0}`,
-        `可写路径：${contract.allowedPaths.join(", ")}`,
-        `允许 Agent：${contract.allowedAgents.join(", ")}`,
-        `固定检查器：${contract.checkerIds.join(", ") || "无"}`,
-        `冻结哈希：${contract.frozenHash}`,
-        "确认后低成本模型只能在以上范围执行；未知项必须阻塞升级。",
-      ].join("\n"),
-    );
-    if (!confirmed) return { ok: false, reason: "User declined execution contract activation." };
     try {
       const createArgs = ["create", "--feature", feature, "--step", step, "--write", "--json"];
       if (contract.stateRevision !== undefined) createArgs.push("--expected-state-revision", String(contract.stateRevision));
@@ -2618,80 +2616,17 @@ export default function devflowCore(pi: ExtensionAPI) {
     snapshot: Record<string, unknown>,
     options: { doctorAlreadyPassed?: boolean; handoffPath?: string } = {},
   ): Promise<{ ok: true; briefing?: string } | { ok: false }> {
-    if (options.doctorAlreadyPassed !== true) {
-      const report = await runDoctor(ctx);
-      if (!report.ok) {
-        setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "开工预检失败" });
-        ctx.ui.notify(formatDoctorReport(report).slice(0, 10000), "error");
-        return { ok: false };
-      }
-    }
-    if (workflowResumeDisposition(snapshot) !== "execute" || snapshot.action === "run_parallel_window") {
-      return { ok: true };
-    }
-
-    try {
-    const feature = typeof snapshot.current_feature === "string" ? snapshot.current_feature : "";
-    const step = String(selectedWorkflowStep(snapshot)?.id ?? "");
-    if (!feature || !step) {
-      setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "开工预检未通过" });
-      ctx.ui.notify("开工预检未通过：当前 Feature 或步骤不可用。", "error");
-      return { ok: false };
-    }
-    let contract = activeContract;
-    if (!contract || contract.feature !== feature || contract.step !== step || !(await contractIsFresh(ctx.cwd, contract))) {
-      const activated = await activateExecutionContract(ctx, feature, step);
-      if (!activated.ok) {
-        setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "开工预检：执行合同未激活" });
-        ctx.ui.notify(`开工预检：执行合同未激活。${activated.reason}`, "error");
-        return { ok: false };
-      }
-      contract = activated.contract;
-    }
-    if (!contract.contractPath) {
-      setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "开工预检：执行合同未激活" });
-      ctx.ui.notify("开工预检：执行合同未激活。合同冻结路径不可用。", "error");
-      return { ok: false };
-    }
-    const contractAbsolute = path.resolve(ctx.cwd, contract.contractPath);
-    const contractRelative = path.relative(ctx.cwd, contractAbsolute).split(path.sep).join("/");
-    if (!contractRelative || contractRelative === ".." || contractRelative.startsWith("../")) {
-      setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "开工预检：执行合同未激活" });
-      ctx.ui.notify("开工预检：执行合同未激活。合同冻结路径越出项目。", "error");
-      return { ok: false };
-    }
-    const preflight = await runPython(ctx.cwd, "workflow-orchestrator/scripts/startup_preflight.py", [
-      "--root", ctx.cwd,
-      "--feature", feature,
-      "--step", step,
-      "--contract", contractRelative,
-      ...(options.handoffPath ? ["--handoff", options.handoffPath] : []),
-    ]);
-    const payload = parseJsonOutput(preflight);
-    if (!payload || payload.status !== "ready") {
-      setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "开工预检未通过" });
+      const feature = String(snapshot.current_feature ?? "");
+      const step = String(selectedWorkflowStep(snapshot)?.id ?? "");
+      const diagnostics = await runPython(ctx.cwd, "workflow-orchestrator/scripts/startup_preflight.py", [
+        "--root", ctx.cwd, "--feature", feature, "--step", step,
+        ...(options.handoffPath ? ["--handoff", options.handoffPath] : []),
+      ]);
+      const payload = parseJsonOutput(diagnostics);
       const issues = Array.isArray(payload?.issues) ? payload.issues : [];
-      const details = issues.length > 0
-        ? issues.map(issue => `- ${describeStartupIssue(issue && typeof issue === "object" ? issue as Record<string, unknown> : {})}`).join("\n")
-        : "- 开工预检输出无法解析";
-      ctx.ui.notify(`开工预检未通过：\n${details}\n可以说「下一步」，由 Devflow 诊断并给出处理办法。`, "error");
-      return { ok: false };
+      if (!diagnostics.ok || issues.length) ctx.ui.notify(`软门禁提示：${JSON.stringify(issues.length ? issues : diagnostics.stderr)}`, "info");
+      return { ok: true, briefing: `软门禁模式：以下是诊断结果，缺项不阻止执行，失败检查不代表通过。\n${JSON.stringify(payload ?? { error: diagnostics.stderr })}` };
     }
-    const facts = payload.facts && typeof payload.facts === "object" ? payload.facts as Record<string, unknown> : {};
-    const handoff = payload.handoff && typeof payload.handoff === "object" ? payload.handoff as Record<string, unknown> : {};
-    return {
-      ok: true,
-      briefing: renderStartupBriefing(facts, handoff, {
-        revision: snapshot.revision,
-        handoffProvided: Boolean(options.handoffPath),
-      }),
-    };
-    } catch (error) {
-      setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "开工预检未通过" });
-      ctx.ui.notify(`开工预检未通过：${error instanceof Error ? error.message : String(error)}`, "error");
-      return { ok: false };
-    }
-  }
 
   async function startWorkflowAfterPreflight(
     ctx: DoctorContext & {
@@ -2708,6 +2643,21 @@ export default function devflowCore(pi: ExtensionAPI) {
   ): Promise<void> {
     const preflight = await runStartupPreflight(ctx, snapshot, options);
     if (!preflight.ok) return;
+    if (snapshot.action === "run_parallel_window") {
+      snapshot = await prepareParallelRun(ctx.cwd, snapshot);
+      const feature = String(snapshot.current_feature ?? "");
+      const step = String(compactStep(snapshot.current_step)?.id ?? "");
+      if (!activeContract || activeContract.scope !== "parallel_window" || !(await contractIsFresh(ctx.cwd, activeContract))) {
+        const activated = await activateExecutionContract(ctx, feature, step);
+        if (!activated.ok) {
+          parallelRunActive = false;
+          setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "并行窗口合同未激活" });
+          ctx.ui.notify(`并行窗口合同未激活：${activated.reason}`, "info");
+
+          parallelRunActive = true;
+        }
+      }
+    }
     setControlState(ctx, executingState(options.executingLabel));
     if (preflight.briefing) await triggerWorkflow(snapshot, source, undefined, preflight.briefing);
     else if (source === "start") await triggerWorkflow(snapshot, "start");
@@ -2719,6 +2669,22 @@ export default function devflowCore(pi: ExtensionAPI) {
     return { result, snapshot: parseJsonResult(result) };
   }
 
+  async function runDynamicPlan(cwd: string, request: Record<string, unknown>): Promise<ProcessResult> {
+    assertRuntimeProjectBoundary(cwd);
+    return runProcess(["ruby", path.join(resolveKitRoot(cwd), "workflow-orchestrator/scripts/dynamic_plan.rb")], cwd, {}, JSON.stringify(request));
+  }
+
+  async function startDynamicTurn(ctx: { ui: { notify(message: string, level: "info" | "error"): void } }, snapshot: Record<string, unknown>) {
+    ctx.ui.notify(renderDynamicWorkflow(snapshot), "info");
+    if (["ready", "cancelled"].includes(String(snapshot.delivery))) return;
+    dynamicTurnRevision = Number(snapshot.revision);
+    dynamicTurnProgress = String(snapshot.progress_key);
+    activeContract = undefined;
+    activeWorkflowTurn = true;
+    controlState = executingState("执行中文工作流");
+    await pi.sendUserMessage(dynamicWorkflowDirective(snapshot));
+  }
+
   async function inspectWorkflowWithRegistryRecovery(cwd: string): Promise<{ result: ProcessResult; snapshot: Record<string, unknown> | null }> {
     let inspected = await inspectWorkflow(cwd);
     const errors = Array.isArray(inspected.snapshot?.state_validation && (inspected.snapshot.state_validation as Record<string, unknown>).errors)
@@ -2818,7 +2784,7 @@ export default function devflowCore(pi: ExtensionAPI) {
     ]));
     if (existing?.ok === true && existing.run) {
       parallelRunActive = true;
-      return { ...snapshot, parallel_run: existing.run };
+      return refreshedParallelSnapshot(cwd, existing.run);
     }
     const revision = typeof snapshot.revision === "number" ? snapshot.revision : undefined;
     if (!feature || !workflowWindow || revision === undefined) throw new Error("parallel window snapshot is incomplete");
@@ -2834,7 +2800,18 @@ export default function devflowCore(pi: ExtensionAPI) {
       throw new Error(prepared.stderr || prepared.stdout || "parallel run prepare failed");
     }
     parallelRunActive = true;
-    return { ...snapshot, parallel_run: payload.run };
+    return refreshedParallelSnapshot(cwd, payload.run);
+  }
+
+  async function refreshedParallelSnapshot(cwd: string, run: unknown): Promise<Record<string, unknown>> {
+    // prepare increments STATE. Recover the derived registry before building
+    // the directive, including when resuming a previously stranded run.
+    const fresh = await inspectWorkflowWithRegistryRecovery(cwd);
+    if (!fresh.result.ok || fresh.snapshot?.action !== "run_parallel_window") {
+      parallelRunActive = false;
+      throw new Error(`并行准备后状态不可调度：${JSON.stringify(fresh.snapshot ?? fresh.result.stderr)}`);
+    }
+    return { ...fresh.snapshot, parallel_run: run };
   }
 
   async function triggerWorkflow(snapshot: Record<string, unknown>, source: "start" | "approval", requirementDraft?: string, briefing?: string) {
@@ -2867,6 +2844,10 @@ export default function devflowCore(pi: ExtensionAPI) {
     snapshot: Record<string, unknown>,
     options: { doctorAlreadyPassed: boolean },
   ): Promise<WorkflowResumeDisposition> {
+    if (snapshot.mode === "dynamic") {
+      await startDynamicTurn(ctx, snapshot);
+      return snapshot.delivery === "ready" ? "complete" : "execute";
+    }
     const disposition = workflowResumeDisposition(snapshot);
     const stepId = String(selectedWorkflowStep(snapshot)?.id ?? "当前步骤");
     if (disposition === "execute") {
@@ -2905,60 +2886,15 @@ export default function devflowCore(pi: ExtensionAPI) {
     ui: { confirm(title: string, body: string): Promise<boolean>; notify(message: string, level: "info" | "error"): void; setStatus(key: string, text: string | undefined): void };
   }): Promise<boolean> {
     const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
-    if (!inspected.result.ok || !inspected.snapshot || !isReviewableWorkflowSnapshot(inspected.snapshot)) return false;
+    if (!inspected.result.ok || !inspected.snapshot || !isReviewableWorkflowSnapshot(inspected.snapshot, { allowAdvisory: true })) return false;
     const step = compactStep(inspected.snapshot.current_step);
     const stepId = typeof step?.id === "string" ? step.id : undefined;
     const revision = typeof inspected.snapshot.revision === "number" ? inspected.snapshot.revision : undefined;
     if (!stepId || revision === undefined) return false;
     const checkpoint = inspected.snapshot.status === "waiting_checkpoint";
-    let cp3Prerequisites: Array<{ id?: unknown; kind?: unknown; summary?: unknown }> = [];
-    if (checkpoint && inspected.snapshot.checkpoint === "CP-3") {
-      const feature = typeof inspected.snapshot.current_feature === "string" ? inspected.snapshot.current_feature : undefined;
-      if (!feature) return false;
-      const suite = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/acceptance_test_suite.rb", [
-        "inspect", "--feature", feature, "--json",
-      ]);
-      const suitePayload = parseJsonResult(suite);
-      if (!suite.ok || !suitePayload || suitePayload.ok !== true) {
-        setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "CP-3 前置检查失败" });
-        ctx.ui.notify(`无法读取 CP-3 测试前置事实：${suite.stderr || suite.stdout}`, "error");
-        return true;
-      }
-      cp3Prerequisites = Array.isArray(suitePayload.unconfirmed_prerequisites)
-        ? suitePayload.unconfirmed_prerequisites as Array<{ id?: unknown; kind?: unknown; summary?: unknown }>
-        : [];
-    }
-    const prerequisiteReview = cp3Prerequisites.length > 0
-      ? [
-          "",
-          `CP-3 检测到 ${cp3Prerequisites.length} 个尚未确认、但被候选验收测试引用的前置事实。批准后 Core 会在同一原子事务中确认它们并冻结测试集：`,
-          ...cp3Prerequisites.map(item => `- ${String(item.id ?? "?")} [${String(item.kind ?? "?")}]${item.summary ? `：${String(item.summary)}` : ""}`),
-        ].join("\n")
-      : "";
-    const approved = await ctx.ui.confirm(
-      "确认推进 Devflow 工作流",
-      `当前步骤：${stepId}\n\n步骤产物已生成并通过基础校验。确认${checkpoint ? "当前 checkpoint 并" : ""}推进到下一步骤吗？${prerequisiteReview}`,
-    );
-    if (!approved) {
-      setControlState(ctx, waitingUserState("等待用户审查步骤产物并明确决定"));
-      ctx.ui.notify("已保留当前步骤，未推进工作流。", "info");
-      return true;
-    }
-    if (checkpoint && stepId === "wireframe-review") {
-      const feature = inspected.snapshot.current_feature;
-      if (typeof feature !== "string") return false;
-      const approval = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/wireframe_commit.rb",
-        wireframeApprovalArgs(feature, revision));
-      if (!controlPlaneSucceeded(approval)) {
-        setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "原型确认写入失败" });
-        ctx.ui.notify(`原型确认未写入：${approval.stderr || approval.stdout}`, "error");
-        return true;
-      }
-    }
     const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
       "--write", "--json", "--expected-revision", String(revision),
       ...(checkpoint ? ["--confirm-checkpoint", "--runtime-confirmed"] : ["--complete-step", stepId]),
-      ...(cp3Prerequisites.length > 0 ? ["--confirm-test-prerequisites"] : []),
     ]);
     if (!result.ok || !controlPlaneSucceeded(result)) {
       setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "推进校验失败" });
@@ -3093,15 +3029,27 @@ export default function devflowCore(pi: ExtensionAPI) {
       ctx.ui.notify("当前步骤正在执行，等这一轮结束后再说「下一步」。", "info");
       return;
     }
+    const dynamic = parseJsonResult(await runDynamicPlan(ctx.cwd, { action: "inspect" }));
+    if (dynamic?.mode === "dynamic") {
+      await startDynamicTurn(ctx, dynamic);
+      return;
+    }
     if (mode === "next") {
       const report = await runDoctor(ctx);
       if (!report.ok) {
-        ctx.ui.notify(`运行环境检查没有通过，暂时不能推进：\n${formatDoctorReport(report).slice(0, 6000)}`, "error");
-        return;
+        ctx.ui.notify(`${"软门禁提示"}：\n${formatDoctorReport(report).slice(0, 6000)}`, "info");
+
       }
     }
+    // In advisory mode "next" is the user's request to continue, including
+    // when the current output is missing or a checker failed.
+    if (mode === "next") {
+      const current = await diagnoseCurrentWorkflow(ctx.cwd, { skipWorkflowUpgrade: true });
+      if (current.snapshot && !current.diagnosis.diagnoses.some(item => item.code === "ROLLOVER_PENDING")
+          && await confirmAndAdvanceWorkflowStep(ctx)) return;
+    }
     // Declining the template upgrade must not strand the step behind it.
-    let skipWorkflowUpgrade = false;
+    let skipWorkflowUpgrade = true;
     for (let attempt = 0; attempt < 4; attempt += 1) {
       const current = await diagnoseCurrentWorkflow(ctx.cwd, { skipWorkflowUpgrade });
       const { diagnosis, snapshot } = current;
@@ -3536,11 +3484,11 @@ export default function devflowCore(pi: ExtensionAPI) {
       parallelDispatchFailureThisTurn = result.stderr || result.stdout || `parallel ${action} failed`;
       return;
     }
-    if (action !== "complete") return;
+
     const refreshed = parseJsonResult(await runRuby(projectRoot, "workflow-orchestrator/scripts/parallel_run.rb", ["--action", "inspect", "--feature", feature, "--json"]));
     const current = refreshed?.run as Record<string, unknown> | undefined;
     const branches = Array.isArray(current?.branches) ? current.branches as Array<Record<string, unknown>> : [];
-    if (branches.length > 0 && branches.every(branch => branch.status === "succeeded")) {
+    if (branches.length > 0 && branches.every(branch => branch.status === "succeeded" || (["failed", "aborted"].includes(String(branch.status))))) {
       const after = await inspectWorkflow(projectRoot);
       const joinRevision = Number(after.snapshot?.revision);
       if (Number.isInteger(joinRevision)) {
@@ -3702,8 +3650,8 @@ export default function devflowCore(pi: ExtensionAPI) {
     if (cliSessionResumeRequested && controlState.phase === "idle" && !pendingRollover) {
       const report = await runDoctor(ctx);
       if (!report.ok) {
-        ctx.ui.notify(formatDoctorReport(report).slice(0, 10000), "error");
-        return;
+        ctx.ui.notify(formatDoctorReport(report).slice(0, 10000), "info");
+
       }
       const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
       if (!inspected.result.ok || !inspected.snapshot) {
@@ -3790,6 +3738,25 @@ export default function devflowCore(pi: ExtensionAPI) {
 
   pi.on("agent_end", async (event, ctx) => {
     if (!activeWorkflowTurn || event.willContinue) return;
+    if (dynamicTurnRevision !== undefined) {
+      const before = dynamicTurnRevision;
+      dynamicTurnRevision = undefined;
+      activeWorkflowTurn = false;
+      const snapshot = parseJsonResult(await runDynamicPlan(ctx.cwd, { action: "inspect" }));
+      if (snapshot?.mode === "dynamic") {
+        ctx.ui.notify(renderDynamicWorkflow(snapshot), "info");
+        if (["run_task", "plan_work", "reconcile_plan"].includes(String(snapshot.action)) && Number(snapshot.revision) > before && snapshot.progress_key !== dynamicTurnProgress) {
+          dynamicTurnRevision = Number(snapshot.revision);
+          dynamicTurnProgress = String(snapshot.progress_key);
+          activeWorkflowTurn = true;
+          setControlState(ctx, executingState("继续执行中文工作流"));
+          pi.sendMessage({ customType: "devflow-dynamic-continue", content: dynamicWorkflowDirective(snapshot), display: false }, { triggerTurn: true, deliverAs: "nextTurn" });
+        } else {
+          setControlState(ctx, snapshot.delivery === "ready" ? initialControlState() : waitingUserState("保留当前结果；等待决定、外部条件或执行恢复"));
+        }
+        return;
+      }
+    }
     const assistant = [...event.messages].reverse().find(message => (
       message && typeof message === "object" && (message as { role?: unknown }).role === "assistant"
     ));
@@ -3806,7 +3773,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         parallelTaskContexts.clear();
         setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "并行子 Agent 未启动" });
         ctx.ui.notify(
-          `并行窗口未启动任何子 Agent，已停止等待不存在的生命周期事件；STATE 未推进。${parallelDispatchFailureThisTurn ? `\n原因：${parallelDispatchFailureThisTurn}` : ""}\n请检查打包 Agent 注册；若当前环境不支持并行，调度器必须按 serial_fallback_order 串行执行。`,
+          `并行窗口未启动任何子 Agent，已停止等待不存在的生命周期事件；STATE 未推进。${parallelDispatchFailureThisTurn ? `\n原因：${parallelDispatchFailureThisTurn}` : ""}\n请先检查本回合的状态、合同与分支派发阻塞证据；未派发不代表 Agent 未安装。仅确认环境不支持并行时才按 serial_fallback_order 串行执行。`,
           "error",
         );
         return;
@@ -3823,6 +3790,10 @@ export default function devflowCore(pi: ExtensionAPI) {
       // UI confirmation may legitimately wait for the user longer than the
       // host's event-handler deadline. Do not await it from agent_end or the
       // host reports a timeout and the approval result is lost.
+      {
+        setControlState(ctx, waitingUserState("当前步骤结束；说「下一步」即可继续，检查缺项仅作提示"));
+        return;
+      }
       void confirmAndAdvanceWorkflowStep(ctx).catch(error => {
         setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "推进确认处理失败" });
         ctx.ui.notify(`推进确认处理失败：${String(error)}`, "error");
@@ -3832,6 +3803,17 @@ export default function devflowCore(pi: ExtensionAPI) {
 
   pi.on("input", async (event, ctx) => {
     if (event.source !== "interactive") return;
+    if (event.text.trim() && !event.text.trim().startsWith("/") && !classifyNextStepPhrase(event.text)) {
+      const dynamic = parseJsonResult(await runDynamicPlan(ctx.cwd, { action: "inspect" }));
+      if (dynamic?.mode === "dynamic") {
+        dynamicTurnRevision = Number(dynamic.revision);
+        dynamicTurnProgress = String(dynamic.progress_key);
+        activeWorkflowTurn = true;
+        activeContract = undefined;
+        setControlState(ctx, executingState("处理需求调整"));
+        return { text: `${dynamicWorkflowDirective(dynamic)}\n用户补充：${event.text}`, handled: false };
+      }
+    }
     const controlAction = classifyNaturalControlAction(event.text);
     const stepNote = event.text.trim();
     if (controlState.intent === "workflow-execute" && !controlAction && stepNote && !stepNote.startsWith("/") && !classifyNextStepPhrase(stepNote)) {
@@ -3940,15 +3922,7 @@ export default function devflowCore(pi: ExtensionAPI) {
           ctx.ui.notify("当前状态缺少可确认的 revision 或步骤，拒绝推进。", "error");
           return { handled: true };
         }
-        if (checkpoint && stepId === "wireframe-review" && typeof inspected.snapshot.current_feature === "string") {
-          const approval = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/wireframe_commit.rb",
-            wireframeApprovalArgs(inspected.snapshot.current_feature, revision));
-          if (!controlPlaneSucceeded(approval)) {
-            setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "原型确认写入失败" });
-            ctx.ui.notify(`原型确认未写入：${approval.stderr || approval.stdout}`, "error");
-            return { handled: true };
-          }
-        }
+
         const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
           "--write",
           "--json",
@@ -4033,6 +4007,19 @@ export default function devflowCore(pi: ExtensionAPI) {
   });
 
   pi.on("tool_call", async (event, ctx) => {
+    if (dynamicTurnRevision !== undefined) {
+      const name = String(event.toolName).toLowerCase();
+      if (isDirectControlMutation(name, event.input, ctx.cwd) || isShellControlMutation(name, event.input) || name === "devflow_transition") {
+        return { block: true, reason: "动态计划由 Core 独占写入；请使用 devflow_plan，不能手工写入通过状态。" };
+      }
+      if (name === "task" && requestedTaskAgents(event.input).names.includes("devflow-code-reviewer")) {
+        const snapshot = parseJsonResult(await runDynamicPlan(ctx.cwd, { action: "inspect" }));
+        const task = snapshot?.current_step as Record<string, unknown> | undefined;
+        if (task?.kind === "review" && task.status === "running") dynamicReviewBindings.set(event.toolCallId, { taskId: String(task.id), attempt: String(task.attempt), revision: Number(snapshot?.revision) });
+      }
+      return;
+    }
+    const decision = await (async () => {
     const toolName = String(event.toolName).toLowerCase();
     const toolInput = event.input && typeof event.input === "object" ? event.input as Record<string, unknown> : undefined;
     const toolCallId = String(event.toolCallId ?? "");
@@ -4048,11 +4035,6 @@ export default function devflowCore(pi: ExtensionAPI) {
       const feature = typeof toolInput?.feature === "string" ? toolInput.feature.trim() : "";
       const phase = typeof toolInput?.phase === "string" && toolInput.phase.trim() ? toolInput.phase.trim() : "默认需求阶段";
       if (!feature) return { block: true, reason: "bootstrap requires a feature name" };
-      const confirmed = await ctx.ui.confirm(
-        "确认启动新的 Devflow Feature",
-        `Feature：${feature}\n阶段：${phase}\n\n确认后由 Core 原子初始化并切换当前 Feature；不会由 AI 直接修改 STATE.md。若当前仍有未完成 Feature，Core 会拒绝切换并保持原状态。继续吗？`,
-      );
-      if (!confirmed) return { block: true, reason: "User declined runtime bootstrap authorization." };
       if (!toolCallId) return { block: true, reason: "bootstrap runtime authorization is missing a tool-call binding" };
       runtimeBootstrapAuthorizations.add(toolCallId);
       bootstrapAuthorized = true;
@@ -4061,14 +4043,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       const branchContext = parallelBranchContext(event.input);
       if (branchContext) parallelTaskContexts.set(event.toolCallId, branchContext);
     }
-    if (coreHardGatesEnabled(activeContract) && controlState.phase === "executing" && !toolName.startsWith("devflow_") && !internalControlResource) {
-      if (!activeContract.allowedTools.includes(toolName)) {
-        return { block: true, reason: `Active contract ${activeContract.contractId} does not allow tool: ${toolName}` };
-      }
-      if (!(await contractIsFresh(ctx.cwd, activeContract))) {
-        return { block: true, reason: `Active contract ${activeContract.contractId} is stale against STATE or graph revision; synthesize a new contract before continuing.` };
-      }
-    }
+
     if (toolName === "task") {
       const requested = requestedTaskAgents(event.input);
       if (requested.missing) {
@@ -4094,43 +4069,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       if (controlState.phase === "planning" && !allowedInDraft) {
         return { block: true, reason: planningToolBlockReason(toolName) };
       }
-      if (
-        coreHardGatesEnabled(activeContract) &&
-        activeContract &&
-        controlState.phase === "executing" &&
-        !requested.names.every(agent => activeContract?.allowedAgents.includes(agent))
-      ) {
-          return { block: true, reason: `Active contract ${activeContract.contractId} only allows agents: ${activeContract.allowedAgents.join(", ")}` };
-      }
-      if (coreHardGatesEnabled(activeContract) && activeContract && controlState.phase === "executing" && contractAgentCalls + requested.names.length > activeContract.toolBudget) {
-        return { block: true, reason: `Active contract ${activeContract.contractId} exhausted its fixed agent budget (${activeContract.toolBudget}).` };
-      }
-      if (coreHardGatesEnabled(activeContract) && activeContract && controlState.phase === "executing" && activeContract.step === "code-review" && requested.names.length !== 1) {
-        return { block: true, reason: "Code review requires exactly one independent reviewer task." };
-      }
-      if (coreHardGatesEnabled(activeContract) && activeContract && controlState.phase === "executing" && activeContract.step === "code-review") {
-        const preflight = await runProcess([
-          "python3", path.join(resolveKitRoot(ctx.cwd), "workflow-orchestrator/scripts/review_preflight.py"),
-          "--root", ctx.cwd,
-          "--feature", activeContract.feature,
-          "--step", activeContract.step,
-          "--contract", `.devflow/planning/contracts/${activeContract.feature}/${activeContract.contractId}.json`,
-          "--obligations", "[]",
-          "--review-agent", "devflow-code-reviewer",
-          "--stage", "entry",
-        ], ctx.cwd);
-        let result: Record<string, unknown> | null = null;
-        try {
-          result = JSON.parse(preflight.stdout) as Record<string, unknown>;
-        } catch {
-          // An unparseable Core preflight result cannot authorize a reviewer task.
-        }
-        if (!preflight.ok || result?.status !== "ready") {
-          return { block: true, reason: `Code review task preflight did not pass: ${preflight.stdout || preflight.stderr || "unavailable"}` };
-        }
-        if (!toolCallId) return { block: true, reason: "Code review task needs a runtime tool-call identity." };
-        pendingReviewTasks.set(toolCallId, { feature: activeContract.feature, contractId: activeContract.contractId });
-      }
+
       if (activeContract && controlState.phase === "executing") contractAgentCalls += requested.names.length;
     } else if (
       controlState.phase === "planning" &&
@@ -4160,41 +4099,7 @@ export default function devflowCore(pi: ExtensionAPI) {
           "Devflow 状态迁移只能由运行时在用户明确批准已展示的步骤或 checkpoint 后执行；LLM 不得自行推进。",
       };
     }
-    if (isUserConfirmedStepTransition && activeContract && coreHardGatesEnabled(activeContract)) {
-      const evidence = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/machine_evidence.rb", [
-        "--feature", activeContract.feature, "--step", activeContract.step, "--write", "--json",
-      ]);
-      const evidencePayload = parseJsonResult(evidence);
-      if (!evidence.ok || !evidencePayload || evidencePayload.complete !== true) {
-        return {
-          block: true,
-          reason: `Devflow machine evidence is incomplete; collect independent runtime evidence before completing ${activeContract.step}.`,
-        };
-      }
-    }
-    if (coreHardGatesEnabled(activeContract) && activeWorkflowTurn && !parallelRunActive && stepScopedMutationOwner(toolName, event.input) !== undefined) {
-      const inspected = await inspectWorkflow(ctx.cwd);
-      if (!inspected.result.ok || !inspected.snapshot) {
-        return {
-          block: true,
-          reason: `Active Devflow workflow mutation blocked because authoritative state could not be inspected: ${inspected.result.stderr || inspected.result.stdout}`,
-        };
-      }
-      const fresh = activeContract ? await contractIsFresh(ctx.cwd, activeContract) : false;
-      const reason = stepScopedMutationBlockReason(toolName, event.input, ctx.cwd, inspected.snapshot, activeContract, fresh);
-      if (reason) return { block: true, reason };
-    }
-    if (
-      coreHardGatesEnabled(activeContract) &&
-      !toolName.startsWith("devflow_") &&
-      ["write", "edit", "apply_patch", "notebook_edit", "bash", "shell", "exec_command"].includes(toolName) &&
-      inputPaths(event.input, ctx.cwd).some(isCoreOwnedGovernancePath)
-    ) {
-      return {
-        block: true,
-        reason: "规范需求图谱、派生视图、机器 Evidence 与合同审计只能由 Core writer 写入；Skill 只能提交候选 delta 或 agent_claim。",
-      };
-    }
+
     // Feature artifacts written while no step is running are never adopted by
     // the workflow (zhaoshang, 2026-10-22). Refuse early in the interactive
     // main session; subagents (no UI), review-feedback edits and controlled
@@ -4229,31 +4134,8 @@ export default function devflowCore(pi: ExtensionAPI) {
       }
     }
     if (toolName.startsWith("devflow_")) return;
-    if (
-      coreHardGatesEnabled(activeContract) &&
-      activeContract &&
-      controlState.phase === "executing" &&
-      !internalControlResource &&
-      ["write", "edit", "apply_patch", "notebook_edit"].includes(toolName)
-    ) {
-      const paths = inputPaths(event.input, ctx.cwd);
-      if (paths.length === 0 || paths.some(filePath => !contractAllowsPath(activeContract!, filePath))) {
-        return {
-          block: true,
-          reason: `Active contract ${activeContract.contractId} only allows edits under: ${activeContract.allowedPaths.join(", ")}`,
-        };
-      }
-    }
-    if (coreHardGatesEnabled(activeContract) && activeContract && controlState.phase === "executing" && ["bash", "shell", "exec_command"].includes(toolName)) {
-      const command = String((event.input as Record<string, unknown> | undefined)?.command ?? (event.input as Record<string, unknown> | undefined)?.cmd ?? "");
-      const shell = shellMutationPaths(command, ctx.cwd);
-      if (shell.mutating && (shell.paths.length === 0 || shell.paths.some(filePath => !contractAllowsPath(activeContract!, filePath)))) {
-        return {
-          block: true,
-          reason: `Active contract ${activeContract.contractId} 不允许通过 Bash/脚本修改合同外路径；请使用合同允许路径，或先更新合同。`,
-        };
-      }
-    }
+
+
     if (isDirectControlMutation(toolName, event.input, ctx.cwd) || isShellControlMutation(toolName, event.input)) {
       return {
         block: true,
@@ -4277,8 +4159,9 @@ export default function devflowCore(pi: ExtensionAPI) {
     if (gate.stdout) {
       try {
         const payload = JSON.parse(gate.stdout) as {
-          hookSpecificOutput?: { permissionDecision?: string; permissionDecisionReason?: string };
+          hookSpecificOutput?: { permissionDecision?: string; permissionDecisionReason?: string; additionalContext?: string };
         };
+        if (payload.hookSpecificOutput?.additionalContext) ctx.ui.notify(payload.hookSpecificOutput.additionalContext, "info");
         if (payload.hookSpecificOutput?.permissionDecision === "deny") {
           return {
             block: true,
@@ -4292,9 +4175,27 @@ export default function devflowCore(pi: ExtensionAPI) {
         };
       }
     }
+    })();
+    if (decision?.block && !String(decision.reason).startsWith("bootstrap ") && decision.reason !== "User declined runtime bootstrap authorization.") {
+      ctx.ui.notify(`软门禁提示：${decision.reason}`, "info");
+      return;
+    }
+    return decision;
   });
 
   pi.on("tool_result", async (event, ctx) => {
+    const dynamicBinding = dynamicReviewBindings.get(event.toolCallId);
+    if (event.toolName === "task" && dynamicBinding) {
+      dynamicReviewBindings.delete(event.toolCallId);
+      const results = (event.details as { results?: Array<Record<string, unknown>> } | undefined)?.results;
+      const child = results?.length === 1 ? results[0] : undefined;
+      if (!event.isError && child?.agent === "devflow-code-reviewer" && child.exitCode === 0 && child.truncated === false && typeof child.output === "string") {
+        try {
+          const report = JSON.parse(child.output);
+          if (typeof report.summary === "string" && Array.isArray(report.findings)) dynamicReviewResults.set(event.toolCallId, { ...dynamicBinding, report });
+        } catch { /* Invalid reviewer output never becomes a pass. */ }
+      }
+    }
     if (event.toolName === "task") {
       const binding = pendingReviewTasks.get(event.toolCallId);
       if (binding) {
@@ -4485,20 +4386,13 @@ export default function devflowCore(pi: ExtensionAPI) {
         if (params.expectedRevision === undefined || !params.delta) {
           return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "propose requires expectedRevision and delta" });
         }
-        if (coreHardGatesEnabled(activeContract) && params.delta.kind === "test_case" && activeContract?.step !== "acceptance-test-design") {
-          return renderResult({
-            ok: false,
-            exitCode: 1,
-            stdout: "",
-            stderr: "TC candidates are accepted only during the active acceptance-test-design contract.",
-          });
-        }
+
         args.push("--expected-revision", String(params.expectedRevision), "--delta-json", JSON.stringify(params.delta));
         // `write` is an explicit dry-run switch. Omit it only when the caller
         // explicitly asks for a preview; the normal approved proposal remains
         // a Core-owned write.
         if (params.write !== false) args.push("--write");
-        if (coreHardGatesEnabled(activeContract) && activeContract?.allowedGraphDelta?.length) args.push("--allowed-kinds", activeContract.allowedGraphDelta.join(","));
+
       }
       if (params.action === "confirm") {
         if (params.expectedRevision === undefined || !params.nodeId || !params.evidence) {
@@ -4602,9 +4496,7 @@ export default function devflowCore(pi: ExtensionAPI) {
     }),
     approval: args => args.action === "validate" ? "read" : "write",
     async execute(_id, params, _signal, _onUpdate, ctx) {
-      if (coreHardGatesEnabled(activeContract) && params.action !== "validate" && activeContract?.step !== "acceptance-test-design") {
-        return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "API test matrix compilation/import is allowed only during the active acceptance-test-design contract." });
-      }
+
       if (params.action === "validate") {
         const process = await runPython(ctx.cwd, "workflow-orchestrator/scripts/api_test_matrix.py", ["validate", "--feature", params.feature, "--json"]);
         const payload = parseJsonResult(process);
@@ -4767,7 +4659,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       "Actions: validate (bindings and suite), validate_human (manual TCs), run (executes every automated TC and writes the canonical acceptance-results.json; Core is the only writer), validate_results (re-checks recorded results against current approvals and hashes), gc_runs (prunes .devflow/runs/<feature> execution directories per retention rules; dry-run by default, pass write=true to delete; optional retentionDays / unreferencedTtlDays).",
       "Failure analysis reads only the Core-produced result.json summary; trace files and screenshots are not readable by Agent tools and are for the user to inspect locally with Playwright in a terminal.",
       "devflow_playwright bindings require CURRENT human approvals created with devflow_approval and confirmed by the user in /devflow control: an execution_plan approval per TC (pins the DSL, TC and suite) and an environment_profile approval for the target profile; manual or downgraded TCs need a human_result / mode_override approval. You cannot confirm approvals yourself.",
-      "Hard gate: a missing, superseded or expired approval, or a DSL/profile/suite/evidence hash that changed after the approval or the run, makes run and validate_results return ok=false and blocks run-acceptance-tests from completing; there is no soft override and results must never be written by hand.",
+      "A missing approval or changed DSL/profile/suite/evidence hash is reported as ok=false by run and validate_results. In soft gate mode these findings do not block workflow advancement. Failed or unexecuted tests must never be reported as passed; results must never be written by hand.",
     ].join(" "),
     parameters: z.object({
       action: z.enum(["validate", "validate_human", "run", "validate_results", "gc_runs"]),
@@ -5214,6 +5106,59 @@ export default function devflowCore(pi: ExtensionAPI) {
     },
   });
 
+  pi.registerTool({
+    name: "devflow_plan",
+    label: "Devflow 中文工作流",
+    description: "Inspect or execute the Core-owned dynamic plan. Never accepts caller-written pass/approval results. Use revise for task proposals, claim before work, report for activity results, verify for actual executable checks, review_result for a captured independent review, and decision only for genuine user choices. Task fields: id,title,kind(discover/implement/verify/review),requirements(R-ids),dependencies,inputs,outputs,checks([{argv:string[],timeout?:number}]),cancelled?,reason?.",
+    parameters: z.object({
+      action: z.enum(["inspect", "revise", "claim", "report", "verify", "review_result", "recover", "wait", "resume", "decision"]),
+      expected_revision: z.number().int().optional(),
+      task_id: z.string().optional(),
+      attempt: z.string().optional(),
+      tasks: z.array(z.object({
+        id: z.string(), title: z.string(), kind: z.enum(["discover", "implement", "repair", "verify", "review"]),
+        requirements: z.array(z.string()), dependencies: z.array(z.string()), inputs: z.array(z.string()), outputs: z.array(z.string()),
+        checks: z.array(z.object({ argv: z.array(z.string()).min(1), timeout: z.number().int().optional() })),
+        cancelled: z.boolean().optional(), reason: z.string().optional(),
+      })).optional(),
+      reason: z.string().optional(), summary: z.string().optional(), task_call_id: z.string().optional(),
+      question: z.string().optional(), options: z.array(z.string()).optional(),
+      task_ids: z.array(z.string()).optional(),
+      scope_decision_id: z.string().optional(), remove_requirements: z.array(z.string()).optional(), approval_option: z.string().optional(),
+    }),
+    approval: "write",
+    async execute(_id, rawParams, _signal, _onUpdate, ctx) {
+      const params = rawParams as { action: string; task_call_id?: string; task_id?: string; attempt?: string; expected_revision?: number; question?: string };
+      const request: Record<string, unknown> = { ...params };
+      if (params.action === "review_result") {
+        const captured = params.task_call_id ? dynamicReviewResults.get(params.task_call_id) : undefined;
+        if (!captured || captured.taskId !== params.task_id || captured.attempt !== params.attempt || captured.revision !== params.expected_revision) {
+          return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "No current independent reviewer result is bound to this task attempt. Dispatch the read-only reviewer first." });
+        }
+        request.runtime_review = true;
+        request.report = captured.report;
+      }
+      let result = await runDynamicPlan(ctx.cwd, request);
+      let snapshot = parseJsonResult(result);
+      if (snapshot?.ok === true && params.action === "review_result" && params.task_call_id) dynamicReviewResults.delete(params.task_call_id);
+      if (snapshot?.ok === true && params.action === "decision") {
+        const decisions = snapshot.decisions as Array<Record<string, unknown>>;
+        const pending = decisions.find(item => item.status === "pending" && item.question === params.question);
+        if (pending) {
+          const removals = pending.remove_requirements as string[] | undefined;
+          const question = String(pending.question) + (removals?.length ? `\n拟移除验收要求：${removals.join("、")}；仅选择「${pending.approval_option}」会授权移除。` : "");
+          const choice = await ctx.ui.select(question, pending.options as string[]);
+          if (choice) {
+            result = await runDynamicPlan(ctx.cwd, { action: "decide", expected_revision: snapshot.revision, decision_id: pending.id, choice, runtime_decision: true });
+            snapshot = parseJsonResult(result);
+          }
+        }
+      }
+      if (snapshot?.mode === "dynamic") ctx.ui.setWidget?.("devflow-plan", projectControlWidget(renderDynamicWorkflow(snapshot).split("\n")));
+      return renderResult(result);
+    },
+  });
+
   pi.registerTool({
     name: "devflow_bootstrap",
     label: "Devflow Bootstrap",
@@ -5221,11 +5166,24 @@ export default function devflowCore(pi: ExtensionAPI) {
     parameters: z.object({
       feature: z.string().min(1),
       phase: z.string().min(1).optional(),
-      flow: z.enum(["feature-development", "acceptance-remediation", "regression-acceptance"]).default("feature-development"),
+      flow: z.enum(["dynamic", "feature-development", "acceptance-remediation", "regression-acceptance"]).default("dynamic"),
       force: z.boolean().default(false),
     }),
     approval: "write",
-    async execute(_id, params, _signal, _onUpdate, ctx) {
+    async execute(_id, rawParams, _signal, _onUpdate, ctx) {
+      const params = rawParams as { flow: string; feature: string; phase?: string; force: boolean };
+      if (params.flow === "dynamic") {
+        const result = await runDynamicPlan(ctx.cwd, { action: "initialize", feature: params.feature, phase: params.phase });
+        const snapshot = parseJsonResult(result);
+        if (snapshot?.mode === "dynamic") {
+          dynamicTurnRevision = Number(snapshot.revision);
+          dynamicTurnProgress = String(snapshot.progress_key);
+          activeWorkflowTurn = true;
+          activeContract = undefined;
+          setControlState(ctx, executingState("梳理需求并生成中文步骤"));
+        }
+        return renderResult(result);
+      }
       // Consume the one-shot runtime authorization before running Core's
       // atomic bootstrap sequence. A retry must obtain a fresh user approval.
       runtimeBootstrapAuthorizations.delete(String(_id));
@@ -5320,9 +5278,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         if (!params.step) {
           return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "step is required" });
         }
-        if (params.confirm !== true) {
-          return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "complete-step requires explicit user confirmation (confirm=true)" });
-        }
+
         const snapshot = parseJsonResult(await runRuby(ctx.cwd, "workflow-orchestrator/scripts/inspect_state.rb", ["--json"]));
         const currentStep = snapshot?.current_step && typeof snapshot.current_step === "object"
           ? (snapshot.current_step as Record<string, unknown>).id
@@ -5341,9 +5297,7 @@ export default function devflowCore(pi: ExtensionAPI) {
           if (activeContract?.feature === feature && activeContract.step === params.step && activeContract.contractPath) evidenceArgs.push("--contract", activeContract.contractPath);
           const evidence = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/machine_evidence.rb", evidenceArgs);
           const evidencePayload = parseJsonResult(evidence);
-          if (!controlPlaneSucceeded(evidence) || evidencePayload?.complete !== true) {
-            return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "machine evidence collection failed or required outputs are incomplete" }, { action: params.action, evidence: evidence.stdout });
-          }
+
         }
         args.push("--complete-step", params.step);
       } else if (params.action === "confirm-checkpoint") {
@@ -5598,6 +5552,15 @@ export default function devflowCore(pi: ExtensionAPI) {
 
   const devflowCommand = async (args: string, ctx: DevflowCommandContext): Promise<void> => {
     const trimmed = args.trim();
+    if (["", "status", "control", "explain-state"].includes(trimmed)) {
+      const dynamic = parseJsonResult(await runDynamicPlan(ctx.cwd, { action: "inspect" }));
+      if (dynamic?.mode === "dynamic") {
+        const lines = renderDynamicWorkflow(dynamic, trimmed === "control").split("\n");
+        ctx.ui.notify(lines.join("\n"), "info");
+        ctx.ui.setWidget?.("devflow-plan", projectControlWidget(lines));
+        return;
+      }
+    }
     if (trimmed === "" || trimmed === "status") {
       await showWorkflowOverview(ctx);
       return;
@@ -5670,6 +5633,17 @@ export default function devflowCore(pi: ExtensionAPI) {
     if (trimmed === "abandon" || trimmed.startsWith("abandon ") || trimmed === "cancel" || trimmed.startsWith("cancel ")) {
       const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
       const snapshot = inspected.snapshot;
+      if (snapshot?.mode === "dynamic") {
+        const result = await runDynamicPlan(ctx.cwd, { action: "cancel", expected_revision: snapshot.revision, runtime_cancel: true, reason: trimmed.replace(/^\S+\s*/, "") || "用户主动终止当前需求" });
+        const cancelled = parseJsonResult(result);
+        if (cancelled?.ok) {
+          dynamicTurnRevision = undefined;
+          activeWorkflowTurn = false;
+          setControlState(ctx, initialControlState());
+          ctx.ui.notify("已取消需求，保留已有工作与失败证据。", "info");
+        } else ctx.ui.notify(String(cancelled?.reason ?? result.stderr), "error");
+        return;
+      }
       const revision = typeof snapshot?.revision === "number" ? snapshot.revision : undefined;
       const feature = typeof snapshot?.current_feature === "string" ? snapshot.current_feature : undefined;
       const status = typeof snapshot?.status === "string" ? snapshot.status : undefined;
@@ -5734,8 +5708,8 @@ export default function devflowCore(pi: ExtensionAPI) {
     if (trimmed === "resume") {
       const report = await runDoctor(ctx);
       if (!report.ok) {
-        ctx.ui.notify(formatDoctorReport(report).slice(0, 10000), "error");
-        return;
+        ctx.ui.notify(formatDoctorReport(report).slice(0, 10000), "info");
+
       }
       const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
       if (!inspected.result.ok || !inspected.snapshot) {
@@ -5773,100 +5747,19 @@ export default function devflowCore(pi: ExtensionAPI) {
     }
     if (trimmed.startsWith("start ")) {
       const [feature, requestedPhase] = trimmed.slice(6).split("|", 2).map(value => value.trim());
-      if (!feature) {
-        ctx.ui.notify("Usage: /devflow start <feature>|<phase>", "error");
-        return;
-      }
-      const phase = requestedPhase || defaultPhaseId(feature);
-      if (!validPhaseId(phase)) {
-        ctx.ui.notify("Phase ID 必须是 1-64 位字母、数字、下划线或连字符，且不得包含路径分隔符。", "error");
+      if (!feature || (requestedPhase && !validPhaseId(requestedPhase))) {
+        ctx.ui.notify("用法：/devflow start <需求名>|<可选阶段标识>", "error");
         return;
       }
       const report = await runDoctor(ctx);
-      if (!report.ok) {
-        ctx.ui.notify(formatDoctorReport(report).slice(0, 10000), "error");
-        return;
-      }
-      const existing = await inspectWorkflow(ctx.cwd);
-      const existingFeature = existing.snapshot?.current_feature;
-      const previousWorkflowComplete = ["workflow_complete", "workflow_cancelled"].includes(existing.snapshot?.action as string);
-      if (
-        !previousWorkflowComplete &&
-        typeof existingFeature === "string" &&
-        existingFeature !== feature
-      ) {
-        ctx.ui.notify(
-          `当前仍有未完成需求：${existingFeature}。请在对话中继续处理当前步骤，完成后再创建新需求：${feature}。`,
-          "error",
-        );
-        return;
-      }
-      // This dry-run happens before init_workflow.rb, so a rejected feature
-      // can never overwrite generated workflow files belonging to an active
-      // owner or a legacy phase directory that has no trustworthy owner.
-      const ownership = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/phase_ownership.rb", [
-        "claim",
-        "--feature",
-        feature,
-        "--phase",
-        phase,
-        "--flow",
-        "feature-development",
-        "--json",
-      ]);
-      if (!controlPlaneSucceeded(ownership)) {
-        ctx.ui.notify((ownership.stderr || ownership.stdout).slice(0, 6000), "error");
-        return;
-      }
-      const workflow = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/init_workflow.rb", [
-        "--write",
-        "--json",
-      ]);
-      if (!controlPlaneSucceeded(workflow)) {
-        ctx.ui.notify(workflow.stderr || workflow.stdout, "error");
+      if (!report.ok) ctx.ui.notify(formatDoctorReport(report).slice(0, 6000), "info");
+      const result = await runDynamicPlan(ctx.cwd, { action: "initialize", feature, phase: requestedPhase || undefined });
+      const snapshot = parseJsonResult(result);
+      if (!snapshot?.ok) {
+        ctx.ui.notify(String(snapshot?.reason ?? result.stderr), "error");
         return;
       }
-      const state = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/init_state.rb", [
-        "--feature",
-        feature,
-        "--phase",
-        phase,
-        "--flow",
-        "feature-development",
-        "--write",
-        "--json",
-        ...(previousWorkflowComplete ? ["--force"] : []),
-      ]);
-      if (!controlPlaneSucceeded(state)) {
-        ctx.ui.notify((state.stderr || state.stdout).slice(0, 6000), "error");
-        return;
-      }
-      const artifacts = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/sync_artifacts.rb", [
-        "--write",
-        "--json",
-      ]);
-      if (!controlPlaneSucceeded(artifacts)) {
-        ctx.ui.notify((artifacts.stderr || artifacts.stdout).slice(0, 6000), "error");
-        return;
-      }
-      const inspected = await inspectWorkflow(ctx.cwd);
-      if (!inspected.result.ok || !inspected.snapshot) {
-        ctx.ui.notify(
-          `Devflow initialized but inspector failed: ${inspected.result.stderr || inspected.result.stdout || "invalid JSON"}`,
-          "error",
-        );
-        return;
-      }
-      setControlState(ctx, planningState("requirement-draft"));
-      await pi.sendUserMessage(
-        [
-          "<devflow-requirement-draft-directive>",
-          `Devflow 已创建 Feature ${feature}。当前为安全的需求梳理阶段：允许澄清和只读证据收集，不得写入项目或迁移状态。`,
-          "请先基于功能名说明你需要的最少业务背景，并邀请用户直接补充目标、使用者、约束和验收结果。收到用户的下一段需求描述后，运行时会将其原文注入 requirement-triage 并启动该步骤。",
-          "不要让用户输入命令；也不要把普通需求文本当成批准或 checkpoint 确认。",
-          "</devflow-requirement-draft-directive>",
-        ].join("\n"),
-      );
+      await startDynamicTurn(ctx, snapshot);
       return;
     }
     ctx.ui.notify(