@guanlin4924/devflow-pi 0.1.105 → 0.1.106

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

@@ -233,12 +233,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 +257,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 +273,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",
@@ -1316,7 +1314,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 +1324,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 +1385,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 +1406,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 +1414,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 +1425,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),
@@ -2160,7 +2160,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 +2259,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 +2607,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 +2634,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");
@@ -2818,7 +2759,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 +2775,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) {
@@ -2905,60 +2857,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: "推进校验失败" });
@@ -3096,12 +3003,19 @@ export default function devflowCore(pi: ExtensionAPI) {
     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 +3450,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 +3616,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) {
@@ -3806,7 +3720,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 +3737,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");
@@ -3940,15 +3858,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 +3943,7 @@ export default function devflowCore(pi: ExtensionAPI) {
   });
 
   pi.on("tool_call", async (event, ctx) => {
+    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 +3959,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 +3967,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 +3993,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 +4023,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 +4058,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 +4083,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,6 +4099,12 @@ 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) => {
@@ -4485,20 +4298,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 +4408,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 +4571,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"]),
@@ -5320,9 +5124,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 +5143,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") {
@@ -5734,8 +5534,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) {
@@ -5784,8 +5584,8 @@ export default function devflowCore(pi: ExtensionAPI) {
       }
       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 existing = await inspectWorkflow(ctx.cwd);
       const existingFeature = existing.snapshot?.current_feature;