@runfusion/fusion 0.77.0-beta.12 → 0.77.0-beta.13

package/dist/child-process-worker.js

@@ -1592,6 +1592,199 @@ Be specific: cite the plan section or file path for every finding and explain th
   }
 });
 
+// ../core/src/workflows/workflow-merge-region.ts
+function isMergeRegionNode(node) {
+  return MERGE_REGION_ENTRY_NODE_KINDS.has(node.kind) || node.config?.seam === "merge";
+}
+function classifyWorkflowNodeMergeRegion(ir2, nodeId) {
+  if (ir2.version !== "v2" || !Array.isArray(ir2.nodes)) return "unknown";
+  const node = ir2.nodes.find((candidate) => candidate.id === nodeId);
+  if (!node) return "unknown";
+  return isMergeRegionNode(node) ? "merge-region" : "outside-merge-region";
+}
+var MERGE_REGION_ENTRY_NODE_KINDS;
+var init_workflow_merge_region = __esm({
+  "../core/src/workflows/workflow-merge-region.ts"() {
+    "use strict";
+    MERGE_REGION_ENTRY_NODE_KINDS = /* @__PURE__ */ new Set([
+      "merge-gate",
+      "merge-attempt",
+      "manual-merge-hold",
+      "retry-backoff",
+      "recovery-router",
+      "branch-group-member-integration",
+      "branch-group-promotion",
+      "pr-create",
+      "pr-respond",
+      "pr-merge"
+    ]);
+  }
+});
+
+// ../core/src/workflows/workflow-optional-steps.ts
+function isWorkflowOptionalGroupEnabled(enabledWorkflowSteps, groupId, defaultOn = false) {
+  return Array.isArray(enabledWorkflowSteps) ? enabledWorkflowSteps.includes(groupId) : defaultOn;
+}
+function isOptionalGroupNode(node) {
+  return node.kind === "optional-group";
+}
+function computeNodeExecutionRanks(ir2) {
+  const ranks = /* @__PURE__ */ new Map();
+  if (ir2.version !== "v2" || !Array.isArray(ir2.nodes) || !Array.isArray(ir2.edges)) {
+    return ranks;
+  }
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const edge of ir2.edges) {
+    if (!outgoing.has(edge.from)) outgoing.set(edge.from, []);
+    outgoing.get(edge.from)?.push(edge.to);
+  }
+  const queue = [];
+  for (const node of ir2.nodes) {
+    if (node.kind === "start" || node.id === "start") {
+      queue.push({ id: node.id, rank: 0 });
+    }
+  }
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (!next) continue;
+    const current = ranks.get(next.id);
+    if (current !== void 0 && current <= next.rank) continue;
+    ranks.set(next.id, next.rank);
+    for (const target of outgoing.get(next.id) ?? []) {
+      queue.push({ id: target, rank: next.rank + 1 });
+    }
+  }
+  return ranks;
+}
+function resolveWorkflowOptionalSteps(ir2, _pluginTemplates = []) {
+  if (ir2.version !== "v2" || !Array.isArray(ir2.nodes)) return [];
+  const ranks = computeNodeExecutionRanks(ir2);
+  const resolved = [];
+  for (const [nodeIndex, node] of ir2.nodes.entries()) {
+    if (!isOptionalGroupNode(node)) continue;
+    const config3 = node.config ?? {};
+    resolved.push({
+      // Keyed by the group node id (documented above); field name preserved.
+      templateId: node.id,
+      name: typeof config3.name === "string" && config3.name.trim() ? config3.name : node.id,
+      description: "",
+      /*
+      FNXC:WorkflowOptionalSteps 2026-06-29-12:47:
+      Post-merge verification is now a graph-native optional group. Task creation and detail surfaces need the resolver to preserve `config.phase` so post-merge toggles do not look like pre-merge gates.
+      */
+      phase: config3.phase === "post-merge" ? "post-merge" : "pre-merge",
+      defaultOn: config3.defaultOn === true,
+      reportingOnly: config3.reportingOnly === true,
+      /*
+      FNXC:WorkflowDefinitionSteps 2026-06-29-00:41:
+      Definition/task creation surfaces must order optional groups by graph execution position, not raw node-array order. Derived built-ins can insert Plan Review between planning and parse while appending its node object, and operators still need the step list to show Plan Review before execution.
+      */
+      rank: ranks.get(node.id) ?? Number.MAX_SAFE_INTEGER,
+      nodeIndex
+    });
+  }
+  return resolved.sort((a, b3) => a.rank - b3.rank || a.nodeIndex - b3.nodeIndex).map(({ rank: _rank, nodeIndex: _nodeIndex, ...step }) => step);
+}
+function resolveDefaultOnOptionalGroupIds(ir2) {
+  return resolveWorkflowOptionalSteps(ir2).filter((step) => step.defaultOn).map((step) => step.templateId);
+}
+function resolveAllOptionalGroupIds(ir2) {
+  return resolveWorkflowOptionalSteps(ir2).map((step) => step.templateId);
+}
+function isReportingOnlyOptionalGroup(ir2, nodeId) {
+  if (!nodeId) return false;
+  return resolveWorkflowOptionalSteps(ir2).some((step) => step.templateId === nodeId && step.reportingOnly);
+}
+var init_workflow_optional_steps = __esm({
+  "../core/src/workflows/workflow-optional-steps.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/workflows/workflow-fast-lane.ts
+function isFastExecutionMode(task) {
+  return task.executionMode === "fast";
+}
+function configString(node, key) {
+  const value = node.config?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function isTaskStepsForeach(node) {
+  return node.kind === "foreach" && node.config?.source === "task-steps";
+}
+function isFastLaneSkippableCustomNode(node, opts = {}) {
+  if (node.config?.summaryTarget === "task" || node.id === "completion-summary") return false;
+  if (opts.optionalGroupId) return false;
+  if (node.config?.seam) return false;
+  return node.kind === "prompt" || node.kind === "script" || node.kind === "gate";
+}
+function isFastLaneBypassedTemplateNode(node) {
+  return node.kind === "step-review";
+}
+function inactiveRoute() {
+  return {
+    active: false,
+    bypassedNodeIds: /* @__PURE__ */ new Set(),
+    bypassedPreMergeGroups: [],
+    parseStepsNodeIds: /* @__PURE__ */ new Set()
+  };
+}
+function resolveFastLaneRoute(ir2, task) {
+  if (!isFastExecutionMode(task)) return inactiveRoute();
+  const foreachNode = ir2.nodes.find(isTaskStepsForeach);
+  const executeNode = ir2.nodes.find((node) => configString(node, "seam") === "execute");
+  const implementationNode = foreachNode ?? executeNode;
+  if (!implementationNode) {
+    return { ...inactiveRoute(), unsupportedReason: "no-implementation-node" };
+  }
+  const implementationKind = foreachNode ? "foreach-steps" : "execute-seam";
+  const bypassedPreMergeGroups = resolveWorkflowOptionalSteps(ir2).filter((step) => step.phase === "pre-merge").map((step) => ({ nodeId: step.templateId, name: step.name }));
+  const bypassedGroupIds = new Set(bypassedPreMergeGroups.map((group) => group.nodeId));
+  const bypassedNodeIds = /* @__PURE__ */ new Set();
+  for (const node of ir2.nodes) {
+    if (isMergeRegionNode(node) || node.id === "completion-summary" || node.config?.summaryTarget === "task") continue;
+    if (configString(node, "seam") === "planning") {
+      bypassedNodeIds.add(node.id);
+      continue;
+    }
+    if (bypassedGroupIds.has(node.id)) {
+      bypassedNodeIds.add(node.id);
+      continue;
+    }
+    const workflowAction = configString(node, "workflowAction");
+    const groupId = configString(node, "forWorkflowStepId");
+    if (workflowAction === "plan-replan" || workflowAction === "plan-review-no-op" || workflowAction === "pre-merge-remediation" || workflowAction === "review-remediation-steps" || groupId !== void 0 && bypassedGroupIds.has(groupId)) {
+      bypassedNodeIds.add(node.id);
+    }
+  }
+  const parseStepsNodeIds = new Set(ir2.nodes.filter((node) => node.kind === "parse-steps").map((node) => node.id));
+  for (const parseNodeId of parseStepsNodeIds) {
+    if (bypassedNodeIds.has(parseNodeId)) {
+      throw new Error(`Fast lane cannot bypass parse-steps node '${parseNodeId}'`);
+    }
+  }
+  return {
+    active: true,
+    bypassedNodeIds,
+    bypassedPreMergeGroups,
+    parseStepsNodeIds,
+    implementationNodeId: implementationNode.id,
+    implementationKind
+  };
+}
+var FAST_LANE_STEP_NAME, FAST_LANE_SKIP_VALUE, FAST_MODE_BYPASS_ACTOR, FAST_LANE_STEP_REVIEW_ROUTE_VALUE;
+var init_workflow_fast_lane = __esm({
+  "../core/src/workflows/workflow-fast-lane.ts"() {
+    "use strict";
+    init_workflow_merge_region();
+    init_workflow_optional_steps();
+    FAST_LANE_STEP_NAME = "Fast implementation";
+    FAST_LANE_SKIP_VALUE = "fast-lane-skip";
+    FAST_MODE_BYPASS_ACTOR = "fast-mode";
+    FAST_LANE_STEP_REVIEW_ROUTE_VALUE = "approve";
+  }
+});
+
 // ../core/src/workflows/workflow-step-results.ts
 function isWorkflowStepNotRun(result) {
   return result.status === "skipped" && typeof result.notRunReason === "string" && WORKFLOW_STEP_NOT_RUN_REASONS.includes(result.notRunReason);
@@ -1892,6 +2085,31 @@ var init_workflow_step_results = __esm({
 });
 
 // ../core/src/merge/pre-merge-approval.ts
+function requiresContentReviewProof(workflowStepId, result) {
+  return workflowStepId === "code-review" || result.reviewKind === "code";
+}
+function isAuditedOperatorBypass(result) {
+  if (result.status !== "skipped") return false;
+  const actor = result.bypassedBy?.trim();
+  return Boolean(
+    actor && !AUTOMATED_BYPASS_ACTORS.has(actor) && result.bypassedAt?.trim() && result.bypassReason?.trim()
+  );
+}
+function resolveUnprovenReviewApproval(result, options) {
+  if ((result.phase ?? "pre-merge") !== "pre-merge" || !requiresContentReviewProof(result.workflowStepId, result) || options.workspace || result.status !== "passed" || result.verdict !== "APPROVE" && result.verdict !== "APPROVE_WITH_NOTES" || result.reviewInputFingerprint !== void 0 || result.bypassedBy !== void 0 || result.remediationArchivedAt != null) {
+    return void 0;
+  }
+  const { verdict: _verdict, ...withoutVerdict } = result;
+  return {
+    downgraded: {
+      ...withoutVerdict,
+      status: "failed",
+      output: UNPROVEN_REVIEW_APPROVAL_DIAGNOSTIC,
+      notes: UNPROVEN_REVIEW_APPROVAL_DIAGNOSTIC
+    },
+    reason: UNPROVEN_REVIEW_APPROVAL_DIAGNOSTIC
+  };
+}
 function evaluatePreMergeApprovals(task, options = {}) {
   const required2 = options.requiredPreMergeStepIds;
   if (!required2?.size) return [];
@@ -1902,13 +2120,16 @@ function evaluateStep(workflowStepId, results, task, descriptor) {
   const result = results.filter((candidate) => candidate.workflowStepId === workflowStepId).at(-1);
   if (!result && descriptor?.kind !== "workspace") return { workflowStepId, state: "missing" };
   if (result) {
-    const requiresExplicitVerdict = workflowStepId === "code-review" || result.reviewKind === "code";
+    const requiresExplicitVerdict = requiresContentReviewProof(workflowStepId, result);
     const approvedVerdict = result.verdict === "APPROVE" || result.verdict === "APPROVE_WITH_NOTES";
     const isPlanDomain = workflowStepId === PLAN_REVIEW_GROUP_ID || result.reviewKind === "plan";
     const notRunApproves = isWorkflowStepNotRun(result) && !requiresExplicitVerdict && !isPlanDomain;
     const approved = result.status === "passed" && (requiresExplicitVerdict ? approvedVerdict : result.verdict === void 0 || approvedVerdict) || result.status === "skipped" && !!result.bypassedBy || notRunApproves;
     if (!approved || !!result.remediationArchivedAt) return { workflowStepId, state: "not-approved" };
     if (result.reviewKind === "plan") return { workflowStepId, state: "approved" };
+    if (isAuditedOperatorBypass(result) && descriptor?.kind !== "workspace") {
+      return { workflowStepId, state: "approved" };
+    }
     const bindsContent = requiresExplicitVerdict || result.reviewInputFingerprint !== void 0;
     if (!bindsContent) return { workflowStepId, state: "approved" };
   }
@@ -1939,11 +2160,15 @@ function evaluateStep(workflowStepId, results, task, descriptor) {
   if (stale.length) return { workflowStepId, state: "stale-content", repositories: stale };
   return { workflowStepId, state: "approved" };
 }
+var AUTOMATED_BYPASS_ACTORS, UNPROVEN_REVIEW_APPROVAL_DIAGNOSTIC;
 var init_pre_merge_approval = __esm({
   "../core/src/merge/pre-merge-approval.ts"() {
     "use strict";
     init_builtin_plan_review_group();
+    init_workflow_fast_lane();
     init_workflow_step_results();
+    AUTOMATED_BYPASS_ACTORS = /* @__PURE__ */ new Set([FAST_MODE_BYPASS_ACTOR]);
+    UNPROVEN_REVIEW_APPROVAL_DIAGNOSTIC = "Content-binding review approval recorded without reviewInputFingerprint; approval invalidated so the gate can run again.";
   }
 });
 
@@ -11453,35 +11678,6 @@ var init_workflow_ir_types = __esm({
   }
 });
 
-// ../core/src/workflows/workflow-merge-region.ts
-function isMergeRegionNode(node) {
-  return MERGE_REGION_ENTRY_NODE_KINDS.has(node.kind) || node.config?.seam === "merge";
-}
-function classifyWorkflowNodeMergeRegion(ir2, nodeId) {
-  if (ir2.version !== "v2" || !Array.isArray(ir2.nodes)) return "unknown";
-  const node = ir2.nodes.find((candidate) => candidate.id === nodeId);
-  if (!node) return "unknown";
-  return isMergeRegionNode(node) ? "merge-region" : "outside-merge-region";
-}
-var MERGE_REGION_ENTRY_NODE_KINDS;
-var init_workflow_merge_region = __esm({
-  "../core/src/workflows/workflow-merge-region.ts"() {
-    "use strict";
-    MERGE_REGION_ENTRY_NODE_KINDS = /* @__PURE__ */ new Set([
-      "merge-gate",
-      "merge-attempt",
-      "manual-merge-hold",
-      "retry-backoff",
-      "recovery-router",
-      "branch-group-member-integration",
-      "branch-group-promotion",
-      "pr-create",
-      "pr-respond",
-      "pr-merge"
-    ]);
-  }
-});
-
 // ../core/src/workflows/workflow-extension-types.ts
 function workflowExtensionRegistryId(pluginId, extensionId) {
   return `plugin:${pluginId}:${extensionId}`;
@@ -12477,6 +12673,16 @@ function validateReviewerAgentOverrides(nodes2) {
     if (Array.isArray(templateNodes)) validateReviewerAgentOverrides(templateNodes);
   }
 }
+function validateReadonlyMcpServersConfig(nodes2) {
+  for (const node of nodes2) {
+    const value = node.config?.readonlyMcpServers;
+    if (value !== void 0 && (!Array.isArray(value) || value.some((name2) => typeof name2 !== "string" || !name2.trim()))) {
+      throw new WorkflowIrError(`Workflow node '${node.id}' readonlyMcpServers must be an array of non-empty strings when present`);
+    }
+    const templateNodes = node.config?.template?.nodes;
+    if (Array.isArray(templateNodes)) validateReadonlyMcpServersConfig(templateNodes);
+  }
+}
 function validateThinkingLevelConfig(nodes2) {
   for (const node of nodes2) {
     const value = node.config?.thinkingLevel;
@@ -13091,6 +13297,7 @@ function validateV2(ir2) {
   const topLevelIds = new Set(ir2.nodes.map((n) => n.id));
   validateStepExecutePlacement(ir2.nodes);
   validateThinkingLevelConfig(ir2.nodes);
+  validateReadonlyMcpServersConfig(ir2.nodes);
   validateCredentialInstanceIdConfig(ir2.nodes);
   validateReviewerAgentOverrides(ir2.nodes);
   for (const node of ir2.nodes) {
@@ -29161,169 +29368,6 @@ var init_explicit_duplicate_marker = __esm({
   }
 });
 
-// ../core/src/workflows/workflow-optional-steps.ts
-function isWorkflowOptionalGroupEnabled(enabledWorkflowSteps, groupId, defaultOn = false) {
-  return Array.isArray(enabledWorkflowSteps) ? enabledWorkflowSteps.includes(groupId) : defaultOn;
-}
-function isOptionalGroupNode(node) {
-  return node.kind === "optional-group";
-}
-function computeNodeExecutionRanks(ir2) {
-  const ranks = /* @__PURE__ */ new Map();
-  if (ir2.version !== "v2" || !Array.isArray(ir2.nodes) || !Array.isArray(ir2.edges)) {
-    return ranks;
-  }
-  const outgoing = /* @__PURE__ */ new Map();
-  for (const edge of ir2.edges) {
-    if (!outgoing.has(edge.from)) outgoing.set(edge.from, []);
-    outgoing.get(edge.from)?.push(edge.to);
-  }
-  const queue = [];
-  for (const node of ir2.nodes) {
-    if (node.kind === "start" || node.id === "start") {
-      queue.push({ id: node.id, rank: 0 });
-    }
-  }
-  while (queue.length > 0) {
-    const next = queue.shift();
-    if (!next) continue;
-    const current = ranks.get(next.id);
-    if (current !== void 0 && current <= next.rank) continue;
-    ranks.set(next.id, next.rank);
-    for (const target of outgoing.get(next.id) ?? []) {
-      queue.push({ id: target, rank: next.rank + 1 });
-    }
-  }
-  return ranks;
-}
-function resolveWorkflowOptionalSteps(ir2, _pluginTemplates = []) {
-  if (ir2.version !== "v2" || !Array.isArray(ir2.nodes)) return [];
-  const ranks = computeNodeExecutionRanks(ir2);
-  const resolved = [];
-  for (const [nodeIndex, node] of ir2.nodes.entries()) {
-    if (!isOptionalGroupNode(node)) continue;
-    const config3 = node.config ?? {};
-    resolved.push({
-      // Keyed by the group node id (documented above); field name preserved.
-      templateId: node.id,
-      name: typeof config3.name === "string" && config3.name.trim() ? config3.name : node.id,
-      description: "",
-      /*
-      FNXC:WorkflowOptionalSteps 2026-06-29-12:47:
-      Post-merge verification is now a graph-native optional group. Task creation and detail surfaces need the resolver to preserve `config.phase` so post-merge toggles do not look like pre-merge gates.
-      */
-      phase: config3.phase === "post-merge" ? "post-merge" : "pre-merge",
-      defaultOn: config3.defaultOn === true,
-      reportingOnly: config3.reportingOnly === true,
-      /*
-      FNXC:WorkflowDefinitionSteps 2026-06-29-00:41:
-      Definition/task creation surfaces must order optional groups by graph execution position, not raw node-array order. Derived built-ins can insert Plan Review between planning and parse while appending its node object, and operators still need the step list to show Plan Review before execution.
-      */
-      rank: ranks.get(node.id) ?? Number.MAX_SAFE_INTEGER,
-      nodeIndex
-    });
-  }
-  return resolved.sort((a, b3) => a.rank - b3.rank || a.nodeIndex - b3.nodeIndex).map(({ rank: _rank, nodeIndex: _nodeIndex, ...step }) => step);
-}
-function resolveDefaultOnOptionalGroupIds(ir2) {
-  return resolveWorkflowOptionalSteps(ir2).filter((step) => step.defaultOn).map((step) => step.templateId);
-}
-function resolveAllOptionalGroupIds(ir2) {
-  return resolveWorkflowOptionalSteps(ir2).map((step) => step.templateId);
-}
-function isReportingOnlyOptionalGroup(ir2, nodeId) {
-  if (!nodeId) return false;
-  return resolveWorkflowOptionalSteps(ir2).some((step) => step.templateId === nodeId && step.reportingOnly);
-}
-var init_workflow_optional_steps = __esm({
-  "../core/src/workflows/workflow-optional-steps.ts"() {
-    "use strict";
-  }
-});
-
-// ../core/src/workflows/workflow-fast-lane.ts
-function isFastExecutionMode(task) {
-  return task.executionMode === "fast";
-}
-function configString(node, key) {
-  const value = node.config?.[key];
-  return typeof value === "string" ? value : void 0;
-}
-function isTaskStepsForeach(node) {
-  return node.kind === "foreach" && node.config?.source === "task-steps";
-}
-function isFastLaneSkippableCustomNode(node, opts = {}) {
-  if (node.config?.summaryTarget === "task" || node.id === "completion-summary") return false;
-  if (opts.optionalGroupId) return false;
-  if (node.config?.seam) return false;
-  return node.kind === "prompt" || node.kind === "script" || node.kind === "gate";
-}
-function isFastLaneBypassedTemplateNode(node) {
-  return node.kind === "step-review";
-}
-function inactiveRoute() {
-  return {
-    active: false,
-    bypassedNodeIds: /* @__PURE__ */ new Set(),
-    bypassedPreMergeGroups: [],
-    parseStepsNodeIds: /* @__PURE__ */ new Set()
-  };
-}
-function resolveFastLaneRoute(ir2, task) {
-  if (!isFastExecutionMode(task)) return inactiveRoute();
-  const foreachNode = ir2.nodes.find(isTaskStepsForeach);
-  const executeNode = ir2.nodes.find((node) => configString(node, "seam") === "execute");
-  const implementationNode = foreachNode ?? executeNode;
-  if (!implementationNode) {
-    return { ...inactiveRoute(), unsupportedReason: "no-implementation-node" };
-  }
-  const implementationKind = foreachNode ? "foreach-steps" : "execute-seam";
-  const bypassedPreMergeGroups = resolveWorkflowOptionalSteps(ir2).filter((step) => step.phase === "pre-merge").map((step) => ({ nodeId: step.templateId, name: step.name }));
-  const bypassedGroupIds = new Set(bypassedPreMergeGroups.map((group) => group.nodeId));
-  const bypassedNodeIds = /* @__PURE__ */ new Set();
-  for (const node of ir2.nodes) {
-    if (isMergeRegionNode(node) || node.id === "completion-summary" || node.config?.summaryTarget === "task") continue;
-    if (configString(node, "seam") === "planning") {
-      bypassedNodeIds.add(node.id);
-      continue;
-    }
-    if (bypassedGroupIds.has(node.id)) {
-      bypassedNodeIds.add(node.id);
-      continue;
-    }
-    const workflowAction = configString(node, "workflowAction");
-    const groupId = configString(node, "forWorkflowStepId");
-    if (workflowAction === "plan-replan" || workflowAction === "plan-review-no-op" || workflowAction === "pre-merge-remediation" || workflowAction === "review-remediation-steps" || groupId !== void 0 && bypassedGroupIds.has(groupId)) {
-      bypassedNodeIds.add(node.id);
-    }
-  }
-  const parseStepsNodeIds = new Set(ir2.nodes.filter((node) => node.kind === "parse-steps").map((node) => node.id));
-  for (const parseNodeId of parseStepsNodeIds) {
-    if (bypassedNodeIds.has(parseNodeId)) {
-      throw new Error(`Fast lane cannot bypass parse-steps node '${parseNodeId}'`);
-    }
-  }
-  return {
-    active: true,
-    bypassedNodeIds,
-    bypassedPreMergeGroups,
-    parseStepsNodeIds,
-    implementationNodeId: implementationNode.id,
-    implementationKind
-  };
-}
-var FAST_LANE_STEP_NAME, FAST_LANE_SKIP_VALUE, FAST_LANE_STEP_REVIEW_ROUTE_VALUE;
-var init_workflow_fast_lane = __esm({
-  "../core/src/workflows/workflow-fast-lane.ts"() {
-    "use strict";
-    init_workflow_merge_region();
-    init_workflow_optional_steps();
-    FAST_LANE_STEP_NAME = "Fast implementation";
-    FAST_LANE_SKIP_VALUE = "fast-lane-skip";
-    FAST_LANE_STEP_REVIEW_ROUTE_VALUE = "approve";
-  }
-});
-
 // ../core/src/mesh/mesh-task-replication.ts
 function buildBootstrapPrompt(taskId, title, description) {
   const heading = title ? `${taskId}: ${title}` : taskId;
@@ -66524,10 +66568,10 @@ var init_migration = __esm({
           return basename6(projectPath);
         }
         try {
-          const { execFile: execFile42 } = await import("node:child_process");
-          const { promisify: promisify90 } = await import("node:util");
-          const execFileAsync36 = promisify90(execFile42);
-          const { stdout } = await execFileAsync36(
+          const { execFile: execFile43 } = await import("node:child_process");
+          const { promisify: promisify91 } = await import("node:util");
+          const execFileAsync37 = promisify91(execFile43);
+          const { stdout } = await execFileAsync37(
             "git",
             ["remote", "get-url", "origin"],
             { cwd: projectPath, timeout: 1e3 }
@@ -68722,10 +68766,10 @@ var init_central_core = __esm({
        */
       async generateProjectName(projectPath) {
         try {
-          const { execFile: execFile42 } = await import("node:child_process");
-          const { promisify: promisify90 } = await import("node:util");
-          const execFileAsync36 = promisify90(execFile42);
-          const { stdout } = await execFileAsync36(
+          const { execFile: execFile43 } = await import("node:child_process");
+          const { promisify: promisify91 } = await import("node:util");
+          const execFileAsync37 = promisify91(execFile43);
+          const { stdout } = await execFileAsync37(
             "git",
             ["remote", "get-url", "origin"],
             { cwd: projectPath, timeout: 5e3 }
@@ -85527,14 +85571,12 @@ async function listWorkflowDefinitionsImpl(store, options) {
   return pluginFiltered;
 }
 async function readAllWorkflowDefinitionsImpl(store) {
-  if (store.workflowDefinitionsCache) return store.workflowDefinitionsCache;
   const layer = store.getAsyncLayer();
   if (!layer) {
     throw new Error("workflow definitions: AsyncDataLayer not initialized in backend mode");
   }
   const rows = await listWorkflowRows(layer);
-  store.workflowDefinitionsCache = [...BUILTIN_WORKFLOWS, ...rows.map((row) => store.toWorkflowDefinition(row))];
-  return store.workflowDefinitionsCache;
+  return [...BUILTIN_WORKFLOWS, ...rows.map((row) => store.toWorkflowDefinition(row))];
 }
 async function getWorkflowDefinitionImpl(store, id) {
   const builtin = getBuiltinWorkflow(id);
@@ -85603,7 +85645,6 @@ function insertWorkflowDefinitionSyncImpl(store, input) {
       if (!isWorkflowDefinitionIdPrimaryKeyCollision(error2)) throw error2;
       continue;
     }
-    store.workflowDefinitionsCache = null;
     return definition;
   }
   throw new Error("Unable to allocate a free workflow definition id after repeated id collisions");
@@ -85993,11 +86034,6 @@ function getPluginStoreImpl(store) {
         ...pluginLayer ? { asyncLayer: pluginLayer } : {}
       }
     );
-    const clearWorkflowDefinitionCache = () => {
-      store.workflowDefinitionsCache = null;
-    };
-    store.pluginStore.on("plugin:registered", clearWorkflowDefinitionCache);
-    store.pluginStore.on("plugin:unregistered", clearWorkflowDefinitionCache);
   }
   return store.pluginStore;
 }
@@ -90369,11 +90405,11 @@ async function searchWithQmd(rootDir, options) {
   const command = "qmd";
   const limit = Math.max(1, Math.min(options.limit ?? 5, 20));
   try {
-    const execFileAsync36 = await getDefaultExecFileAsync();
-    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync36);
+    const execFileAsync37 = await getDefaultExecFileAsync();
+    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync37);
     scheduleQmdProjectMemoryRefresh(rootDir);
     const args = buildQmdSearchArgs(rootDir, options);
-    const { stdout } = await execFileAsync36(command, args, {
+    const { stdout } = await execFileAsync37(command, args, {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 1024 * 1024
@@ -90398,12 +90434,12 @@ async function searchWithQmd(rootDir, options) {
     return [];
   }
 }
-async function ensureQmdProjectMemoryCollection(rootDir, execFileAsync36) {
+async function ensureQmdProjectMemoryCollection(rootDir, execFileAsync37) {
   const collectionName = qmdMemoryCollectionName(rootDir);
   const memoryDir = memoryWorkspacePath(rootDir);
   await mkdir10(memoryDir, { recursive: true });
   try {
-    await execFileAsync36("qmd", buildQmdCollectionAddArgs(rootDir), {
+    await execFileAsync37("qmd", buildQmdCollectionAddArgs(rootDir), {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 512 * 1024
@@ -90501,14 +90537,14 @@ async function refreshQmdProjectMemoryIndex(rootDir, options) {
     }
   }
   const promise = (async () => {
-    const execFileAsync36 = options?.execFileAsync ?? await getDefaultExecFileAsync();
-    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync36);
-    await execFileAsync36("qmd", ["update"], {
+    const execFileAsync37 = options?.execFileAsync ?? await getDefaultExecFileAsync();
+    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync37);
+    await execFileAsync37("qmd", ["update"], {
       cwd: rootDir,
       timeout: 3e4,
       maxBuffer: 1024 * 1024
     });
-    await execFileAsync36("qmd", ["embed"], {
+    await execFileAsync37("qmd", ["embed"], {
       cwd: rootDir,
       timeout: 12e4,
       maxBuffer: 1024 * 1024
@@ -90544,12 +90580,12 @@ async function refreshQmdAgentMemoryIndex(rootDir, agentId, options) {
     }
   }
   const promise = (async () => {
-    const execFileAsync36 = options?.execFileAsync ?? await getDefaultExecFileAsync();
+    const execFileAsync37 = options?.execFileAsync ?? await getDefaultExecFileAsync();
     const { agentMemoryWorkspacePath: agentMemoryWorkspacePath2 } = await Promise.resolve().then(() => (init_memory_dreams(), memory_dreams_exports));
     const workspacePath = agentMemoryWorkspacePath2(rootDir, agentId);
     await mkdir10(workspacePath, { recursive: true });
     try {
-      await execFileAsync36("qmd", ["collection", "add", workspacePath, "--name", qmdAgentMemoryCollectionName(rootDir, agentId), "--mask", "**/*.md"], {
+      await execFileAsync37("qmd", ["collection", "add", workspacePath, "--name", qmdAgentMemoryCollectionName(rootDir, agentId), "--mask", "**/*.md"], {
         cwd: rootDir,
         timeout: 4e3,
         maxBuffer: 512 * 1024
@@ -90562,8 +90598,8 @@ ${stderr}`)) {
         throw err;
       }
     }
-    await execFileAsync36("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
-    await execFileAsync36("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync37("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync37("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
   })();
   qmdAgentRefreshState.set(key, { lastStartedAt: now, inFlight: promise });
   try {
@@ -90584,8 +90620,8 @@ function scheduleQmdAgentMemoryRefresh(rootDir, agentId) {
 }
 async function isQmdAvailable() {
   try {
-    const execFileAsync36 = await getDefaultExecFileAsync();
-    await execFileAsync36("qmd", ["--help"], {
+    const execFileAsync37 = await getDefaultExecFileAsync();
+    await execFileAsync37("qmd", ["--help"], {
       timeout: 3e3,
       maxBuffer: 128 * 1024,
       keepAlive: true
@@ -90596,12 +90632,12 @@ async function isQmdAvailable() {
   }
 }
 async function installQmd(options) {
-  const execFileAsync36 = options?.execFileAsync ?? await getDefaultExecFileAsync();
+  const execFileAsync37 = options?.execFileAsync ?? await getDefaultExecFileAsync();
   const [command, ...args] = QMD_INSTALL_COMMAND.split(" ");
   if (!command || args.length === 0) {
     throw new MemoryBackendError("BACKEND_UNAVAILABLE", "qmd install command is not configured", "qmd");
   }
-  await execFileAsync36(command, args, {
+  await execFileAsync37(command, args, {
     timeout: 12e4,
     maxBuffer: 1024 * 1024
   });
@@ -100116,7 +100152,6 @@ async function createWorkflowDefinitionImpl(store, input) {
         if (!isWorkflowDefinitionIdPrimaryKeyCollision(error2)) throw error2;
         continue;
       }
-      store.workflowDefinitionsCache = null;
       return definition;
     }
     throw new Error("Unable to allocate a free workflow definition id after repeated id collisions");
@@ -103700,7 +103735,6 @@ async function updateWorkflowDefinitionImpl(store, id, updates) {
       eq(project_exports.workflows.id, id),
       projectScopeFor(project_exports.workflows.projectId, layer.projectId)
     ));
-    store.workflowDefinitionsCache = null;
     return next;
   });
   if (pendingRehome) {
@@ -103735,7 +103769,6 @@ async function deleteWorkflowDefinitionImpl(store, id) {
     projectScopeFor(project_exports.workflows.projectId, layer.projectId)
   )).returning();
   if (deleted.length === 0) throw new Error(`Workflow '${id}' not found`);
-  store.workflowDefinitionsCache = null;
   await layer.db.delete(project_exports.workflowSettings).where(and(
     eq(project_exports.workflowSettings.workflowId, id),
     projectScopeFor(project_exports.workflowSettings.projectId, layer.projectId)
@@ -108329,7 +108362,6 @@ var init_store = __esm({
       taskIdIntegrityReport = { status: "ok", checkedAt: (/* @__PURE__ */ new Date()).toISOString(), anomalies: [] };
       lastTaskIdIntegrityLogSignature = null;
       workflowStepsCache = null;
-      workflowDefinitionsCache = null;
       _pluginWorkflowStepTemplates = [];
       globalSettingsStore;
       donePauseBackfillDone = false;
@@ -115959,7 +115991,7 @@ function getPostMergeFinalizeBlocker(task) {
 }
 function planConfirmedMergeChecklistReconciliation(task) {
   return {
-    skippedStepIndexes: task.steps.map((step, index2) => step.status === "pending" || step.status === "in-progress" ? index2 : -1).filter((index2) => index2 >= 0),
+    skippedStepIndexes: (task.steps ?? []).map((step, index2) => step.status === "pending" || step.status === "in-progress" ? index2 : -1).filter((index2) => index2 >= 0),
     reconciledWorkflowStepIds: (task.workflowStepResults ?? []).filter((result) => result.status === "pending").map((result) => result.workflowStepId)
   };
 }
@@ -136009,11 +136041,11 @@ var require_extract_zip = __commonJS({
     var { createWriteStream, promises: fs10 } = __require("fs");
     var getStream = require_get_stream();
     var path6 = __require("path");
-    var { promisify: promisify90 } = __require("util");
+    var { promisify: promisify91 } = __require("util");
     var stream = __require("stream");
     var yauzl = require_yauzl();
-    var openZip = promisify90(yauzl.open);
-    var pipeline = promisify90(stream.pipeline);
+    var openZip = promisify91(yauzl.open);
+    var pipeline = promisify91(stream.pipeline);
     var Extractor = class {
       constructor(zipPath, opts) {
         this.zipPath = zipPath;
@@ -136095,7 +136127,7 @@ var require_extract_zip = __commonJS({
         await fs10.mkdir(destDir, mkdirOptions);
         if (isDir) return;
         debug("opening read stream", dest);
-        const readStream = await promisify90(this.zipfile.openReadStream.bind(this.zipfile))(entry);
+        const readStream = await promisify91(this.zipfile.openReadStream.bind(this.zipfile))(entry);
         if (symlink) {
           const link = await getStream(readStream);
           debug("creating symlink", link, dest);
@@ -137534,6 +137566,7 @@ async function updateChatSession(handle2, id, input) {
   if (input.status !== void 0) setValues.status = input.status;
   if (input.modelProvider !== void 0) setValues.modelProvider = input.modelProvider;
   if (input.modelId !== void 0) setValues.modelId = input.modelId;
+  if (input.agentId !== void 0) setValues.agentId = input.agentId;
   if (input.thinkingLevel !== void 0) setValues.thinkingLevel = input.thinkingLevel;
   if (input.memoryFocus !== void 0) setValues.memoryFocus = input.memoryFocus;
   if (input.pinnedAt !== void 0) setValues.pinnedAt = input.pinnedAt;
@@ -138587,6 +138620,7 @@ var init_cli_session_store = __esm({
 });
 
 // ../core/src/secrets/oauth-credential-interop.ts
+import { createHash as createHash22 } from "node:crypto";
 import { existsSync as existsSync40, readFileSync as readFileSync11 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { join as join55 } from "node:path";
@@ -138646,6 +138680,22 @@ function getLastRefreshFallbackExpiryMs(lastRefresh) {
   }
   return parsed + CODEX_REFRESH_FALLBACK_WINDOW_MS;
 }
+function isSameStoredCredentialMaterial(left, right) {
+  if (!left || !right || left.type !== right.type) {
+    return false;
+  }
+  return left.key === right.key && left.access === right.access && left.refresh === right.refresh;
+}
+function computeStoredCredentialAccountFingerprint(credential) {
+  if (!credential) {
+    return void 0;
+  }
+  const material = typeof credential.refresh === "string" && credential.refresh.length > 0 ? credential.refresh : typeof credential.access === "string" && credential.access.length > 0 ? credential.access : typeof credential.key === "string" && credential.key.length > 0 ? credential.key : void 0;
+  if (!material) {
+    return void 0;
+  }
+  return createHash22("sha256").update(`${credential.type ?? ""}\0${material}`).digest("hex").slice(0, 16);
+}
 function isStoredAuthCredential(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -139616,7 +139666,7 @@ var init_task_timing = __esm({
 });
 
 // ../core/src/task-recommendation-notice.ts
-import { createHash as createHash22 } from "node:crypto";
+import { createHash as createHash23 } from "node:crypto";
 function registerTaskRecommendationNoticeMailbox(store, mailbox) {
   mailboxes2.set(store, mailbox);
   return () => {
@@ -139641,7 +139691,7 @@ function buildTaskRecommendationNoticeContent(task, recommendations) {
 }
 function buildTaskRecommendationNoticeIdempotencyKey(taskId, recommendations) {
   const ids = recommendations.map(({ id }) => id).sort().join("\n");
-  const digest = createHash22("sha256").update(ids, "utf8").digest("hex").slice(0, 16);
+  const digest = createHash23("sha256").update(ids, "utf8").digest("hex").slice(0, 16);
   return `task-recommendation-notice:${taskId}:${digest}`;
 }
 async function notifyOperatorOfTaskRecommendations(store, task, recommendations, settings) {
@@ -140087,6 +140137,7 @@ __export(src_exports, {
   APPROVAL_REQUEST_STATUSES: () => APPROVAL_REQUEST_STATUSES,
   ARCHIVED_TASK_DOCUMENT_ADDITION_BOUNDARY: () => ARCHIVED_TASK_DOCUMENT_ADDITION_BOUNDARY,
   ARCHIVED_TASK_DOCUMENT_PUBLICATION_REJECTED: () => ARCHIVED_TASK_DOCUMENT_PUBLICATION_REJECTED,
+  AUTOMATED_BYPASS_ACTORS: () => AUTOMATED_BYPASS_ACTORS,
   AUTOMATION_PRESETS: () => AUTOMATION_PRESETS,
   AUTOMATION_SELECTABLE_TOOLS: () => AUTOMATION_SELECTABLE_TOOLS,
   AUTOPILOT_STATES: () => AUTOPILOT_STATES,
@@ -140282,6 +140333,7 @@ __export(src_exports, {
   FAST_LANE_SKIP_VALUE: () => FAST_LANE_SKIP_VALUE,
   FAST_LANE_STEP_NAME: () => FAST_LANE_STEP_NAME,
   FAST_LANE_STEP_REVIEW_ROUTE_VALUE: () => FAST_LANE_STEP_REVIEW_ROUTE_VALUE,
+  FAST_MODE_BYPASS_ACTOR: () => FAST_MODE_BYPASS_ACTOR,
   FEATURE_LOOP_REPAIR_TRANSITIONS: () => FEATURE_LOOP_REPAIR_TRANSITIONS,
   FEATURE_LOOP_STATES: () => FEATURE_LOOP_STATES,
   FEATURE_STATUSES: () => FEATURE_STATUSES,
@@ -140846,6 +140898,7 @@ __export(src_exports, {
   computeRetrySummary: () => computeRetrySummary,
   computeSkillId: () => computeSkillId,
   computeSnapshotChecksum: () => computeSnapshotChecksum,
+  computeStoredCredentialAccountFingerprint: () => computeStoredCredentialAccountFingerprint,
   computeWorkflowIrPin: () => computeWorkflowIrPin,
   configurationTargetKey: () => configurationTargetKey,
   configureApprovalRequestTtls: () => configureApprovalRequestTtls,
@@ -141168,6 +141221,7 @@ __export(src_exports, {
   isApprovalRequestExpired: () => isApprovalRequestExpired,
   isArchivedColumnRole: () => isArchivedColumnRole,
   isArchivedRemediationCarrier: () => isArchivedRemediationCarrier,
+  isAuditedOperatorBypass: () => isAuditedOperatorBypass,
   isBlockingFinding: () => isBlockingFinding,
   isBranchGroupComplete: () => isBranchGroupComplete,
   isBranchGroupMemberLanded: () => isBranchGroupMemberLanded,
@@ -141255,6 +141309,7 @@ __export(src_exports, {
   isReviewColumnRole: () => isReviewColumnRole,
   isRunRecord: () => isRunRecord,
   isRunningAgentTask: () => isRunningAgentTask,
+  isSameStoredCredentialMaterial: () => isSameStoredCredentialMaterial,
   isSanctionedEngineBackwardMove: () => isSanctionedEngineBackwardMove,
   isSandboxExperimentalEnabled: () => isSandboxExperimentalEnabled,
   isSecretAccessPolicy: () => isSecretAccessPolicy,
@@ -141533,6 +141588,7 @@ __export(src_exports, {
   renderTriagePolicyPlaceholders: () => renderTriagePolicyPlaceholders,
   renderValidationCause: () => renderValidationCause,
   renderValidationFailureDescription: () => renderValidationFailureDescription,
+  requiresContentReviewProof: () => requiresContentReviewProof,
   requiresPlannerConfirmation: () => requiresPlannerConfirmation,
   requiresWorktrunkInstallVerification: () => requiresWorktrunkInstallVerification,
   resetGhAvailabilityCache: () => resetGhAvailabilityCache,
@@ -141696,6 +141752,7 @@ __export(src_exports, {
   resolveTitleSummarizerSettingsModel: () => resolveTitleSummarizerSettingsModel,
   resolveToolOutputBudget: () => resolveToolOutputBudget,
   resolveTrailingVerificationStepIndex: () => resolveTrailingVerificationStepIndex,
+  resolveUnprovenReviewApproval: () => resolveUnprovenReviewApproval,
   resolveUpdateAutomationSettings: () => resolveUpdateAutomationSettings,
   resolveUpdateTargetVersion: () => resolveUpdateTargetVersion,
   resolveUpdatesExternallyManaged: () => resolveUpdatesExternallyManaged,
@@ -145177,18 +145234,25 @@ function parseWorktreesFromPorcelain(porcelain) {
   if (current.path) rows.push({ path: current.path, branch: current.branch });
   return rows;
 }
+function isRegenerableIgnoredPorcelainEntry(entry) {
+  const path6 = entry.slice(3).replace(/\/$/, "");
+  if (!path6 || path6.startsWith('"')) return false;
+  const lastSegment = path6.split("/").at(-1);
+  return lastSegment !== void 0 && REGENERABLE_IGNORED_DIR_NAMES.has(lastSegment);
+}
 function classifyWorktreeRemovalContent(porcelain) {
   const entries = porcelain.split(/\r?\n/).filter((line2) => line2.trim().length > 0);
   if (entries.length === 0) return "clean";
-  return entries.every((line2) => line2.startsWith("!!")) ? "ignored-only" : "deliverable";
+  if (entries.some((line2) => !line2.startsWith("!! "))) return "deliverable";
+  return entries.every(isRegenerableIgnoredPorcelainEntry) ? "regenerable-ignored" : "ignored-only";
 }
 async function assertCleanForDefensiveRemoval(worktreePath) {
   if (!existsSync42(worktreePath)) {
-    return "clean";
+    return { classification: "clean", entryCount: 0 };
   }
   let stdout;
   try {
-    ({ stdout } = await execFileAsync7("git", ["status", "--porcelain=v1", "--ignored", "--untracked-files=normal"], {
+    ({ stdout } = await execFileAsync7("git", ["status", "--porcelain=v1", "--ignored=matching", "--untracked-files=normal"], {
       cwd: worktreePath,
       encoding: "utf-8",
       timeout: 15e3,
@@ -145201,7 +145265,10 @@ async function assertCleanForDefensiveRemoval(worktreePath) {
   if (classification === "deliverable") {
     throw new Error(`preserving ${worktreePath}: uncommitted or ignored content present`);
   }
-  return classification;
+  return {
+    classification,
+    entryCount: stdout.split(/\r?\n/).filter((line2) => line2.trim().length > 0).length
+  };
 }
 async function removeWorktree(input) {
   const logger3 = {
@@ -145218,9 +145285,12 @@ async function removeWorktree(input) {
   }
   const requiresCleanWorktree = DEFENSIVE_REMOVAL_REASONS.has(input.reason);
   let contentClassification;
+  let contentEntryCount = 0;
   if (requiresCleanWorktree) {
     try {
-      contentClassification = await assertCleanForDefensiveRemoval(input.worktreePath);
+      const contentProbe = await assertCleanForDefensiveRemoval(input.worktreePath);
+      contentClassification = contentProbe.classification;
+      contentEntryCount = contentProbe.entryCount;
     } catch (error2) {
       const classification = error2 instanceof Error && error2.message.includes(": status probe failed (") ? "unverifiable" : "deliverable";
       await input.audit?.git({
@@ -145237,6 +145307,17 @@ async function removeWorktree(input) {
       throw error2;
     }
     if (contentClassification === "ignored-only" && !input.postLandingProof) {
+      await input.audit?.git({
+        type: "worktree:removal-preserved",
+        target: input.worktreePath,
+        metadata: {
+          taskId: input.taskId,
+          reason: input.reason,
+          source: void 0,
+          classification: "ignored-only",
+          hasPostLandingProof: false
+        }
+      }).catch(() => void 0);
       throw new Error(`preserving ${input.worktreePath}: uncommitted or ignored content present`);
     }
   }
@@ -145256,6 +145337,17 @@ async function removeWorktree(input) {
     } catch {
     }
   };
+  const recordRegenerableDiscard = async () => {
+    if (contentClassification !== "regenerable-ignored") return;
+    try {
+      await input.audit?.git({
+        type: "worktree:removal-discarded-regenerable-content",
+        target: input.worktreePath,
+        metadata: { taskId: input.taskId, reason: input.reason, entryCount: contentEntryCount }
+      });
+    } catch {
+    }
+  };
   if (input.expectedOwnerTaskId && input.liveOwnerProbe) {
     const reconciled = reconcileSelfOwnedActiveSessionForRemoval(
       activeSessionRegistry,
@@ -145309,6 +145401,7 @@ async function removeWorktree(input) {
   try {
     await backend.remove(removeInput);
     await recordIgnoredOnlyDiscard();
+    await recordRegenerableDiscard();
     if (input.audit) {
       await input.audit.git({
         type: backend.kind === "worktrunk" ? "worktree:worktrunk-remove" : "worktree:remove",
@@ -145336,6 +145429,7 @@ async function removeWorktree(input) {
     try {
       await native.remove(removeInput);
       await recordIgnoredOnlyDiscard();
+      await recordRegenerableDiscard();
       await input.audit?.git({ type: "worktree:remove", target: input.worktreePath });
       return { removed: true, classification: "removed" };
     } catch (nativeError) {
@@ -145357,7 +145451,7 @@ function resolveWorktreeBackend(settings, deps = {}) {
   }
   return new NativeWorktreeBackend({ logger: deps.logger, settings, audit: deps.audit });
 }
-var execAsync10, execFileAsync7, NATIVE_TIMEOUT_MS, REMOVE_TIMEOUT_MS, MAX_BUFFER3, HARMLESS_MERGE_REMOVE_ERROR_PATTERNS, WORKTRUNK_TIMEOUTS_MS, WORKTREE_BACKEND_MARKER, WorktrunkOperationError, NativeWorktreeBackend, WorktrunkWorktreeBackend, RemovalReason, ALLOWED_FORCE_REASONS, DEFENSIVE_REMOVAL_REASONS, POST_LANDING_PROOF_REASONS, InvalidForceUsageError, InvalidPostLandingProofUsageError, ActiveSessionWorktreeRemovalError;
+var execAsync10, execFileAsync7, NATIVE_TIMEOUT_MS, REMOVE_TIMEOUT_MS, MAX_BUFFER3, HARMLESS_MERGE_REMOVE_ERROR_PATTERNS, WORKTRUNK_TIMEOUTS_MS, WORKTREE_BACKEND_MARKER, WorktrunkOperationError, NativeWorktreeBackend, WorktrunkWorktreeBackend, RemovalReason, ALLOWED_FORCE_REASONS, DEFENSIVE_REMOVAL_REASONS, POST_LANDING_PROOF_REASONS, InvalidForceUsageError, InvalidPostLandingProofUsageError, ActiveSessionWorktreeRemovalError, REGENERABLE_IGNORED_DIR_NAMES;
 var init_worktree_backend = __esm({
   "../engine/src/worktree/worktree-backend.ts"() {
     "use strict";
@@ -146097,6 +146191,27 @@ ${getErrorStderr(error2) ?? ""}`;
         this.name = "ActiveSessionWorktreeRemovalError";
       }
     };
+    REGENERABLE_IGNORED_DIR_NAMES = /* @__PURE__ */ new Set([
+      "node_modules",
+      "dist",
+      "build",
+      "out",
+      "target",
+      "bin",
+      "obj",
+      "coverage",
+      ".next",
+      ".nuxt",
+      ".turbo",
+      ".svelte-kit",
+      ".parcel-cache",
+      ".pytest_cache",
+      ".mypy_cache",
+      "__pycache__",
+      ".gradle",
+      ".venv",
+      "venv"
+    ]);
   }
 });
 
@@ -146718,6 +146833,14 @@ function resolveAiMergeRootPath(rootDir, settings) {
 function resolveLegacyAiMergeRootPath(rootDir) {
   return join59(rootDir, ".fusion", "ai-merge");
 }
+function resolveAiMergeSearchRoots(rootDir, settings) {
+  const roots = [
+    resolveAiMergeRootPath(rootDir, settings),
+    resolveLegacyAiMergeRootPath(rootDir),
+    ...settings?.worktreesDir ? [] : [join59(resolveLegacyWorktreesDirLayout(rootDir), AI_MERGE_DIRNAME)]
+  ];
+  return [...new Set(roots)];
+}
 function resolveWorktreesDir(rootDir, settings, workspaceContext) {
   return resolveWorktreesDirLayout(rootDir, settings, workspaceContext);
 }
@@ -148194,7 +148317,7 @@ var init_plan_review_continuation = __esm({
 });
 
 // ../engine/src/execution/hold-release.ts
-import { createHash as createHash24 } from "node:crypto";
+import { createHash as createHash25 } from "node:crypto";
 import { readFile as readFile36 } from "node:fs/promises";
 function findColumn2(ir2, columnId) {
   if (ir2.version !== "v2") return void 0;
@@ -148232,9 +148355,9 @@ async function checkAndRecordUnplannedExecutionBlock(store, task, ir2) {
       promptContent = "";
     }
   }
-  const promptMarker = promptContent.length > 0 ? createHash24("sha256").update(promptContent).digest("hex") : "missing";
+  const promptMarker = promptContent.length > 0 ? createHash25("sha256").update(promptContent).digest("hex") : "missing";
   const dependencies = [...task.dependencies ?? []].sort();
-  const episode = createHash24("sha256").update(JSON.stringify({
+  const episode = createHash25("sha256").update(JSON.stringify({
     planReviewNode,
     promptMarker,
     dependencies,
@@ -153237,6 +153360,15 @@ async function withOAuthRefreshLock(authPath, providerId, refresh) {
     await release3();
   }
 }
+async function withOAuthInstanceLoginLock(authPath, providerId, operation) {
+  const safeProviderId = providerId.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const release3 = await import_proper_lockfile.default.lock(`${authPath}.${safeProviderId}.instance-login`, AUTH_LOCK_OPTIONS);
+  try {
+    return await operation();
+  } finally {
+    await release3();
+  }
+}
 function readDefaultInstanceMap(data) {
   const candidate = data.__fusionDefaultInstances;
   if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) return {};
@@ -153526,7 +153658,7 @@ function createFusionAuthStorage() {
       primary.reload();
       const selectPersistedRefreshCredential = () => {
         const storedCredential = primary.get(storageProvider);
-        if (refreshLockProvider !== ANTHROPIC_PROVIDER_ID2) {
+        if (storedCredential?.type === "oauth" || refreshLockProvider !== ANTHROPIC_PROVIDER_ID2) {
           return storedCredential;
         }
         const legacyCredential = primary.get(ANTHROPIC_PROVIDER_ID2);
@@ -153656,18 +153788,16 @@ function createFusionAuthStorage() {
       if (rawKey) return rawKey;
     }
     const subscriptionLoggedOut = loggedOutProviders.has(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID);
-    const legacyAnthropicOAuthCredential = rawProviderLoggedOut ? void 0 : selectStoredCredentialByType(ANTHROPIC_PROVIDER_ID2, "oauth");
+    const subscriptionCredential = subscriptionLoggedOut ? void 0 : selectStoredCredential(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID);
+    if (subscriptionCredential?.type === "oauth") {
+      const subscriptionKey = await resolveRefreshableCredentialApiKey(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, subscriptionCredential);
+      if (subscriptionKey) return subscriptionKey;
+    }
+    const legacyAnthropicOAuthCredential = rawProviderLoggedOut || subscriptionCredential ? void 0 : selectStoredCredentialByType(ANTHROPIC_PROVIDER_ID2, "oauth");
     if (!subscriptionLoggedOut && legacyAnthropicOAuthCredential) {
       const legacyKey = await resolveRefreshableCredentialApiKey(ANTHROPIC_PROVIDER_ID2, legacyAnthropicOAuthCredential);
       if (legacyKey) return legacyKey;
     }
-    if (!subscriptionLoggedOut) {
-      const subscriptionCredential = selectStoredCredential(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID);
-      if (subscriptionCredential?.type === "oauth") {
-        const subscriptionKey = await resolveRefreshableCredentialApiKey(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, subscriptionCredential);
-        if (subscriptionKey) return subscriptionKey;
-      }
-    }
     if (preferSubscription) {
       const rawKey = resolveRawApiKey();
       if (rawKey) return rawKey;
@@ -153844,8 +153974,15 @@ function createFusionAuthStorage() {
               return void 0;
             }
             if (sourceProvider !== ANTHROPIC_SUBSCRIPTION_PROVIDER_ID) {
-              await primary.set(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, subscriptionCredential);
-              loggedOutProviders.delete(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID);
+              const legacyKey = await resolveRefreshableCredentialApiKey(ANTHROPIC_PROVIDER_ID2, subscriptionCredential);
+              primary.reload();
+              const storedSubscription = primary.get(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID);
+              const refreshedLegacyCredential = primary.get(ANTHROPIC_PROVIDER_ID2);
+              if (!storedSubscription && refreshedLegacyCredential?.type === "oauth") {
+                await primary.set(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, refreshedLegacyCredential);
+                loggedOutProviders.delete(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID);
+              }
+              return legacyKey;
             }
             return resolveRefreshableCredentialApiKey(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, subscriptionCredential);
           }
@@ -153890,6 +154027,9 @@ var init_auth_storage = __esm({
       }
       data = {};
       modelRuntime;
+      async withProviderInstanceLoginLock(providerId, operation) {
+        return withOAuthInstanceLoginLock(this.authPath, providerId, operation);
+      }
       ensureFile() {
         const parent = dirname27(this.authPath);
         if (!existsSync47(parent)) mkdirSync7(parent, { recursive: true, mode: 448 });
@@ -154596,7 +154736,7 @@ var init_gating_classifications = __esm({
 });
 
 // ../engine/src/agents/agent-action-gate.ts
-import { createHash as createHash25 } from "node:crypto";
+import { createHash as createHash26 } from "node:crypto";
 function getExemptTools() {
   if (!_exemptTools) {
     _exemptTools = new Set(DEFAULT_EXEMPT_TOOLS);
@@ -154630,7 +154770,7 @@ function evaluateAgentActionGate(params) {
   if (params.toolName === "bash") {
     const command = extractShellCommand(args);
     const git10 = classifyGitCommand(command);
-    resourceId = command ? `cmd:${createHash25("sha256").update(command).digest("hex").slice(0, 16)}` : void 0;
+    resourceId = command ? `cmd:${createHash26("sha256").update(command).digest("hex").slice(0, 16)}` : void 0;
     if (git10?.write) {
       category = "git_write";
       operation = git10.operation;
@@ -176496,6 +176636,7 @@ async function connectMcpSessionTools(servers, opts = {}) {
   const clients = [];
   const closedClients = /* @__PURE__ */ new WeakSet();
   const usedToolNames = /* @__PURE__ */ new Set();
+  const serverByToolName = /* @__PURE__ */ new Map();
   let disposed = false;
   const closeOnce = async (client) => {
     if (closedClients.has(client)) return;
@@ -176545,7 +176686,9 @@ async function connectMcpSessionTools(servers, opts = {}) {
             opts.logger?.log?.(connectMsg);
           }
           for (const tool of listedTools) {
-            tools.push(wrapMcpTool(server.name, tool, client, usedToolNames));
+            const wrappedTool = wrapMcpTool(server.name, tool, client, usedToolNames);
+            tools.push(wrappedTool);
+            serverByToolName.set(wrappedTool.name, server.name);
           }
           break;
         } catch (error2) {
@@ -176572,7 +176715,7 @@ async function connectMcpSessionTools(servers, opts = {}) {
       await closeAll();
     }
   }
-  return { tools, connected, skipped, dispose: closeAll };
+  return { tools, connected, skipped, serverByToolName, dispose: closeAll };
 }
 function normalizeMaxAttempts(value) {
   if (value === void 0 || !Number.isFinite(value)) return DEFAULT_MAX_ATTEMPTS;
@@ -179706,8 +179849,10 @@ async function createPiAgentSessionRaw(options) {
   const createSessionWithModel = async (modelOverride) => {
     let mcpToolset;
     const allowReadonlyMcpTools = options.allowMcpToolsInReadonly === true;
-    if (forwardedMcpServers.length > 0 && (!isReadonly || allowReadonlyMcpTools)) {
-      mcpToolset = await connectMcpSessionTools(forwardedMcpServers, {
+    const readonlyMcpServerAllowlist = options.readonlyMcpServerAllowlist === void 0 ? void 0 : new Set(options.readonlyMcpServerAllowlist.map((name2) => name2.trim()).filter(Boolean));
+    const mcpServersToConnect = isReadonly && allowReadonlyMcpTools && readonlyMcpServerAllowlist !== void 0 ? forwardedMcpServers.filter((server) => readonlyMcpServerAllowlist.has(server.name)) : forwardedMcpServers;
+    if (mcpServersToConnect.length > 0 && (!isReadonly || allowReadonlyMcpTools)) {
+      mcpToolset = await connectMcpSessionTools(mcpServersToConnect, {
         cwd: options.cwd,
         clientFactory: options.mcpClientFactory,
         logger: piLog,
@@ -179718,7 +179863,8 @@ async function createPiAgentSessionRaw(options) {
         piLog.warn(`MCP session continuing with unavailable servers: count=${bootstrapFailures.length}`);
       }
     } else if (forwardedMcpServers.length > 0 && isReadonly) {
-      piLog.debug(`readonly session \u2014 MCP servers (${forwardedMcpServers.length}) skipped`);
+      const reason = !allowReadonlyMcpTools ? "no-readonly-opt-in" : "readonly-allowlist-no-match";
+      piLog.log(`readonly session \u2014 MCP servers (${forwardedMcpServers.length}) skipped: reason=${reason}`);
     }
     const mcpReadonlyTools = new Set(mcpToolset?.tools ?? []);
     const candidateCustomTools = [
@@ -179727,7 +179873,9 @@ async function createPiAgentSessionRaw(options) {
     ];
     const readonlyFilteredCustomTools = isReadonly ? filterCustomToolsForReadonly(
       candidateCustomTools,
-      allowReadonlyMcpTools ? { allowTool: (tool) => mcpReadonlyTools.has(tool) } : {}
+      allowReadonlyMcpTools ? {
+        allowTool: (tool) => readonlyMcpServerAllowlist === void 0 ? mcpReadonlyTools.has(tool) : readonlyMcpServerAllowlist.has(mcpToolset?.serverByToolName?.get(tool.name) ?? "")
+      } : {}
     ) : { allowed: candidateCustomTools, denied: [] };
     const allowlistFilteredCustomTools = {
       ...readonlyFilteredCustomTools,
@@ -180197,7 +180345,7 @@ var init_pi = __esm({
 });
 
 // ../engine/src/agents/agent-logger.ts
-import { createHash as createHash26 } from "node:crypto";
+import { createHash as createHash27 } from "node:crypto";
 function truncateToolResultDetail(value) {
   if (value.length <= TOOL_RESULT_DETAIL_LIMIT) return value;
   return `${value.slice(0, TOOL_RESULT_DETAIL_LIMIT)}${TOOL_RESULT_DETAIL_TRUNCATION_NOTICE}`;
@@ -180305,7 +180453,7 @@ function summarizeToolArgs(name2, args) {
     return `${key}=${clipToolArgValue(compactToolArgValue(args[key]), maximum)}`;
   }).join(", ");
   if (rendered.length <= TOOL_ARG_SUMMARY_MAX) return rendered;
-  const hash3 = createHash26("sha256").update(fullArgsJson).digest("hex").slice(0, STRUCTURED_ARG_HASH_HEX_LEN);
+  const hash3 = createHash27("sha256").update(fullArgsJson).digest("hex").slice(0, STRUCTURED_ARG_HASH_HEX_LEN);
   const suffix = `\u2026#${hash3}`;
   const keep = Math.max(0, TOOL_ARG_SUMMARY_MAX - suffix.length);
   return `${rendered.slice(0, keep)}${suffix}`;
@@ -183013,7 +183161,7 @@ var init_retry_burned_logger = __esm({
 
 // ../engine/src/merge/merge-dependency-sync.ts
 import { exec as exec20 } from "node:child_process";
-import { createHash as createHash27 } from "node:crypto";
+import { createHash as createHash28 } from "node:crypto";
 import { existsSync as existsSync50, readFileSync as readFileSync19, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join69 } from "node:path";
 import { promisify as promisify27 } from "node:util";
@@ -183046,7 +183194,7 @@ function computeLockfileHash(rootDir) {
     const p2 = join69(rootDir, name2);
     if (existsSync50(p2)) {
       try {
-        return createHash27("sha256").update(readFileSync19(p2)).digest("hex");
+        return createHash28("sha256").update(readFileSync19(p2)).digest("hex");
       } catch {
         return null;
       }
@@ -183176,7 +183324,7 @@ var init_merge_dependency_sync = __esm({
 });
 
 // ../engine/src/worktree/worktree-dependency-install.ts
-import { createHash as createHash28 } from "node:crypto";
+import { createHash as createHash29 } from "node:crypto";
 import { existsSync as existsSync51, readFileSync as readFileSync20, readdirSync as readdirSync8, statSync as statSync11, writeFileSync as writeFileSync7 } from "node:fs";
 import { delimiter as delimiter2, join as join70 } from "node:path";
 function rootEntries(rootDir) {
@@ -183274,7 +183422,7 @@ function isCommandAvailable(binary, env = process.env) {
   );
 }
 function hashParts(parts) {
-  const hash3 = createHash28("sha256");
+  const hash3 = createHash29("sha256");
   for (const [name2, value] of [...parts].sort(([left], [right]) => left.localeCompare(right))) {
     hash3.update(name2).update("\0").update(value).update("\0");
   }
@@ -185558,7 +185706,7 @@ var init_code_node_runner = __esm({
 // ../engine/src/agent-tools.ts
 import { appendFile as appendFile3, mkdir as mkdir27, readFile as readFile40, readdir as readdir11, realpath, stat as stat11, writeFile as writeFile23 } from "node:fs/promises";
 import { existsSync as existsSync53 } from "node:fs";
-import { createHash as createHash29, randomUUID as randomUUID48 } from "node:crypto";
+import { createHash as createHash30, randomUUID as randomUUID48 } from "node:crypto";
 import { tmpdir as tmpdir6 } from "node:os";
 import { extname as extname4, isAbsolute as isAbsolute14, join as join72, relative as relative13, resolve as resolve40, sep as sep11 } from "node:path";
 import { Type as Type2 } from "@earendil-works/pi-ai";
@@ -185602,7 +185750,7 @@ async function readAgentMemoryWorkspaceLongTerm(rootDir, agentId) {
   }
 }
 function qmdAgentMemoryCollectionName2(rootDir, agentId) {
-  const hash3 = createHash29("sha1").update(`${rootDir}:${agentId}`).digest("hex").slice(0, 12);
+  const hash3 = createHash30("sha1").update(`${rootDir}:${agentId}`).digest("hex").slice(0, 12);
   return `fusion-agent-memory-${sanitizeAgentMemoryId(agentId).toLowerCase()}-${hash3}`;
 }
 function buildQmdAgentMemoryCollectionAddArgs(rootDir, agentId) {
@@ -185731,11 +185879,11 @@ async function refreshAgentMemoryQmdIndex(rootDir, agentMemory) {
     return;
   }
   const promise = (async () => {
-    const { execFile: execFile42 } = await import("node:child_process");
-    const { promisify: promisify90 } = await import("node:util");
-    const execFileAsync36 = promisify90(execFile42);
+    const { execFile: execFile43 } = await import("node:child_process");
+    const { promisify: promisify91 } = await import("node:util");
+    const execFileAsync37 = promisify91(execFile43);
     try {
-      await execFileAsync36("qmd", buildQmdAgentMemoryCollectionAddArgs(rootDir, agentMemory.agentId), {
+      await execFileAsync37("qmd", buildQmdAgentMemoryCollectionAddArgs(rootDir, agentMemory.agentId), {
         cwd: rootDir,
         timeout: 4e3,
         maxBuffer: 512 * 1024
@@ -185748,8 +185896,8 @@ ${stderr}`)) {
         throw error2;
       }
     }
-    await execFileAsync36("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
-    await execFileAsync36("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync37("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync37("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
   })();
   agentQmdRefreshState.set(key, { lastStartedAt: now, inFlight: promise });
   try {
@@ -185804,10 +185952,10 @@ async function searchAgentMemoryWithQmd(rootDir, agentMemory, query, limit) {
   }
   try {
     await refreshAgentMemoryQmdIndex(rootDir, agentMemory);
-    const { execFile: execFile42 } = await import("node:child_process");
-    const { promisify: promisify90 } = await import("node:util");
-    const execFileAsync36 = promisify90(execFile42);
-    const { stdout } = await execFileAsync36("qmd", buildQmdAgentMemorySearchArgs(rootDir, agentMemory.agentId, query, limit), {
+    const { execFile: execFile43 } = await import("node:child_process");
+    const { promisify: promisify91 } = await import("node:util");
+    const execFileAsync37 = promisify91(execFile43);
+    const { stdout } = await execFileAsync37("qmd", buildQmdAgentMemorySearchArgs(rootDir, agentMemory.agentId, query, limit), {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 1024 * 1024
@@ -190384,7 +190532,7 @@ var init_workspace_review_remediation = __esm({
 });
 
 // ../engine/src/worktree/secrets-env-writer.ts
-import { createHash as createHash30 } from "node:crypto";
+import { createHash as createHash31 } from "node:crypto";
 import { execFile as execFile17 } from "node:child_process";
 import { promises as fs6 } from "node:fs";
 import path3 from "node:path";
@@ -190393,7 +190541,7 @@ function isValidFilename(filename) {
   return !!filename && !filename.includes("/") && !filename.includes("\\") && !filename.includes("..") && !filename.includes("\0") && filename !== FINGERPRINT_FILE;
 }
 function sha2562(content) {
-  return createHash30("sha256").update(Buffer.from(content, "utf8")).digest("hex");
+  return createHash31("sha256").update(Buffer.from(content, "utf8")).digest("hex");
 }
 function quote(value) {
   return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t")}"`;
@@ -199189,7 +199337,7 @@ var init_mesh_lease_manager = __esm({
 });
 
 // ../engine/src/merge/merger-integration-worktree.ts
-import { createHash as createHash32 } from "node:crypto";
+import { createHash as createHash33 } from "node:crypto";
 import { exec as exec33, execFile as execFile26 } from "node:child_process";
 import { promisify as promisify49 } from "node:util";
 function quoteAutostashArg(value) {
@@ -199312,7 +199460,7 @@ async function gitDirtyFingerprintLocal(rootDir) {
       )
     ]);
     if (!diffOut && !statusOut) return "";
-    return createHash32("sha256").update(diffOut).update("\0").update(statusOut).digest("hex");
+    return createHash33("sha256").update(diffOut).update("\0").update(statusOut).digest("hex");
   } catch {
     return "";
   }
@@ -200295,7 +200443,7 @@ import { execSync as execSync6, exec as exec35 } from "node:child_process";
 import * as childProcess4 from "node:child_process";
 import { promisify as promisify52 } from "node:util";
 import { existsSync as existsSync61, readFileSync as readFileSync23, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3, renameSync as renameSync4 } from "node:fs";
-import { createHash as createHash33 } from "node:crypto";
+import { createHash as createHash34 } from "node:crypto";
 import { join as join80, resolve as resolve47 } from "node:path";
 import { hostname as hostname3 } from "node:os";
 import { Type as Type4 } from "typebox";
@@ -200550,7 +200698,7 @@ async function gitDirtyFingerprint(rootDir) {
       )
     ]);
     if (!diffOut && !statusOut) return "";
-    return createHash33("sha256").update(diffOut).update("\0").update(statusOut).digest("hex");
+    return createHash34("sha256").update(diffOut).update("\0").update(statusOut).digest("hex");
   } catch {
     return "";
   }
@@ -209575,19 +209723,51 @@ async function captureBaseCommitSha(store, task, worktreePath, audit, options =
 }
 
 // ../engine/src/worktree/review-diff-fingerprint.ts
-import { createHash as createHash23 } from "node:crypto";
+import { createHash as createHash24 } from "node:crypto";
 import { execFile as execFile8 } from "node:child_process";
 import { promisify as promisify8 } from "node:util";
 var execFileAsync5 = promisify8(execFile8);
+var REVIEW_DIFF_GIT_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+var REVIEW_DIFF_GIT_TIMEOUT_MS = 12e4;
+function gitCaptureOptions(cwd) {
+  return {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: REVIEW_DIFF_GIT_MAX_BUFFER_BYTES,
+    timeout: REVIEW_DIFF_GIT_TIMEOUT_MS
+  };
+}
+function isGitDiffBufferOverflow(error2) {
+  if (typeof error2 !== "object" || error2 === null) return false;
+  const candidate = error2;
+  return candidate.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" || typeof candidate.message === "string" && candidate.message.includes("maxBuffer");
+}
 var MAX_REVIEW_CHANGED_FILES = 100;
 var EMPTY_REVIEW_DIFF_FINGERPRINT = "empty-review-input:v1";
+async function resolveContentReviewInputProof(worktreePath, diffBaseCommitSha) {
+  let baseRef;
+  try {
+    baseRef = await resolveDiffBaseRef(worktreePath, diffBaseCommitSha);
+  } catch {
+    return { kind: "unprovable", reason: "no-diff-base" };
+  }
+  if (!baseRef) return { kind: "unprovable", reason: "no-diff-base" };
+  const probe = await probeReviewDiffFingerprint(worktreePath, baseRef);
+  if (probe.state === "empty") {
+    return { kind: "fingerprint", fingerprint: EMPTY_REVIEW_DIFF_FINGERPRINT };
+  }
+  return probe.state === "fingerprint" ? { kind: "fingerprint", fingerprint: probe.fingerprint } : { kind: "unprovable", reason: probe.reason };
+}
 async function probeReviewDiffFingerprint(worktreePath, baseRef, targetRef = "HEAD") {
   if (!worktreePath || !baseRef) return { state: "unavailable", reason: "missing-worktree-or-base" };
   try {
-    const { stdout } = await execFileAsync5("git", ["diff", "--binary", `${baseRef}..${targetRef}`], { cwd: worktreePath, encoding: "utf8" });
-    return stdout ? { state: "fingerprint", fingerprint: createHash23("sha256").update(stdout).digest("hex") } : { state: "empty" };
-  } catch {
-    return { state: "unavailable", reason: "git-diff-failed" };
+    const { stdout } = await execFileAsync5("git", ["diff", "--binary", `${baseRef}..${targetRef}`], gitCaptureOptions(worktreePath));
+    return stdout ? { state: "fingerprint", fingerprint: createHash24("sha256").update(stdout).digest("hex") } : { state: "empty" };
+  } catch (error2) {
+    return {
+      state: "unavailable",
+      reason: isGitDiffBufferOverflow(error2) ? "git-diff-too-large" : "git-diff-failed"
+    };
   }
 }
 async function probeReviewChangesSinceCommit(worktreePath, reviewedCommitSha) {
@@ -209595,14 +209775,11 @@ async function probeReviewChangesSinceCommit(worktreePath, reviewedCommitSha) {
     return { state: "unavailable", reason: "missing-worktree-or-reviewed-commit" };
   }
   try {
-    await execFileAsync5("git", ["cat-file", "-e", `${reviewedCommitSha}^{commit}`], {
-      cwd: worktreePath,
-      encoding: "utf8"
-    });
+    await execFileAsync5("git", ["cat-file", "-e", `${reviewedCommitSha}^{commit}`], gitCaptureOptions(worktreePath));
     const [{ stdout: countOutput }, { stdout: filesOutput }, { stdout: shortstatOutput }] = await Promise.all([
-      execFileAsync5("git", ["rev-list", "--count", `${reviewedCommitSha}..HEAD`], { cwd: worktreePath, encoding: "utf8" }),
-      execFileAsync5("git", ["diff", "--name-only", "-z", `${reviewedCommitSha}..HEAD`], { cwd: worktreePath, encoding: "utf8" }),
-      execFileAsync5("git", ["diff", "--shortstat", `${reviewedCommitSha}..HEAD`], { cwd: worktreePath, encoding: "utf8" })
+      execFileAsync5("git", ["rev-list", "--count", `${reviewedCommitSha}..HEAD`], gitCaptureOptions(worktreePath)),
+      execFileAsync5("git", ["diff", "--name-only", "-z", `${reviewedCommitSha}..HEAD`], gitCaptureOptions(worktreePath)),
+      execFileAsync5("git", ["diff", "--shortstat", `${reviewedCommitSha}..HEAD`], gitCaptureOptions(worktreePath))
     ]);
     const commitCount = Number.parseInt(countOutput.trim(), 10);
     if (!Number.isSafeInteger(commitCount) || commitCount < 0) {
@@ -209639,7 +209816,12 @@ import { promisify as promisify11 } from "node:util";
 import { join as join57 } from "node:path";
 var execFileAsync6 = promisify11(execFile9);
 async function git(args, cwd) {
-  const { stdout } = await execFileAsync6("git", args, { cwd, encoding: "utf8" });
+  const { stdout } = await execFileAsync6("git", args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: REVIEW_DIFF_GIT_MAX_BUFFER_BYTES,
+    timeout: REVIEW_DIFF_GIT_TIMEOUT_MS
+  });
   return stdout.trim();
 }
 async function captureWorkspaceReviewEvidence(options) {
@@ -209721,14 +209903,14 @@ async function captureMergeContentDescriptor(task, deps) {
 
 // ../engine/src/project-engine.ts
 init_integration_branch();
-import { execFile as execFile41 } from "node:child_process";
-import { promisify as promisify89 } from "node:util";
+import { execFile as execFile42 } from "node:child_process";
+import { promisify as promisify90 } from "node:util";
 
 // ../engine/src/runtimes/in-process-runtime.ts
 init_src2();
 init_scheduler();
 init_pi();
-import { createHash as createHash37 } from "node:crypto";
+import { createHash as createHash38 } from "node:crypto";
 import { EventEmitter as EventEmitter27 } from "node:events";
 
 // ../engine/src/executor/public-reexports.ts
@@ -211291,7 +211473,7 @@ var WorkflowGraphExecutor = class {
             phase: "pre-merge",
             source: "optional-group",
             status: "skipped",
-            bypassedBy: "fast-mode",
+            bypassedBy: FAST_MODE_BYPASS_ACTOR,
             bypassedAt,
             bypassReason: "Fast mode bypasses pre-merge workflow gates",
             bypassedFromStatus: "absent",
@@ -211495,7 +211677,7 @@ var WorkflowGraphExecutor = class {
         const stepFindings = this.workflowReviewKind(node) && Array.isArray(exitContextPatch?.findings) ? exitContextPatch.findings : void 0;
         const repositoryReviewOutcomes = this.workflowReviewKind(node) && Array.isArray(exitContextPatch?.repositoryReviewOutcomes) ? exitContextPatch.repositoryReviewOutcomes : void 0;
         const repositoryScopeRevision = this.workflowReviewKind(node) && typeof exitContextPatch?.repositoryScopeRevision === "number" ? exitContextPatch.repositoryScopeRevision : void 0;
-        const reviewInputFingerprint = this.workflowReviewKind(node) && typeof exitContextPatch?.reviewInputFingerprint === "string" ? exitContextPatch.reviewInputFingerprint : void 0;
+        const reviewInputFingerprint = requiresContentReviewProof(node.id, { reviewKind: this.workflowReviewKind(node) }) && typeof exitContextPatch?.reviewInputFingerprint === "string" ? exitContextPatch.reviewInputFingerprint : void 0;
         const reviewedCommitSha = this.workflowReviewKind(node) && typeof exitContextPatch?.reviewedCommitSha === "string" ? exitContextPatch.reviewedCommitSha : void 0;
         const supersededFindingSourceWorkflowStepId = this.workflowReviewKind(node) && typeof exitContextPatch?.supersededFindingSourceWorkflowStepId === "string" ? exitContextPatch.supersededFindingSourceWorkflowStepId : void 0;
         const supersededFindingIds = supersededFindingSourceWorkflowStepId && this.workflowReviewKind(node) && Array.isArray(exitContextPatch?.supersededFindingIds) ? exitContextPatch.supersededFindingIds.filter((id) => typeof id === "string") : void 0;
@@ -212234,7 +212416,7 @@ ${stepOutput}` : ""}`);
     const findings = this.workflowReviewKind(node) && Array.isArray(contextPatch.findings) ? contextPatch.findings : void 0;
     const repositoryReviewOutcomes = this.workflowReviewKind(node) && Array.isArray(contextPatch.repositoryReviewOutcomes) ? contextPatch.repositoryReviewOutcomes : void 0;
     const repositoryScopeRevision = this.workflowReviewKind(node) && typeof contextPatch.repositoryScopeRevision === "number" ? contextPatch.repositoryScopeRevision : void 0;
-    const reviewInputFingerprint = this.workflowReviewKind(node) && typeof contextPatch.reviewInputFingerprint === "string" ? contextPatch.reviewInputFingerprint : void 0;
+    const reviewInputFingerprint = requiresContentReviewProof(node.id, { reviewKind: this.workflowReviewKind(node) }) && typeof contextPatch.reviewInputFingerprint === "string" ? contextPatch.reviewInputFingerprint : void 0;
     const reviewedCommitSha = this.workflowReviewKind(node) && typeof contextPatch.reviewedCommitSha === "string" ? contextPatch.reviewedCommitSha : void 0;
     const supersededFindingSourceWorkflowStepId = this.workflowReviewKind(node) && typeof contextPatch.supersededFindingSourceWorkflowStepId === "string" ? contextPatch.supersededFindingSourceWorkflowStepId : void 0;
     const supersededFindingIds = supersededFindingSourceWorkflowStepId && this.workflowReviewKind(node) && Array.isArray(contextPatch.supersededFindingIds) ? contextPatch.supersededFindingIds.filter((id) => typeof id === "string") : void 0;
@@ -212756,7 +212938,7 @@ init_agent_tools();
 init_agent_logger();
 init_agent_usage_telemetry();
 import { Type as Type3 } from "@earendil-works/pi-ai";
-import { createHash as createHash31 } from "node:crypto";
+import { createHash as createHash32 } from "node:crypto";
 
 // ../engine/src/agents/approval-mail.ts
 init_src2();
@@ -214385,7 +214567,7 @@ function truncatePrompt(text2, maxChars) {
 ... (truncated, ${text2.length} chars)`;
 }
 function shortContentHash(value) {
-  return createHash31("sha256").update(value).digest("hex").slice(0, 8);
+  return createHash32("sha256").update(value).digest("hex").slice(0, 8);
 }
 function buildIdentitySnapshot(args) {
   const { agent, resolvedInstructions, workspaceMemory } = args;
@@ -218766,6 +218948,51 @@ async function finalizeProvenAutoMergeTask({
   }
 }
 
+// ../engine/src/merge/stale-content-review-reroute.ts
+init_src2();
+function isContentReviewNode(node) {
+  if (node.kind !== "optional-group" && node.kind !== "step-review") return false;
+  const name2 = typeof node.config?.name === "string" ? node.config.name : "";
+  return node.id === "code-review" || node.config?.reviewKind === "code" || /code review/i.test(name2);
+}
+async function rerouteSingularStaleContentToReview(store, task, options) {
+  const mergeContent = options.mergeContent;
+  if (mergeContent.kind !== "singular" || task.workspaceWorktrees !== void 0) {
+    return { rerouted: false, reason: "not-singular" };
+  }
+  if (task.paused || task.userPaused || task.deletedAt || task.autoMerge === false) {
+    return { rerouted: false, reason: "operator-held" };
+  }
+  if (mergeContent.diff.state !== "fingerprint") return { rerouted: false, reason: "no-progress" };
+  const currentFingerprint = mergeContent.diff.fingerprint;
+  const ir2 = await resolveWorkflowIrForTask(store, task.id);
+  const selection = store.getTaskWorkflowSelectionAsync ? await store.getTaskWorkflowSelectionAsync(task.id) : store.getTaskWorkflowSelection(task.id);
+  const selected = selection?.stepIds ?? [];
+  const nodes2 = ir2.nodes.filter((node2) => {
+    if (!isContentReviewNode(node2) || !options.requiredPreMergeStepIds.has(node2.id)) return false;
+    return node2.config?.defaultOn === true || selected.includes(node2.id);
+  });
+  const node = nodes2.find((candidate) => {
+    const latest = task.workflowStepResults?.filter((result2) => result2.workflowStepId === candidate.id).at(-1);
+    return latest?.reviewInputFingerprint !== currentFingerprint;
+  });
+  if (!node) return { rerouted: false, reason: nodes2.length ? "no-progress" : "no-review-route" };
+  const items = await store.listWorkflowWorkItemsForTask(task.id);
+  const result = await store.seedWorkspaceCodeReviewContinuationIfIdle({
+    taskId: task.id,
+    nodeId: node.id,
+    kind: "task",
+    state: "runnable",
+    runId: `${task.id}:stale-content-review-reroute:${node.id}:${items.length}`,
+    stableWorkflowRunId: `${task.id}:${ir2.name}`,
+    continuationSequence: items.length,
+    sourceColumn: task.column,
+    targetColumn: node.column ?? task.column,
+    irHash: computeWorkflowIrPin(ir2, node.id).irHash
+  });
+  return result.seeded ? { rerouted: true, reason: "seeded", nodeId: node.id, workflowStepId: node.id } : { rerouted: false, reason: "active-continuation", nodeId: node.id, workflowStepId: node.id };
+}
+
 // ../engine/src/healing/auto-recovery.ts
 init_logger();
 var autoRecoveryLog = createLogger("auto-recovery");
@@ -220175,9 +220402,6 @@ var BOARD_STALL_NOTIFICATION_COOLDOWN_MS = 60 * 6e4;
 var DB_CORRUPTION_NOTIFICATION_COOLDOWN_MS = 60 * 60 * 1e3;
 var PHANTOM_EXECUTOR_BINDING_AGE_MULTIPLIER = 3;
 var MAX_NO_PROGRESS_RESUME_ATTEMPTS = 2;
-function resolveRepoLocalAiMergeRoot(rootDir, settings) {
-  return resolveAiMergeRootPath(rootDir, settings);
-}
 async function classifyOwnedLandedEvidenceForSelfHealing(rootDir, task, mergeTargetBranch) {
   const { classifyOwnedLandedEvidence: classifyOwnedLandedEvidence2 } = await Promise.resolve().then(() => (init_merger(), merger_exports));
   return classifyOwnedLandedEvidence2(rootDir, task, { mergeTargetBranch });
@@ -220354,6 +220578,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
   symbolLockNoActionAudited = false;
   maintenanceTickCounter = 0;
   taskLifecycleRetentionLastPrunedAt = /* @__PURE__ */ new Map();
+  staleContentRerouteAuditKeys = /* @__PURE__ */ new Set();
   githubCheckStateRetentionLastPrunedAt = /* @__PURE__ */ new Map();
   processBootStartedAt = Date.now();
   lastDbCorruptionNotifiedAt = null;
@@ -221069,6 +221294,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       // flight" to all of them (the merge gate included), which is the two-hour
       // stall-deadlock ride this sweep exists to prevent.
       { name: "reconcile-orphaned-pending-step-results", fn: () => this.reconcileOrphanedPendingStepResults().then(() => void 0) },
+      { name: "reconcile-unproven-review-approvals", fn: () => this.reconcileUnprovenReviewApprovals().then(() => void 0) },
       /*
       FNXC:WorkspaceContention 2026-08-23-08:00:
       `contention-hold` is owned by an in-memory retry timer. After a process restart that
@@ -221949,6 +222175,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
           Keep them adjacent and in this order.
           */
           { name: "reconcile-orphaned-pending-step-results", fn: () => this.reconcileOrphanedPendingStepResults() },
+          { name: "reconcile-unproven-review-approvals", fn: () => this.reconcileUnprovenReviewApprovals() },
           { name: "recover-failed-pre-merge-steps", fn: () => this.recoverReviewTasksWithFailedPreMergeSteps() },
           { name: "recover-missing-worktree-review-failures", fn: () => this.recoverMissingWorktreeReviewFailures() },
           { name: "recover-interrupted-merging", fn: () => this.recoverInterruptedMergingTasks() },
@@ -226395,6 +226622,95 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       return 0;
     }
   }
+  /*
+    FNXC:ReviewInputProof 2026-09-01-11:28:
+    Prevention cannot release cards that already persisted a proofless `passed` content review. Repair
+    only the invalid result in place, including when auto-merge is off, so automatic recovery can re-run
+    eligible gates and a human-held card gains the failed result its audited bypass needs. The
+    `needsOperatorBypass` label is therefore truthful rather than aspirational; no lifecycle state moves.
+  
+    FNXC:ReviewInputProof 2026-09-01-11:57:
+    Reconciliation must recompute from the lock-held task inside `updateTaskAtomic`; a graph writer can
+    publish a proof-bound approval or another gate after the preliminary read, and a stale array write
+    would discard that valid result. Re-check lane, user pause, workspace ownership, and session liveness
+    in the callback, then log and audit only a repair whose atomic mutation actually applied.
+    */
+  async reconcileUnprovenReviewApprovals() {
+    try {
+      const reviewColumns = await resolveProjectColumnsForRoles(this.store, REVIEW_ROLES);
+      const candidates = /* @__PURE__ */ new Map();
+      for (const column of reviewColumns) {
+        for (const task of await this.store.listTasks({ column, slim: true })) candidates.set(task.id, task);
+      }
+      const settings = await this.store.getSettings().catch(() => void 0);
+      let repairedTasks = 0;
+      const isSessionLive = (taskId) => {
+        const livePaths = activeSessionRegistry.pathsForTask(taskId);
+        return livePaths.some((path6) => activeSessionRegistry.isPathActive(path6)) || executingTaskLock.has(taskId) || this.options.isTaskActive?.(taskId) === true;
+      };
+      for (const candidate of candidates.values()) {
+        if (candidate.userPaused === true || candidate.workspaceWorktrees !== void 0 || isSessionLive(candidate.id)) continue;
+        if (!candidate.workflowStepResults?.some((result) => resolveUnprovenReviewApproval(result, { workspace: false }))) continue;
+        const fresh = await this.store.getTask(candidate.id);
+        if (!fresh || !reviewColumns.has(fresh.column) || fresh.userPaused === true || fresh.workspaceWorktrees !== void 0 || isSessionLive(fresh.id)) continue;
+        let repair;
+        try {
+          await this.store.updateTaskAtomic(fresh.id, (live) => {
+            repair = void 0;
+            if (!reviewColumns.has(live.column) || live.userPaused === true || live.workspaceWorktrees !== void 0 || isSessionLive(live.id)) return null;
+            const repairedStepIds = [];
+            let repairReason;
+            const results = (live.workflowStepResults ?? []).map((result) => {
+              const resolution = resolveUnprovenReviewApproval(result, { workspace: false });
+              if (!resolution) return result;
+              repairedStepIds.push(result.workflowStepId);
+              repairReason ??= resolution.reason;
+              return resolution.downgraded;
+            });
+            if (repairedStepIds.length === 0 || !repairReason) return null;
+            repair = {
+              stepIds: repairedStepIds,
+              reason: repairReason,
+              column: live.column,
+              resultCount: results.length,
+              needsOperatorBypass: settings ? !allowsAutoMergeProcessing(live, settings) : void 0
+            };
+            return { workflowStepResults: results };
+          });
+          if (!repair) continue;
+          repairedTasks += 1;
+        } catch (error2) {
+          log34.warn(`reconcileUnprovenReviewApprovals: failed for ${fresh.id}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+          continue;
+        }
+        await this.store.logEntry(
+          fresh.id,
+          `[pre-merge] Invalid proofless approval repaired for ${repair.stepIds.join(", ")}: ${repair.reason}`
+        ).catch(() => void 0);
+        await emitBoundedRunAudit2(this.store, {
+          taskId: fresh.id,
+          agentId: "self-healing",
+          runId: generateSyntheticRunId("reconcile-unproven-review-approval", fresh.id),
+          domain: "database",
+          mutationType: "task:reconcile-unproven-review-approval",
+          target: fresh.id,
+          metadata: {
+            taskId: fresh.id,
+            column: repair.column,
+            workflowStepId: repair.stepIds[0],
+            repairedCount: repair.stepIds.length,
+            resultCount: repair.resultCount,
+            needsOperatorBypass: repair.needsOperatorBypass
+          }
+        }, { log: log34 });
+      }
+      if (repairedTasks > 0) log34.log(`Repaired unproven review approvals on ${repairedTasks} task(s)`);
+      return repairedTasks;
+    } catch (error2) {
+      log34.error(`reconcileUnprovenReviewApprovals failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      return 0;
+    }
+  }
   /**
    * Backward lifecycle move gated on triple proof (FN-5335).
    * When the unproven fallback predicate fails, emits `task:finalize-no-op-review-no-action` and skips lifecycle mutation.
@@ -226748,6 +227064,66 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
     }
     return allowsAutoMergeProcessing(task, settings) && resolveEffectiveAutoMerge(task, settings) !== false;
   }
+  /*
+  FNXC:PreMergeApproval 2026-09-01-14:05:
+  Self-healing must not treat a stale content-bound approval as mergeable just because the cheap
+  blocker check lacks a fresh Git descriptor. Capture the same merge content the merge queue uses and
+  seed the graph back at Code Review, so cards like FN-9234 stop looping through doomed merge retries.
+  */
+  async routeStaleSingularApprovalBackToReview(task, reviewColumns, settings) {
+    let mergeGate;
+    try {
+      mergeGate = await resolvePreMergeGateForTask(this.store, task.id, task.enabledWorkflowSteps, task);
+    } catch {
+      return false;
+    }
+    if (mergeGate.provenance === "default" && !mergeGate.selectionAbsent) return false;
+    const mergeContent = await captureMergeContentDescriptor(task, {
+      workspaceRootDir: this.options.rootDir,
+      settings
+    });
+    const blocker = getTaskMergeBlocker(task, {
+      reviewColumns,
+      requiredPreMergeStepIds: mergeGate.requiredPreMergeStepIds,
+      mergeContent
+    });
+    if (blocker !== "task has a pre-merge approval recorded against different content" || mergeContent.kind !== "singular") {
+      return false;
+    }
+    const reroute = await rerouteSingularStaleContentToReview(this.store, task, {
+      requiredPreMergeStepIds: mergeGate.requiredPreMergeStepIds,
+      mergeContent
+    }).catch(() => ({
+      rerouted: false,
+      reason: "no-progress",
+      nodeId: void 0,
+      workflowStepId: void 0
+    }));
+    if (reroute.rerouted) {
+      await this.store.logEntry(task.id, "[pre-merge] Self-healing re-seeded Code Review after stale content evidence blocked merge.");
+      log34.warn(`Stale content approval for ${task.id} re-seeded at ${reroute.nodeId ?? "code-review"}`);
+    }
+    const auditKey = `${task.id}:${reroute.reason}:${reroute.nodeId ?? ""}`;
+    if (!this.staleContentRerouteAuditKeys.has(auditKey)) {
+      this.staleContentRerouteAuditKeys.add(auditKey);
+      await emitBoundedRunAudit2(this.store, {
+        taskId: task.id,
+        agentId: "self-healing",
+        runId: generateSyntheticRunId("self-healing", task.id),
+        domain: "database",
+        mutationType: "task:merge-stale-content-review-rerouted",
+        target: task.id,
+        metadata: {
+          taskId: task.id,
+          nodeId: reroute.nodeId,
+          workflowStepId: reroute.workflowStepId,
+          reason: reroute.reason,
+          source: "self-healing"
+        }
+      });
+    }
+    return true;
+  }
   /**
    * Recover `in-review` tasks that are fully mergeable but never had
    * `mergeTask()` invoked.
@@ -226801,6 +227177,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       for (const task of mergeable) {
         const reviewColumns = await ownReviewLanesFor(task);
         if (!reviewColumns.has(task.column)) continue;
+        if (await this.routeStaleSingularApprovalBackToReview(task, reviewColumns, settings)) continue;
         if (getTaskMergeBlocker(task, { reviewColumns }) !== void 0) continue;
         laneQualifiedMergeable.push(task);
       }
@@ -229367,8 +229744,7 @@ This review is not retried until its findings change. Re-run the review after ad
   }
   async listAiMergeWorktreeCandidates(taskId, settings) {
     const roots = Array.from(/* @__PURE__ */ new Set([
-      resolveRepoLocalAiMergeRoot(this.options.rootDir, settings),
-      resolveLegacyAiMergeRootPath(this.options.rootDir),
+      ...resolveAiMergeSearchRoots(this.options.rootDir, settings),
       tmpdir8()
     ]));
     const testWorkerRoot = process.env.FUSION_TEST_WORKER_ROOT;
@@ -231902,9 +232278,7 @@ This review is not retried until its findings change. Re-run the review after ad
         log34.debug("[self-healing] temp-dir sweep: worktrunk enabled \u2014 AI merge clean-room worktrees use Fusion's dedicated clean-room root, proceeding with native sweep");
       }
       const roots = Array.from(/* @__PURE__ */ new Set([
-        resolveRepoLocalAiMergeRoot(this.options.rootDir, settings),
-        resolveLegacyAiMergeRootPath(this.options.rootDir),
-        ...settings.worktreesDir ? [] : [join81(resolveLegacyWorktreesDirLayout(this.options.rootDir), ".ai-merge")],
+        ...resolveAiMergeSearchRoots(this.options.rootDir, settings),
         tmpdir8()
       ]));
       const auditor = createRunAuditor(this.store, {
@@ -234559,7 +234933,7 @@ ${recommendation.description}`)) {
 // ../engine/src/executor/execute-workflow-step.ts
 init_src2();
 import { exec as exec41 } from "node:child_process";
-import { promisify as promisify58 } from "node:util";
+import { promisify as promisify59 } from "node:util";
 
 // ../engine/src/executor/shared-worker-tools.ts
 init_agent_tools();
@@ -236418,6 +236792,47 @@ function isWorkflowStepSkillDiscoverable(skillName, additionalSkillPaths, ceSkil
   );
 }
 
+// ../engine/src/worktree/review-inline-fix-recapture.ts
+import { execFile as execFile29 } from "node:child_process";
+import { promisify as promisify58 } from "node:util";
+var execFileAsync23 = promisify58(execFile29);
+function classifyReviewInlineFixRecapture(input) {
+  if (input.reviewKind === "plan") return { recapture: false, reason: "plan-domain" };
+  if (input.verdict !== "APPROVE" && input.verdict !== "APPROVE_WITH_NOTES") {
+    return { recapture: false, reason: "not-approval-verdict" };
+  }
+  if (!input.reviewedCommitSha || !input.currentHeadSha || !input.baseRef) {
+    return { recapture: false, reason: "missing-anchor" };
+  }
+  if (input.reviewedCommitSha === input.currentHeadSha) return { recapture: false, reason: "head-unchanged" };
+  if (input.fastForwardAdvance === void 0 || input.baseIsAncestor === void 0) {
+    return { recapture: false, reason: "probe-unavailable" };
+  }
+  if (!input.fastForwardAdvance) return { recapture: false, reason: "history-rewritten" };
+  if (!input.baseIsAncestor) return { recapture: false, reason: "base-not-ancestor" };
+  if (!input.fingerprintProbeAvailable) return { recapture: false, reason: "probe-unavailable" };
+  return { recapture: true, reason: "recaptured" };
+}
+async function readHeadSha(worktreePath) {
+  if (!worktreePath) return void 0;
+  try {
+    const { stdout } = await execFileAsync23("git", ["rev-parse", "HEAD"], { cwd: worktreePath, encoding: "utf8" });
+    return stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function isFastForwardAdvance(worktreePath, fromSha, toSha) {
+  if (!worktreePath || !fromSha || !toSha) return void 0;
+  try {
+    await execFileAsync23("git", ["merge-base", "--is-ancestor", fromSha, toSha], { cwd: worktreePath, encoding: "utf8" });
+    return true;
+  } catch (error2) {
+    const code = error2?.code;
+    return code === 1 ? false : void 0;
+  }
+}
+
 // ../engine/src/executor/optional-step-revision.ts
 init_src2();
 
@@ -236575,7 +236990,7 @@ function buildGraphPlanReviewConvergenceContext(task, revisionKey) {
 
 // ../engine/src/executor/execute-workflow-step.ts
 init_agent_usage_telemetry();
-var execAsync38 = promisify58(exec41);
+var execAsync38 = promisify59(exec41);
 var WORKFLOW_STEP_NOTES_REPAIR_TIMEOUT_MS = 12e4;
 function findReusableReviewResult(task, workflowStepId, reviewInputFingerprint, repositoryScopeRevision) {
   if (!reviewInputFingerprint) return void 0;
@@ -236614,6 +237029,8 @@ async function executeWorkflowStep(deps, task, workflowStep, worktreePath, setti
   const unattended = stepOptions?.unattended === true;
   const workflowStepMetadata = workflowStep;
   const optionalGroupId = workflowStepMetadata.optionalGroupId;
+  const effectiveWorkflowStepId = optionalGroupId ?? workflowStep.id.replace(/^graph:/, "");
+  const isContentBindingStep = requiresContentReviewProof(effectiveWorkflowStepId, workflowStepMetadata);
   const isPlanReviewStep = workflowStep.id === "graph:plan-review-step" || workflowStep.name === "Plan Review" || optionalGroupId === PLAN_REVIEW_GROUP_ID;
   const planReviewRevisionKey = optionalStepRevisionKey2(optionalGroupId, workflowStep.name);
   const isReviewTypeWorkflowStep = isPlanReviewStep || workflowStepMetadata.reviewCanFixInline === true || /(?:^|\b)(?:review|verification)(?:\b|$)/i.test(workflowStep.name) || optionalGroupId === "plan-review" || optionalGroupId === "code-review" || optionalGroupId === "browser-verification";
@@ -236624,6 +237041,8 @@ async function executeWorkflowStep(deps, task, workflowStep, worktreePath, setti
     toolMode = "coding";
   }
   const requireExternalIntegrationEvidence = workflowStepMetadata.requireExternalIntegrationEvidence === true;
+  const readonlyMcpServerAllowlist = toolMode === "readonly" ? [...new Set((workflowStepMetadata.readonlyMcpServers ?? []).map((name2) => name2.trim()).filter(Boolean))] : [];
+  const allowReadonlyMcpTools = toolMode === "readonly" && readonlyMcpServerAllowlist.length > 0;
   let workflowReviewSpecArtifact;
   if (isReviewTypeWorkflowStep) {
     try {
@@ -236642,7 +237061,7 @@ async function executeWorkflowStep(deps, task, workflowStep, worktreePath, setti
   const workflowReviewSpecText = typeof workflowReviewSpecArtifact === "string" ? workflowReviewSpecArtifact : "";
   const planReviewSpecText = isPlanReviewStep ? workflowReviewSpecText : "";
   const latestTaskForUserComments = await deps.store.getTask(task.id).catch(() => task);
-  const sameGateStepId = workflowStep.id.replace(/^graph:/, "");
+  const sameGateStepId = effectiveWorkflowStepId;
   const planReviewConvergenceContext = isPlanReviewStep ? buildGraphPlanReviewConvergenceContext(latestTaskForUserComments, planReviewRevisionKey) : "";
   const planReviewEnvironmentCapabilities = isPlanReviewStep ? await probeEnvironmentCapabilities({
     extraCommands: [
@@ -236690,21 +237109,44 @@ async function executeWorkflowStep(deps, task, workflowStep, worktreePath, setti
   let diffShortstat;
   let reviewInputFingerprint;
   let reviewedCommitSha;
+  let baseRef;
   try {
-    const baseRef = await resolveDiffBaseRef(worktreePath, diffBaseCommitSha);
-    if (baseRef) {
-      const { stdout } = await execAsync38(`git diff --shortstat ${baseRef}..HEAD`, {
-        cwd: worktreePath,
-        encoding: "utf-8"
-      });
-      diffShortstat = stdout.trim() || void 0;
+    baseRef = await resolveDiffBaseRef(worktreePath, diffBaseCommitSha);
+  } catch {
+  }
+  if (isContentBindingStep && task.workspaceWorktrees === void 0) {
+    const suppliedFingerprint = stepOptions?.reviewInputFingerprint?.trim();
+    const proof = suppliedFingerprint ? { kind: "fingerprint", fingerprint: suppliedFingerprint } : await resolveContentReviewInputProof(worktreePath, diffBaseCommitSha);
+    if (proof.kind === "unprovable") {
+      const diagnostic = `${workflowStep.name} review input is unprovable (${proof.reason}); reviewer dispatch refused.`;
+      await deps.store.logEntry(
+        task.id,
+        `[pre-merge] ${diagnostic}`,
+        void 0,
+        deps.getRunContextFor(task.id)
+      );
+      return { success: false, error: diagnostic, failureValue: "review-input-unprovable" };
+    }
+    reviewInputFingerprint = proof.fingerprint;
+  } else if (baseRef) {
+    try {
       if (workflowStepMetadata.reviewKind === "code") {
         reviewInputFingerprint = await computeCodeReviewInputFingerprint(worktreePath, baseRef);
       } else if (isReviewTypeWorkflowStep) {
         reviewInputFingerprint = await computeReviewDiffFingerprint(worktreePath, baseRef);
       }
+    } catch {
+    }
+  }
+  if (baseRef) {
+    try {
+      const { stdout } = await execAsync38(`git diff --shortstat ${baseRef}..HEAD`, {
+        cwd: worktreePath,
+        encoding: "utf-8"
+      });
+      diffShortstat = stdout.trim() || void 0;
+    } catch {
     }
-  } catch {
   }
   if (isReviewTypeWorkflowStep) {
     try {
@@ -237014,6 +237456,12 @@ ${workflowStepUserCommentSection}` : ""}${priorFindingsBlock}
     const workflowStepThinkingSource = workflowStep.thinkingLevel ?? (isReviewTypeWorkflowStep ? task.validatorThinkingLevel ?? task.thinkingLevel : task.thinkingLevel);
     const workflowStepThinkingLevel = attemptLabel === "fallback" ? isReviewTypeWorkflowStep ? resolveValidatorFallbackThinkingLevel(workflowStepThinkingSource, settings) : resolveExecutorFallbackThinkingLevel(workflowStepThinkingSource, settings) : isReviewTypeWorkflowStep ? resolveValidatorThinkingLevel(workflowStepThinkingSource, settings) : resolveExecutorThinkingLevel(workflowStepThinkingSource, settings);
     const workflowStepFallbackThinkingLevel = isReviewTypeWorkflowStep ? resolveValidatorFallbackThinkingLevel(workflowStepThinkingSource, settings) : resolveExecutorFallbackThinkingLevel(workflowStepThinkingSource, settings);
+    if (allowReadonlyMcpTools) {
+      await deps.store.logEntry(
+        task.id,
+        `Workflow step '${workflowStep.name}' enabled read-only MCP servers: ${readonlyMcpServerAllowlist.join(", ")}`
+      );
+    }
     const { session } = await createResolvedAgentSession({
       sessionPurpose: "executor",
       taskExecutionSession: true,
@@ -237034,6 +237482,10 @@ ${workflowStepUserCommentSection}` : ""}${priorFindingsBlock}
       settings,
       taskEnv: stepEnv,
       mcpServers: await deps.resolveMcpServers(void 0),
+      ...allowReadonlyMcpTools ? {
+        allowMcpToolsInReadonly: true,
+        readonlyMcpServerAllowlist
+      } : {},
       // FNXC:SessionRouting 2026-06-24-11:20:
       // #1675: propagate task id so workflow-step requests carry the same
       // X-Session-Id/X-Session-Affinity as the primary session.
@@ -237249,6 +237701,60 @@ ${detectedQuestion}
           });
         }
         const revisionRequested = effectiveVerdict === "REVISE";
+        if (isReviewTypeWorkflowStep && !isPlanReviewStep && !revisionRequested) {
+          const priorReviewedCommitSha = reviewedCommitSha;
+          const currentHeadSha = await readHeadSha(worktreePath);
+          const fastForwardAdvance = await isFastForwardAdvance(worktreePath, priorReviewedCommitSha, currentHeadSha);
+          const baseIsAncestor = await isFastForwardAdvance(worktreePath, baseRef, currentHeadSha);
+          const decision = classifyReviewInlineFixRecapture({
+            verdict: effectiveVerdict,
+            reviewKind: workflowStepMetadata.reviewKind,
+            reviewedCommitSha: priorReviewedCommitSha,
+            currentHeadSha,
+            baseRef,
+            fastForwardAdvance,
+            baseIsAncestor,
+            fingerprintProbeAvailable: true
+          });
+          if (decision.recapture) {
+            try {
+              const recapturedFingerprint = workflowStepMetadata.reviewKind === "code" ? await computeCodeReviewInputFingerprint(worktreePath, baseRef) : await computeReviewDiffFingerprint(worktreePath, baseRef);
+              const finalDecision = classifyReviewInlineFixRecapture({
+                verdict: effectiveVerdict,
+                reviewKind: workflowStepMetadata.reviewKind,
+                reviewedCommitSha: priorReviewedCommitSha,
+                currentHeadSha,
+                baseRef,
+                fastForwardAdvance,
+                baseIsAncestor,
+                fingerprintProbeAvailable: recapturedFingerprint !== void 0
+              });
+              if (finalDecision.recapture && currentHeadSha) {
+                reviewInputFingerprint = recapturedFingerprint;
+                reviewedCommitSha = currentHeadSha;
+                const resolvedInReviewFindingCount = parsed.findings?.filter((finding) => finding.resolution === "resolved-in-review").length ?? 0;
+                await deps.store.logEntry(task.id, `[pre-merge] ${workflowStep.name} re-captured its own review identity after fast-forward ${priorReviewedCommitSha?.slice(0, 7)} \u2192 ${currentHeadSha.slice(0, 7)} (${finalDecision.reason})`);
+                const runContext = deps.getRunContextFor(task.id);
+                if (runContext) await emitBoundedRunAudit2(deps.store, {
+                  taskId: task.id,
+                  agentId: runContext.agentId,
+                  runId: runContext.runId,
+                  domain: "git",
+                  mutationType: "task:review-input-recaptured",
+                  target: task.id,
+                  metadata: {
+                    taskId: task.id,
+                    workflowStepId: workflowStep.id,
+                    verdict: effectiveVerdict,
+                    resolvedInReviewFindingCount,
+                    reason: finalDecision.reason
+                  }
+                });
+              }
+            } catch {
+            }
+          }
+        }
         if (workflowStep.requiresBrowser === true) {
           await logBrowserVerificationActivity(`[browser-verification] finished browser verification for task ${task.id}: verdict ${effectiveVerdict}`);
         }
@@ -237953,10 +238459,10 @@ init_branch_conflicts();
 init_integration_branch();
 init_logger();
 import { exec as exec42 } from "node:child_process";
-import { promisify as promisify59 } from "node:util";
+import { promisify as promisify60 } from "node:util";
 import { existsSync as existsSync66 } from "node:fs";
 import { rm as rm11 } from "node:fs/promises";
-var execAsync39 = promisify59(exec42);
+var execAsync39 = promisify60(exec42);
 async function tryCreateWorktree(deps, branch, path6, taskId, startPoint, attemptNumber = 0, recoveryDepth = 0, allowSiblingBranchRename = false, settings = {}) {
   await assertWorktreePathNotNested(deps.rootDir, deps.store, path6, taskId);
   const installGuardOrCleanup = async () => {
@@ -238244,10 +238750,10 @@ init_src2();
 init_worktree_pool();
 init_logger();
 import { exec as exec43 } from "node:child_process";
-import { promisify as promisify60 } from "node:util";
+import { promisify as promisify61 } from "node:util";
 import { existsSync as existsSync67, lstatSync as lstatSync3, realpathSync as realpathSync11 } from "node:fs";
 import { rm as rm12 } from "node:fs/promises";
-var execAsync40 = promisify60(exec43);
+var execAsync40 = promisify61(exec43);
 async function cleanupConflictingWorktree(deps, worktreePath, branch, taskId) {
   await deps.reconcileSelfOwnedBeforeRemove(worktreePath, taskId);
   const activeOwner = await deps.findActiveWorktreeOwner(worktreePath, taskId);
@@ -238364,10 +238870,10 @@ init_worktree_stale_lock();
 init_integration_branch();
 init_logger();
 import { exec as exec44 } from "node:child_process";
-import { promisify as promisify61 } from "node:util";
+import { promisify as promisify62 } from "node:util";
 import { existsSync as existsSync68 } from "node:fs";
 import { isAbsolute as isAbsolute22 } from "node:path";
-var execAsync41 = promisify61(exec44);
+var execAsync41 = promisify62(exec44);
 async function resolveWorktreeStartPoint(rootDir, store, startPoint, taskId) {
   const command = isAbsolute22(startPoint) && existsSync68(startPoint) ? `git -C "${startPoint}" rev-parse --verify HEAD^{commit}` : `git rev-parse --verify "${startPoint}^{commit}"`;
   try {
@@ -238569,8 +239075,8 @@ init_effective_settings();
 init_worktree_pinning();
 init_logger();
 import { exec as exec45 } from "node:child_process";
-import { promisify as promisify62 } from "node:util";
-var execAsync42 = promisify62(exec45);
+import { promisify as promisify63 } from "node:util";
+var execAsync42 = promisify63(exec45);
 async function reclaimExistingWorktree(deps, task, livePath, branch, tipSha, count2, settings) {
   const targetPath = preservedWorktreeTargetPathForTask(task.id, livePath, settings, deps.rootDir);
   const normalizedPath = await deps.normalizeReclaimableWorktreePath(livePath, targetPath, task.id, settings);
@@ -238803,7 +239309,7 @@ init_worktree_names();
 init_logger();
 init_run_audit();
 import { exec as exec47 } from "node:child_process";
-import { promisify as promisify65 } from "node:util";
+import { promisify as promisify66 } from "node:util";
 import { existsSync as existsSync71 } from "node:fs";
 
 // ../engine/src/executor/session-worktree-paths.ts
@@ -238931,11 +239437,11 @@ function classifyWorkspaceZeroAcquire(task, options) {
 }
 
 // ../engine/src/execution/external-execution-checkout.ts
-import { execFile as execFile29 } from "node:child_process";
+import { execFile as execFile30 } from "node:child_process";
 import { existsSync as existsSync69, realpathSync as realpathSync13, statSync as statSync14 } from "node:fs";
 import { isAbsolute as isAbsolute23 } from "node:path";
-import { promisify as promisify63 } from "node:util";
-var execFileAsync23 = promisify63(execFile29);
+import { promisify as promisify64 } from "node:util";
+var execFileAsync24 = promisify64(execFile30);
 function readSourceMetadata(task) {
   if (!task || typeof task !== "object") return void 0;
   const sourceMetadata = task.sourceMetadata;
@@ -238954,7 +239460,7 @@ async function inspectExternalGitCheckout(candidate, options = {}) {
       return { valid: false, reason: `checkoutPath is not a directory: ${checkoutPath}` };
     }
     const canonicalCheckout = realpathSync13(checkoutPath);
-    const { stdout: topLevelOutput } = await execFileAsync23("git", ["rev-parse", "--show-toplevel"], {
+    const { stdout: topLevelOutput } = await execFileAsync24("git", ["rev-parse", "--show-toplevel"], {
       cwd: canonicalCheckout,
       encoding: "utf-8",
       timeout: 1e4
@@ -238967,7 +239473,7 @@ async function inspectExternalGitCheckout(candidate, options = {}) {
         reason: `checkoutPath must be the Git top-level (observed ${canonicalTopLevel})`
       };
     }
-    const { stdout: branchOutput } = await execFileAsync23("git", ["symbolic-ref", "--quiet", "--short", "HEAD"], {
+    const { stdout: branchOutput } = await execFileAsync24("git", ["symbolic-ref", "--quiet", "--short", "HEAD"], {
       cwd: canonicalCheckout,
       encoding: "utf-8",
       timeout: 1e4
@@ -238977,7 +239483,7 @@ async function inspectExternalGitCheckout(candidate, options = {}) {
       return { valid: false, reason: "checkoutPath must have a checked-out branch" };
     }
     if (options.requireClean) {
-      const { stdout: statusOutput } = await execFileAsync23("git", ["status", "--porcelain=v1"], {
+      const { stdout: statusOutput } = await execFileAsync24("git", ["status", "--porcelain=v1"], {
         cwd: canonicalCheckout,
         encoding: "utf-8",
         timeout: 1e4
@@ -239040,9 +239546,9 @@ async function resolveAuthoritativeExternalExecutionRoute(store, task) {
 import { exec as exec46 } from "node:child_process";
 import { existsSync as existsSync70, promises as fs7 } from "node:fs";
 import path4 from "node:path";
-import { promisify as promisify64 } from "node:util";
+import { promisify as promisify65 } from "node:util";
 init_worktree_paths();
-var execAsync43 = promisify64(exec46);
+var execAsync43 = promisify65(exec46);
 var probeOptions = { encoding: "utf-8", timeout: 1e4, maxBuffer: 1024 * 1024 };
 function workspaceExecutionAnchor(task) {
   const executionValues = [task.firstExecutionAt, task.executionStartedAt].map((value) => typeof value === "string" ? Date.parse(value) : Number.NaN).filter(Number.isFinite);
@@ -239162,7 +239668,7 @@ async function detectWorkspaceMainCheckoutWork(deps, task, repos, declaredScope)
 }
 
 // ../engine/src/executor/worktree-verify-invariants.ts
-var execAsync44 = promisify65(exec47);
+var execAsync44 = promisify66(exec47);
 async function verifyWorktreeInvariants(deps, task, worktreePathOverride, allowReanchor = true, options) {
   const workspaceConfig = deps.ensureWorkspaceConfig ? await deps.ensureWorkspaceConfig() : deps.workspaceConfig;
   const settings = await deps.store.getSettings();
@@ -239567,14 +240073,14 @@ async function emitWorktreeReanchoredAudit(deps, taskId, fromPath, toPath, sourc
 }
 
 // ../engine/src/executor/worktree-task-done-scope-leak.ts
-import { execFile as execFile30 } from "node:child_process";
+import { execFile as execFile31 } from "node:child_process";
 import { access as access9 } from "node:fs/promises";
-import { promisify as promisify66 } from "node:util";
+import { promisify as promisify67 } from "node:util";
 init_logger();
-var execFileAsync24 = promisify66(execFile30);
+var execFileAsync25 = promisify67(execFile31);
 async function verifyRepositoryCaptureEvidence(worktreePath) {
   await access9(worktreePath);
-  const { stdout } = await execFileAsync24("git", ["rev-parse", "--is-inside-work-tree"], {
+  const { stdout } = await execFileAsync25("git", ["rev-parse", "--is-inside-work-tree"], {
     cwd: worktreePath,
     encoding: "utf8"
   });
@@ -239591,7 +240097,7 @@ async function captureRepositoryChangeEvidence(worktreePath, baseCommitSha) {
   } else {
     commands.push(["rev-parse", "--verify", "HEAD"]);
   }
-  const results = await Promise.all(commands.map((args) => execFileAsync24("git", args, {
+  const results = await Promise.all(commands.map((args) => execFileAsync25("git", args, {
     cwd: worktreePath,
     encoding: "utf8"
   })));
@@ -239725,8 +240231,8 @@ async function evaluateTaskDoneScopeLeak(deps, task, worktreePath, promptContent
 init_branch_attribution();
 init_logger();
 import { exec as exec48 } from "node:child_process";
-import { promisify as promisify67 } from "node:util";
-var execAsync45 = promisify67(exec48);
+import { promisify as promisify68 } from "node:util";
+var execAsync45 = promisify68(exec48);
 async function captureModifiedFiles(worktreePath, baseCommitSha, taskId, audit, source = "unspecified") {
   try {
     const baseRef = await resolveDiffBaseRef(worktreePath, baseCommitSha);
@@ -240024,6 +240530,27 @@ ${result.review}`);
     summarySections.push(`[${repoRel}] ${result.verdict}: ${result.summary}`);
   }
   const aggregateVerdict = reviewedResults.some(({ result }) => result.verdict === "RETHINK") ? "RETHINK" : reviewedResults.some(({ result }) => result.verdict === "REVISE") ? "REVISE" : reviewedResults.some(({ result }) => !isApprovalFamilyVerdict(result.verdict)) ? "UNAVAILABLE" : "APPROVE";
+  let publishedModifiedFiles = modifiedFiles;
+  if (isApprovalFamilyVerdict(aggregateVerdict) && evidence && options.workspaceRootDir) {
+    try {
+      const refreshed = await captureWorkspaceReviewEvidence({ task, workspaceRootDir: options.workspaceRootDir, settings: options.settings ?? {} });
+      if (refreshed.outOfScopeRepositories.size > 0) {
+        return { verdict: "UNAVAILABLE", retryable: false, review: "Workspace Code Review cannot approve changes outside confirmed scope after review.", summary: "Unavailable: changes outside confirmed scope after review", repositoryScopeRevision };
+      }
+      for (const updated of refreshed.repositories) {
+        const original = evidence.repositories.find((candidate) => candidate.repository === updated.repository);
+        const worktreePath = workspaceWorktrees[updated.repository]?.worktreePath;
+        const outcome = repositoryReviewOutcomes.find((candidate) => candidate.repository === updated.repository && candidate.status === "REVIEWED");
+        if (!original || !worktreePath || !updated.fingerprint || !outcome || !repositoryScope.has(updated.repository)) continue;
+        if (await isFastForwardAdvance(worktreePath, original.branch, updated.branch)) {
+          repositoryDiffFingerprints[updated.repository] = updated.fingerprint;
+          outcome.fingerprint = updated.fingerprint;
+        }
+      }
+      publishedModifiedFiles = refreshed.modifiedFiles;
+    } catch {
+    }
+  }
   const blockingRepositories = reviewedResults.filter(({ result }) => !isApprovalFamilyVerdict(result.verdict)).map(({ repository }) => repository);
   const blockingSummary = blockingRepositories.length > 0 ? `blocking repositories: ${blockingRepositories.join(", ")}` : `all ${repoKeys.length} modified in-scope repositories approved`;
   const coverageNotice = noVerdictRepositories.length > 0 ? `
@@ -240035,7 +240562,7 @@ Not covered by a verdict: ${noVerdictRepositories.join(", ")}.` : "";
 ${reviewSections.join("\n\n")}`,
     summary: `${aggregateVerdict} \u2014 ${blockingSummary} \u2014 ${summarySections.join(" | ")}`,
     repositoryDiffFingerprints,
-    repositoryModifiedFiles: modifiedFiles,
+    repositoryModifiedFiles: publishedModifiedFiles,
     repositoryReviewOutcomes,
     ...findings.length > 0 ? { findings } : {},
     repositoryScopeRevision
@@ -240357,9 +240884,9 @@ init_worktree_names();
 init_worktree_pool();
 init_logger();
 import { exec as exec49 } from "node:child_process";
-import { promisify as promisify68 } from "node:util";
+import { promisify as promisify69 } from "node:util";
 init_lifecycle_columns();
-var execAsync46 = promisify68(exec49);
+var execAsync46 = promisify69(exec49);
 async function handleDepAbortCleanup(deps, taskId, worktreePath) {
   executorLog.log(`${taskId} dependency added \u2014 work discarded, moved to triage for re-planning`);
   const task = await deps.store.getTask(taskId);
@@ -240935,8 +241462,8 @@ async function advanceNoMergeWorkflowToCompleteColumn(store, task) {
 init_logger();
 import { exec as exec50 } from "node:child_process";
 import { existsSync as existsSync73, statSync as statSync15 } from "node:fs";
-import { promisify as promisify69 } from "node:util";
-var execAsync47 = promisify69(exec50);
+import { promisify as promisify70 } from "node:util";
+var execAsync47 = promisify70(exec50);
 async function runTaskStep(deps, task, stepIndex, opts = {}) {
   const { store, worktreePath } = deps;
   const gitRevParse = deps.gitRevParse ?? defaultGitRevParse;
@@ -243022,8 +243549,8 @@ async function recoverFailedPreMergeWorkflowStep(deps, task) {
 init_src2();
 init_logger();
 import { exec as exec51 } from "node:child_process";
-import { promisify as promisify70 } from "node:util";
-var execAsync48 = promisify70(exec51);
+import { promisify as promisify71 } from "node:util";
+var execAsync48 = promisify71(exec51);
 async function reconcileStepsFromGitHistory(deps, taskId, detail, worktreePath) {
   const baseCommitSha = detail.baseCommitSha;
   if (!baseCommitSha) return;
@@ -245347,7 +245874,14 @@ async function persistWorkflowStepResultWithOutcome(deps, taskId, result, fence
         scopeSuperseded = true;
         return null;
       }
-      const built = buildWorkflowStepResultPatch(current, result, isPlanReviewResult);
+      const unprovenApproval = resolveUnprovenReviewApproval(result, {
+        workspace: current.workspaceWorktrees !== void 0
+      });
+      const built = buildWorkflowStepResultPatch(
+        current,
+        unprovenApproval?.downgraded ?? result,
+        isPlanReviewResult
+      );
       activityResult = built.resultToPersist;
       activityResults = built.results;
       return built.patch;
@@ -245384,21 +245918,30 @@ async function persistWorkflowStepResultWithOutcome(deps, taskId, result, fence
     if (scopeSuperseded) return { scopeCurrent: false, persisted: false };
     if (fenceRefused) return { scopeCurrent: true, persisted: false };
     const persistedResult = activityResults?.find((entry) => entry.workflowStepId === result.workflowStepId) ?? activityResult;
-    if (isTerminalStepResult(result)) {
-      const passed = result.status === "passed" || result.status === "skipped" || result.verdict === "APPROVE" || result.verdict === "APPROVE_WITH_NOTES" || result.verdict === "CLOSE_NO_OP";
+    const approvalDowngraded = result.status === "passed" && persistedResult.status === "failed" && result.reviewInputFingerprint === void 0 && persistedResult.verdict === void 0;
+    if (approvalDowngraded) {
+      await deps.store.logEntry(
+        taskId,
+        `[pre-merge] ${result.workflowStepName} approval invalidated: ${persistedResult.notes ?? persistedResult.output ?? "review input proof missing"}`,
+        void 0,
+        deps.getRunContextFor(taskId)
+      ).catch(() => void 0);
+    }
+    if (isTerminalStepResult(persistedResult)) {
+      const passed = persistedResult.status === "passed" || persistedResult.status === "skipped" || persistedResult.verdict === "APPROVE" || persistedResult.verdict === "APPROVE_WITH_NOTES" || persistedResult.verdict === "CLOSE_NO_OP";
       try {
         await deps.store.recordAgentActivity({
           type: passed ? "workflow:gate-passed" : "workflow:gate-failed",
           attributionClaim: resolveWorkflowGateActivityClaim(
-            deps.workflowGateActivityPrincipals?.get(`${taskId}\0${result.workflowStepId}`) ?? deps.activeWorkflowPrincipals?.get(taskId)?.agentId,
+            deps.workflowGateActivityPrincipals?.get(`${taskId}\0${persistedResult.workflowStepId}`) ?? deps.activeWorkflowPrincipals?.get(taskId)?.agentId,
             live?.assignedAgentId
           ),
           taskId,
-          occurredAt: result.completedAt ?? result.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-          discriminator: `${result.workflowStepId}:${result.startedAt ?? result.completedAt ?? result.status}`,
-          metadata: buildWorkflowGateActivityMetadata(result, persistedResult)
+          occurredAt: persistedResult.completedAt ?? persistedResult.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          discriminator: `${persistedResult.workflowStepId}:${persistedResult.startedAt ?? persistedResult.completedAt ?? persistedResult.status}`,
+          metadata: buildWorkflowGateActivityMetadata(persistedResult, persistedResult)
         });
-        deps.workflowGateActivityPrincipals?.delete(`${taskId}\0${result.workflowStepId}`);
+        deps.workflowGateActivityPrincipals?.delete(`${taskId}\0${persistedResult.workflowStepId}`);
       } catch (error2) {
         executorLog.warn(`[agent-activity] ${taskId}: failed to record workflow gate activity: ${error2 instanceof Error ? error2.message : String(error2)}`);
       }
@@ -247323,8 +247866,8 @@ async function runSpawnedChild(deps, agentId, childSession, taskPrompt) {
 
 // ../engine/src/auto-recovery-handlers/file-scope.ts
 import { exec as exec52 } from "node:child_process";
-import { promisify as promisify71 } from "node:util";
-var execAsync49 = promisify71(exec52);
+import { promisify as promisify72 } from "node:util";
+var execAsync49 = promisify72(exec52);
 var FileScopeAutoRecoveryHandler = class {
   constructor(deps) {
     this.deps = deps;
@@ -247349,8 +247892,8 @@ init_integration_branch();
 init_logger();
 import { exec as exec53 } from "node:child_process";
 import { existsSync as existsSync76 } from "node:fs";
-import { promisify as promisify72 } from "node:util";
-var execAsync50 = promisify72(exec53);
+import { promisify as promisify73 } from "node:util";
+var execAsync50 = promisify73(exec53);
 var baseLog2 = createLogger("auto-recovery:branch-worktree");
 var GIT_TIMEOUT_MS8 = 3e4;
 var GIT_MAX_BUFFER6 = 10 * 1024 * 1024;
@@ -248340,8 +248883,8 @@ init_src2();
 init_worktree_names();
 init_logger();
 import { exec as exec54 } from "node:child_process";
-import { promisify as promisify73 } from "node:util";
-var execAsync51 = promisify73(exec54);
+import { promisify as promisify74 } from "node:util";
+var execAsync51 = promisify74(exec54);
 async function resetStepsIfWorkLost(deps, task) {
   const completedSteps = task.steps.filter(
     (s3) => s3.status === "done" || s3.status === "in-progress"
@@ -248416,8 +248959,8 @@ init_worktree_names();
 init_worktree_paths();
 init_logger();
 import { exec as exec55 } from "node:child_process";
-import { promisify as promisify74 } from "node:util";
-var execAsync52 = promisify74(exec55);
+import { promisify as promisify75 } from "node:util";
+var execAsync52 = promisify75(exec55);
 var WORKSPACE_ISOLATION_UNSUPPORTED_MESSAGE = "per-instance worktree isolation is not supported for workspace projects";
 function buildForeachWorktreeDeps(deps, task, runId) {
   const taskId = task.id;
@@ -248610,7 +249153,7 @@ init_src2();
 // ../engine/src/executor/derive-remediation-steps.ts
 init_src2();
 init_merger_file_scope();
-import { createHash as createHash34 } from "node:crypto";
+import { createHash as createHash35 } from "node:crypto";
 var fileReference = /(?:^|[\s(])([\w@./-]+\.(?:[cm]?[jt]sx?|json|md|css|html|yml|yaml))(?::(\d+))?/gm;
 var ansiEscapeSequence = /\u001B\[[0-?]*[ -/]*[@-~]/g;
 var isoTimestamp = /\b\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b/g;
@@ -248623,7 +249166,7 @@ function normalizeVerificationEvidence(output) {
 }
 function verificationEvidenceDigest(output) {
   const evidence = normalizeVerificationEvidence(output);
-  return evidence ? createHash34("sha256").update(evidence).digest("hex").slice(0, 16) : void 0;
+  return evidence ? createHash35("sha256").update(evidence).digest("hex").slice(0, 16) : void 0;
 }
 function verificationCandidates(input) {
   const detail = input.verificationCommandLabel ?? "verification command";
@@ -252011,6 +252554,8 @@ async function runGraphCustomNode(deps, node, nodeTask, settings, columnBinding,
   }
   const optionalGroupId = typeof graphContext?.[WORKFLOW_OPTIONAL_GROUP_CONTEXT_KEY] === "string" ? graphContext[WORKFLOW_OPTIONAL_GROUP_CONTEXT_KEY] : void 0;
   const declaredReviewKind = cfg.reviewKind === "plan" || cfg.reviewKind === "code" ? cfg.reviewKind : graphContext?.[WORKFLOW_REVIEW_KIND_CONTEXT_KEY] === "plan" || graphContext?.[WORKFLOW_REVIEW_KIND_CONTEXT_KEY] === "code" ? graphContext[WORKFLOW_REVIEW_KIND_CONTEXT_KEY] : void 0;
+  const effectiveStepId = optionalGroupId ?? node.id;
+  const isContentBindingStep = requiresContentReviewProof(effectiveStepId, { reviewKind: declaredReviewKind });
   if (isFastExecutionMode(live) && graphContext?.["workflow:fast-lane-active"] === true && isFastLaneSkippableCustomNode(node, { optionalGroupId })) {
     executorLog.debug(`${live.id}: fast mode \u2014 skipping custom graph node '${node.id}'`);
     await deps.store.logEntry(
@@ -252205,6 +252750,7 @@ ${prompt}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const stepSkillName = executorKind === "skill" && typeof cfg.skillName === "string" && cfg.skillName.trim() ? cfg.skillName.trim() : void 0;
   const stepThinkingLevel = typeof cfg.thinkingLevel === "string" && WORKFLOW_THINKING_LEVEL_SET2.has(cfg.thinkingLevel) ? cfg.thinkingLevel : void 0;
+  const readonlyMcpServers = Array.isArray(cfg.readonlyMcpServers) ? [...new Set(cfg.readonlyMcpServers.filter((name2) => typeof name2 === "string").map((name2) => name2.trim()).filter(Boolean))] : [];
   const step = {
     id: `graph:${node.id}`,
     name: typeof cfg.name === "string" && cfg.name.trim() ? cfg.name : node.id,
@@ -252221,7 +252767,8 @@ ${prompt}`;
     ...stepSkillName ? { skillName: stepSkillName } : {},
     ...cfg.requiresBrowser === true ? { requiresBrowser: true } : {},
     ...modelProvider && modelId ? { modelProvider, modelId } : {},
-    ...stepThinkingLevel ? { thinkingLevel: stepThinkingLevel } : {}
+    ...stepThinkingLevel ? { thinkingLevel: stepThinkingLevel } : {},
+    ...readonlyMcpServers.length > 0 ? { readonlyMcpServers } : {}
   };
   if (cfg.summaryTarget === "task") {
     step.summaryTarget = "task";
@@ -252335,12 +252882,36 @@ ${prompt}`;
       outcome = buildWorkspaceReviewOutcome(aggregate, { superseded: reviewSuperseded });
     }
   } else {
-    outcome = mode === "script" ? await deps.executeScriptWorkflowStep(live, step, worktreePath, settings, nodeEnv) : await deps.executeWorkflowStep(live, step, worktreePath, settings, nodeEnv, {
-      unattended,
-      principalAgentId,
-      outputLanguage,
-      ...nodeSessionBoundary ? { sessionBoundary: nodeSessionBoundary } : {}
-    });
+    const dispatchSingularStep = async (reviewInputFingerprint) => {
+      if (mode === "script") {
+        const scriptOutcome = await deps.executeScriptWorkflowStep(live, step, worktreePath, settings, nodeEnv);
+        return reviewInputFingerprint === void 0 ? scriptOutcome : { ...scriptOutcome, reviewInputFingerprint };
+      }
+      return deps.executeWorkflowStep(live, step, worktreePath, settings, nodeEnv, {
+        unattended,
+        principalAgentId,
+        outputLanguage,
+        ...nodeSessionBoundary ? { sessionBoundary: nodeSessionBoundary } : {},
+        ...reviewInputFingerprint !== void 0 ? { reviewInputFingerprint } : {}
+      });
+    };
+    if (isContentBindingStep && !workspaceConfig) {
+      const proof = await resolveContentReviewInputProof(worktreePath, executionTarget.baseCommitSha);
+      if (proof.kind === "unprovable") {
+        const diagnostic = `${step.name} review input is unprovable (${proof.reason}); reviewer dispatch refused.`;
+        await deps.store.logEntry(
+          live.id,
+          `[pre-merge] ${diagnostic}`,
+          void 0,
+          deps.getRunContextFor(live.id)
+        );
+        outcome = { success: false, error: diagnostic, failureValue: "review-input-unprovable" };
+      } else {
+        outcome = await dispatchSingularStep(proof.fingerprint);
+      }
+    } else {
+      outcome = await dispatchSingularStep();
+    }
   }
   if (declaredReviewKind && typeof outcome.output === "string") {
     const rawReviewOutput = outcome.output;
@@ -253328,7 +253899,7 @@ async function runImplementationPhase(deps, task, prepared) {
 // ../engine/src/executor/run-implementation.ts
 init_src2();
 import { exec as exec56 } from "node:child_process";
-import { promisify as promisify76 } from "node:util";
+import { promisify as promisify77 } from "node:util";
 import { existsSync as existsSync80 } from "node:fs";
 import { join as join91 } from "node:path";
 import { SessionManager as SessionManager2 } from "@earendil-works/pi-coding-agent";
@@ -254203,11 +254774,11 @@ init_logger();
 // ../engine/src/merge/merger-orphan-rehome.ts
 init_src2();
 init_merger_ref_update_advance();
-import { execFile as execFile31 } from "node:child_process";
-import { promisify as promisify75 } from "node:util";
-var execFileAsync25 = promisify75(execFile31);
+import { execFile as execFile32 } from "node:child_process";
+import { promisify as promisify76 } from "node:util";
+var execFileAsync26 = promisify76(execFile32);
 async function runGit5(args, cwd) {
-  const { stdout } = await execFileAsync25("git", args, {
+  const { stdout } = await execFileAsync26("git", args, {
     cwd,
     encoding: "utf-8",
     timeout: 3e4
@@ -254216,7 +254787,7 @@ async function runGit5(args, cwd) {
 }
 async function isAncestor3(repoDir, ancestor, descendant) {
   try {
-    await execFileAsync25(
+    await execFileAsync26(
       "git",
       ["merge-base", "--is-ancestor", ancestor, descendant],
       { cwd: repoDir, encoding: "utf-8", timeout: 3e4 }
@@ -254320,7 +254891,7 @@ init_run_audit();
 init_worktree_acquisition();
 init_worktree_paths();
 init_worktree_pool();
-var execAsync53 = promisify76(exec56);
+var execAsync53 = promisify77(exec56);
 var MAX_TASK_DONE_SESSION_RETRIES = 3;
 async function parkExternalSessionObstacle(deps, taskId, errorMessage) {
   const obstacle = classifyExternalObstacle(errorMessage);
@@ -260093,8 +260664,8 @@ init_active_session_registry();
 init_agent_session_helpers();
 init_logger();
 init_effective_settings();
-import { execFile as execFile32 } from "node:child_process";
-import { promisify as promisify77 } from "node:util";
+import { execFile as execFile33 } from "node:child_process";
+import { promisify as promisify78 } from "node:util";
 
 // ../engine/src/agents/workflow-agent-capacity.ts
 var WorkflowAgentCapacity = class _WorkflowAgentCapacity {
@@ -260171,7 +260742,7 @@ var WorkflowAgentCapacity = class _WorkflowAgentCapacity {
 };
 
 // ../engine/src/executor/wire-executor-lifecycle.ts
-var execFileAsync26 = promisify77(execFile32);
+var execFileAsync27 = promisify78(execFile33);
 async function releaseWorkspaceAcquireClaims(store, taskId) {
   for (const entry of activeSessionRegistry.entriesByKind("workspace-repo-acquire")) {
     if (entry.taskId === taskId) activeSessionRegistry.unregisterPath(entry.path);
@@ -260263,7 +260834,7 @@ function wireExecutorLifecycle(deps) {
         if (await canonicalizeWorktreePath(entry.worktreePath) === await canonicalizeWorktreePath(entry.repoRootDir)) throw new Error("Refusing to remove workspace repository root");
         activeSessionRegistry.unregisterPath(entry.worktreePath);
         await removeWorktree({ worktreePath: entry.worktreePath, rootDir: entry.repoRootDir, settings: await deps.store.getSettings(), taskId: task.id, reason: RemovalReason.ExecutorDispose, force: true });
-        await execFileAsync26("git", ["branch", "-D", entry.branch], { cwd: entry.repoRootDir, timeout: 12e4, maxBuffer: 10 * 1024 * 1024 });
+        await execFileAsync27("git", ["branch", "-D", entry.branch], { cwd: entry.repoRootDir, timeout: 12e4, maxBuffer: 10 * 1024 * 1024 });
         if (task.workspaceWorktrees) for (const repoRel of [entry.repoRel, ...entry.aliasRepoRels]) delete task.workspaceWorktrees[repoRel];
         removed.push(entry.repoRel);
       } catch (error2) {
@@ -262939,9 +263510,9 @@ var BUNDLED_CLI_ADAPTERS = Object.freeze([
 
 // ../engine/src/cli-agent/resume-coordinator.ts
 import { existsSync as existsSync83 } from "node:fs";
-import { execFile as execFile33 } from "node:child_process";
-import { promisify as promisify78 } from "node:util";
-var execFileAsync27 = promisify78(execFile33);
+import { execFile as execFile34 } from "node:child_process";
+import { promisify as promisify79 } from "node:util";
+var execFileAsync28 = promisify79(execFile34);
 var ORPHANED_LIVE_STATES = /* @__PURE__ */ new Set([
   "starting",
   "ready",
@@ -262952,7 +263523,7 @@ var DEFAULT_MAX_RESUME_ATTEMPTS = 2;
 var DEFAULT_RESUME_BACKOFF_BASE_MS = 1e3;
 async function defaultIsWorktreeDirty(worktreePath) {
   try {
-    const { stdout } = await execFileAsync27("git", ["status", "--porcelain"], {
+    const { stdout } = await execFileAsync28("git", ["status", "--porcelain"], {
       cwd: worktreePath
     });
     return stdout.trim().length > 0;
@@ -265301,7 +265872,7 @@ init_notifier();
 
 // ../engine/src/healing/stuck-task-detector.ts
 init_logger();
-import { createHash as createHash35 } from "node:crypto";
+import { createHash as createHash36 } from "node:crypto";
 var stuckLog = createLogger("stuck-detector");
 var LOOP_ACTIVITY_THRESHOLD = 60;
 var LOOP_IGNORED_STEP_MIN = 10;
@@ -265312,7 +265883,7 @@ var TOOL_DETAIL_HASH_HEX_LEN = 16;
 var NO_PROGRESS_CHURN_THRESHOLD = 25;
 var VERIFICATION_DEADLINE_GRACE_MS = 5e3;
 function hashToolDetail(detail) {
-  return createHash35("sha256").update(detail).digest("hex").slice(0, TOOL_DETAIL_HASH_HEX_LEN);
+  return createHash36("sha256").update(detail).digest("hex").slice(0, TOOL_DETAIL_HASH_HEX_LEN);
 }
 function buildToolFingerprint(toolName, toolDetail) {
   const name2 = toolName.trim().toLowerCase() || "tool";
@@ -268021,7 +268592,7 @@ var MissionAutopilot = class {
 // ../engine/src/missions/mission-execution-loop.ts
 init_src2();
 import { EventEmitter as EventEmitter26 } from "node:events";
-import { createHash as createHash36 } from "node:crypto";
+import { createHash as createHash37 } from "node:crypto";
 
 // ../engine/src/missions/mission-verification.ts
 init_sandbox();
@@ -268033,8 +268604,8 @@ import { promises as fs9 } from "node:fs";
 import os7 from "node:os";
 import path5 from "node:path";
 import { exec as exec58 } from "node:child_process";
-import { promisify as promisify79 } from "node:util";
-var execAsync54 = promisify79(exec58);
+import { promisify as promisify80 } from "node:util";
+var execAsync54 = promisify80(exec58);
 var verifyLog = createLogger("mission-verify");
 var GitCheckoutMaterializer = class {
   async materialize(rootDir, revision) {
@@ -268083,8 +268654,8 @@ init_fallback_model_observer();
 init_mcp_resolution();
 init_run_audit();
 import { exec as exec59 } from "node:child_process";
-import { promisify as promisify80 } from "node:util";
-var execAsync55 = promisify80(exec59);
+import { promisify as promisify81 } from "node:util";
+var execAsync55 = promisify81(exec59);
 function quoteShellArg8(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -268094,7 +268665,7 @@ var MAX_VALIDATION_RESPONSE_BYTES = 256 * 1024;
 var MAX_VALIDATION_JSON_CANDIDATES = 8;
 var VALIDATION_FAILURE_BUDGET_PER_FINGERPRINT = 3;
 function fingerprintMissionValidationInput(landedSha, provider, modelId, systemPrompt, userPrompt) {
-  return createHash36("sha256").update(Buffer.from(JSON.stringify(["mission-validation-input-v1", landedSha, provider, modelId, systemPrompt, userPrompt]), "utf8")).digest("hex");
+  return createHash37("sha256").update(Buffer.from(JSON.stringify(["mission-validation-input-v1", landedSha, provider, modelId, systemPrompt, userPrompt]), "utf8")).digest("hex");
 }
 var MissionExecutionLoop = class extends EventEmitter26 {
   running = false;
@@ -269802,7 +270373,7 @@ import { exec as exec60 } from "node:child_process";
 import { existsSync as existsSync84 } from "node:fs";
 import { readFile as readFile50, writeFile as writeFile29, rm as rm16 } from "node:fs/promises";
 import { join as join94 } from "node:path";
-import { promisify as promisify81 } from "node:util";
+import { promisify as promisify82 } from "node:util";
 
 // ../engine/src/triage-domain/triage-preflight.ts
 var BUG_FIX_REGEX = /typecheck error|compile error|broken|regression|lint error/i;
@@ -273020,7 +273591,7 @@ ${lines.join("\n")}` }],
           written,
           {
             cwd: this.rootDir,
-            exec: promisify81(exec60)
+            exec: promisify82(exec60)
           }
         ),
         new Promise((resolve52) => setTimeout(() => resolve52(null), 15e3))
@@ -273797,7 +274368,7 @@ function stableNotificationJson(value) {
   return `{${fields.join(",")}}`;
 }
 function buildCliAgentNotificationDedupeKey(input) {
-  const notificationFingerprint = createHash37("sha256").update(stableNotificationJson(input.info.notification ?? null)).digest("hex").slice(0, 16);
+  const notificationFingerprint = createHash38("sha256").update(stableNotificationJson(input.info.notification ?? null)).digest("hex").slice(0, 16);
   const waitingEpoch = input.session?.updatedAt ?? "unknown-waiting-epoch";
   return [
     "cli-agent",
@@ -278487,8 +279058,8 @@ init_src2();
 init_agent_user_comments();
 init_worktree_names();
 init_integration_branch();
-import { execFile as execFile38 } from "node:child_process";
-import { promisify as promisify86 } from "node:util";
+import { execFile as execFile39 } from "node:child_process";
+import { promisify as promisify87 } from "node:util";
 import { realpathSync as realpathSync15, readdirSync as readdirSync13 } from "node:fs";
 import { mkdtemp as mkdtemp5 } from "node:fs/promises";
 import { tmpdir as tmpdir12 } from "node:os";
@@ -278497,10 +279068,10 @@ init_workspace_base_branch();
 init_merger_ref_update_advance();
 
 // ../engine/src/merge/merger-ai-squash-gates.ts
-import { execFile as execFile34 } from "node:child_process";
-import { promisify as promisify82 } from "node:util";
+import { execFile as execFile35 } from "node:child_process";
+import { promisify as promisify83 } from "node:util";
 init_merger_file_scope();
-var execFileAsync28 = promisify82(execFile34);
+var execFileAsync29 = promisify83(execFile35);
 function resolveRepoDeclaredScopeTransform({ repoRel, repoKeys }) {
   return {
     transform(scope) {
@@ -278531,8 +279102,8 @@ async function enforceAiMergeSquashGates(params) {
     });
   } catch (error2) {
     if (!(error2 instanceof FileScopeViolationError)) throw error2;
-    await execFileAsync28("git", ["reset", "--hard", params.tipSha], { cwd: params.mergeRoot });
-    await execFileAsync28("git", ["clean", "-fd"], { cwd: params.mergeRoot });
+    await execFileAsync29("git", ["reset", "--hard", params.tipSha], { cwd: params.mergeRoot });
+    await execFileAsync29("git", ["clean", "-fd"], { cwd: params.mergeRoot });
     try {
       await params.store.updateTask(params.taskId, { aiMergeReviewReconciliation: null });
     } catch {
@@ -278721,10 +279292,10 @@ function resolveWorkspaceMergeReadiness(task, freshModifiedRepositories, netZero
 }
 
 // ../engine/src/merge/workspace-fence-ref.ts
-import { execFile as execFile35 } from "node:child_process";
-import { createHash as createHash38 } from "node:crypto";
-import { promisify as promisify83 } from "node:util";
-var execFileAsync29 = promisify83(execFile35);
+import { execFile as execFile36 } from "node:child_process";
+import { createHash as createHash39 } from "node:crypto";
+import { promisify as promisify84 } from "node:util";
+var execFileAsync30 = promisify84(execFile36);
 var WorkspaceFenceRefError = class extends Error {
   constructor(message, kind) {
     super(message);
@@ -278733,7 +279304,7 @@ var WorkspaceFenceRefError = class extends Error {
   }
 };
 async function git6(args, cwd) {
-  const { stdout } = await execFileAsync29("git", args, {
+  const { stdout } = await execFileAsync30("git", args, {
     cwd,
     encoding: "utf8",
     maxBuffer: 1024 * 1024
@@ -278746,7 +279317,7 @@ async function remoteRefSha(remote, ref, cwd) {
   return /^[0-9a-f]{40,64}$/i.test(sha ?? "") ? sha : void 0;
 }
 function workspaceLandFenceRef(repoRelPath) {
-  const slug2 = createHash38("sha256").update(repoRelPath).digest("hex").slice(0, 24);
+  const slug2 = createHash39("sha256").update(repoRelPath).digest("hex").slice(0, 24);
   return `refs/fusion/workspace-lease/${slug2}`;
 }
 function mergeDispatchFenceRef(taskId) {
@@ -278755,7 +279326,7 @@ function mergeDispatchFenceRef(taskId) {
 async function createFenceObject(cwd, handle2) {
   const tree = await git6(["hash-object", "-w", "-t", "tree", "/dev/null"], cwd);
   const message = `workspace lease ${handle2.leaseKey} ${handle2.owner.taskId} ${handle2.owner.nodeId} ${handle2.owner.incarnationId} ${handle2.fenceToken}`;
-  const { stdout } = await execFileAsync29("git", [
+  const { stdout } = await execFileAsync30("git", [
     "-c",
     "user.name=Fusion",
     "-c",
@@ -278890,9 +279461,9 @@ async function publishWorkspaceIntegrationRef(input) {
 init_push_after_merge_policy();
 
 // ../engine/src/merge/workspace-integration-target.ts
-import { execFile as execFile36 } from "node:child_process";
-import { promisify as promisify84 } from "node:util";
-var execFileAsync30 = promisify84(execFile36);
+import { execFile as execFile37 } from "node:child_process";
+import { promisify as promisify85 } from "node:util";
+var execFileAsync31 = promisify85(execFile37);
 var WorkspaceEnvironmentError = class extends Error {
   constructor(repository, resource, action, message) {
     super(message);
@@ -278912,7 +279483,7 @@ var WorkspaceIntegrationTargetError = class extends WorkspaceEnvironmentError {
   }
 };
 async function git7(args, cwd) {
-  const { stdout } = await execFileAsync30("git", args, { cwd, encoding: "utf8" });
+  const { stdout } = await execFileAsync31("git", args, { cwd, encoding: "utf8" });
   return stdout.trim();
 }
 async function resolveWorkspaceIntegrationTarget(input) {
@@ -278959,17 +279530,17 @@ init_worktree_paths();
 
 // ../engine/src/merge/merger-ai-worktree.ts
 init_active_session_registry();
-import { execFile as execFile37 } from "node:child_process";
+import { execFile as execFile38 } from "node:child_process";
 import { appendFileSync as appendFileSync2, existsSync as existsSync87, mkdirSync as mkdirSync11, readdirSync as readdirSync12, readFileSync as readFileSync28, realpathSync as realpathSync14, rmSync as rmSync8, statSync as statSync16 } from "node:fs";
 import { rm as rm17 } from "node:fs/promises";
 import { tmpdir as tmpdir11 } from "node:os";
 import { isAbsolute as isAbsolute27, join as join96, relative as relative23 } from "node:path";
-import { promisify as promisify85 } from "node:util";
+import { promisify as promisify86 } from "node:util";
 init_worktree_paths();
 init_worktree_removal_retry();
-var execFileAsync31 = promisify85(execFile37);
+var execFileAsync32 = promisify86(execFile38);
 async function git8(args, cwd, opts = {}) {
-  const { stdout } = await execFileAsync31("git", args, {
+  const { stdout } = await execFileAsync32("git", args, {
     cwd,
     encoding: "utf-8",
     timeout: opts.timeout ?? 12e4,
@@ -278998,14 +279569,7 @@ function ensureAiMergeRootIgnored(projectRootDir, settings) {
   if (!existsSync87(excludePath)) return;
   try {
     const current = readFileSync28(excludePath, "utf-8");
-    const legacyAiMergeRoot = resolveLegacyAiMergeRootPath(projectRootDir);
-    const legacyRelativeAiMergeRoot = relative23(projectRootDir, legacyAiMergeRoot);
-    const entries = [`${legacyRelativeAiMergeRoot.replaceAll("\\", "/")}/`];
-    const aiMergeRoot = resolveAiMergeRootPath(projectRootDir, settings);
-    const relativeAiMergeRoot = relative23(projectRootDir, aiMergeRoot);
-    if (relativeAiMergeRoot && !relativeAiMergeRoot.startsWith("..") && !isAbsolute27(relativeAiMergeRoot)) {
-      entries.push(`${relativeAiMergeRoot.replaceAll("\\", "/")}/`);
-    }
+    const entries = resolveAiMergeSearchRoots(projectRootDir, settings).map((root) => relative23(projectRootDir, root)).filter((root) => root && !root.startsWith("..") && !isAbsolute27(root)).map((root) => `${root.replaceAll("\\", "/")}/`);
     const missing = entries.filter((entry) => !current.split(/\r?\n/).includes(entry));
     if (missing.length > 0) {
       appendFileSync2(excludePath, `${current.endsWith("\n") ? "" : "\n"}${missing.join("\n")}
@@ -279021,7 +279585,7 @@ function resolveAiMergeRoot(projectRootDir, settings) {
   return root;
 }
 function getAiMergeTempSearchRoots(projectRootDir, settings) {
-  const roots = [resolveAiMergeRoot(projectRootDir, settings), resolveLegacyAiMergeRootPath(projectRootDir), tmpdir11()];
+  const roots = [resolveAiMergeRoot(projectRootDir, settings), ...resolveAiMergeSearchRoots(projectRootDir, settings), tmpdir11()];
   const testWorkerRoot = process.env.FUSION_TEST_WORKER_ROOT;
   if (testWorkerRoot) {
     try {
@@ -279074,7 +279638,7 @@ async function pruneExistingAiMergeWorktrees(taskId, projectRootDir, audit, log4
       let alreadyAbsent = false;
       try {
         cleanupAttempted = true;
-        await execFileAsync31("git", ["worktree", "remove", "--force", canonicalPath], {
+        await execFileAsync32("git", ["worktree", "remove", "--force", canonicalPath], {
           cwd: projectRootDir,
           timeout: 3e4
         });
@@ -279105,7 +279669,7 @@ async function pruneExistingAiMergeWorktrees(taskId, projectRootDir, audit, log4
   }
   if (cleanupAttempted) {
     try {
-      await execFileAsync31("git", ["worktree", "prune"], { cwd: projectRootDir, timeout: 3e4 });
+      await execFileAsync32("git", ["worktree", "prune"], { cwd: projectRootDir, timeout: 3e4 });
     } catch (err) {
       await log42(`AI merge pre-merge prune: git worktree prune failed: ${describeCleanupError(err)}`);
     }
@@ -279514,7 +280078,7 @@ function short(sha) {
 }
 
 // ../engine/src/merge/merger-ai.ts
-var execFileAsync32 = promisify86(execFile38);
+var execFileAsync33 = promisify87(execFile39);
 var aiMergeLog = createLogger("merger-ai");
 async function resolveNoOpFinalizeGateIds3(store, task) {
   const selection = store.getTaskWorkflowSelectionAsync ? await store.getTaskWorkflowSelectionAsync(task.id) : store.getTaskWorkflowSelection?.(task.id);
@@ -279540,7 +280104,7 @@ function writeTransientMergeStatus(store, taskId, signal, status) {
   return fence.write("lifecycle", () => store.updateTask(taskId, { status }).catch(() => void 0));
 }
 async function git9(args, cwd, opts = {}) {
-  const { stdout } = await execFileAsync32("git", args, {
+  const { stdout } = await execFileAsync33("git", args, {
     cwd,
     encoding: "utf-8",
     timeout: opts.timeout ?? 12e4,
@@ -279581,7 +280145,7 @@ function boundBlockingReviewReasons(reasons) {
 }
 function listAiMergeWorktreeCandidates(taskId, projectRootDir, settings) {
   const prefix = `fusion-ai-merge-${taskId.toLowerCase()}-`;
-  const roots = Array.from(/* @__PURE__ */ new Set([resolveAiMergeRoot(projectRootDir, settings), resolveLegacyAiMergeRootPath(projectRootDir), tmpdir12()]));
+  const roots = Array.from(/* @__PURE__ */ new Set([resolveAiMergeRoot(projectRootDir, settings), ...resolveAiMergeSearchRoots(projectRootDir, settings), tmpdir12()]));
   const testWorkerRoot = process.env.FUSION_TEST_WORKER_ROOT;
   if (testWorkerRoot) {
     try {
@@ -282166,8 +282730,8 @@ init_transient_merge_error_classifier();
 
 // ../engine/src/remote-access/remote-tunnel-service.ts
 init_logger();
-import { execFile as execFile40 } from "node:child_process";
-import { promisify as promisify88 } from "node:util";
+import { execFile as execFile41 } from "node:child_process";
+import { promisify as promisify89 } from "node:util";
 
 // ../engine/src/local-dashboard-port.ts
 var DEFAULT_DASHBOARD_PORT = 4040;
@@ -282180,8 +282744,8 @@ function getLocalDashboardPort() {
 init_src2();
 init_logger();
 import { EventEmitter as EventEmitter28 } from "node:events";
-import { exec as exec61, execFile as execFile39, spawn as spawn8 } from "node:child_process";
-import { promisify as promisify87 } from "node:util";
+import { exec as exec61, execFile as execFile40, spawn as spawn8 } from "node:child_process";
+import { promisify as promisify88 } from "node:util";
 
 // ../engine/src/remote-access/provider-adapters.ts
 import { accessSync, constants as fsConstants5 } from "node:fs";
@@ -282349,8 +282913,8 @@ var DEFAULT_MAX_LOG_ENTRIES = 400;
 var DEFAULT_STOP_TIMEOUT_MS2 = 5e3;
 var DEFAULT_RESTART_BASE_DELAY_MS = 1e3;
 var DEFAULT_RESTART_MAX_DELAY_MS = 3e4;
-var execFileAsync33 = promisify87(execFile39);
-var execAsync56 = promisify87(exec61);
+var execFileAsync34 = promisify88(execFile40);
+var execAsync56 = promisify88(exec61);
 function serveConfigScopes(config3) {
   const foreground = Object.values(config3.Foreground ?? {}).filter(
     (scope) => Boolean(scope)
@@ -282500,7 +283064,7 @@ var TunnelProcessManager = class extends EventEmitter28 {
       return null;
     }
     try {
-      const { stdout } = await execFileAsync33("tailscale", ["status", "--json"], { timeout: 3e3 });
+      const { stdout } = await execFileAsync34("tailscale", ["status", "--json"], { timeout: 3e3 });
       const data = JSON.parse(String(stdout));
       const dnsName = data.Self?.DNSName?.replace(/\.$/, "");
       if (!dnsName) {
@@ -282523,7 +283087,7 @@ var TunnelProcessManager = class extends EventEmitter28 {
     ];
     for (const resetCommand of resetCommands) {
       try {
-        await execFileAsync33(resetCommand.command, resetCommand.args, { timeout: 5e3 });
+        await execFileAsync34(resetCommand.command, resetCommand.args, { timeout: 5e3 });
         return;
       } catch {
       }
@@ -282629,7 +283193,7 @@ var TunnelProcessManager = class extends EventEmitter28 {
   async detectActiveFunnel() {
     let stdout = "";
     try {
-      const result = await execFileAsync33("tailscale", ["serve", "status", "--json"], { timeout: 5e3 });
+      const result = await execFileAsync34("tailscale", ["serve", "status", "--json"], { timeout: 5e3 });
       stdout = String(result.stdout ?? "");
     } catch (error2) {
       const failure = error2;
@@ -283045,7 +283609,7 @@ var TunnelProcessManager = class extends EventEmitter28 {
 };
 
 // ../engine/src/remote-access/remote-tunnel-service.ts
-var execFileAsync34 = promisify88(execFile40);
+var execFileAsync35 = promisify89(execFile41);
 var isRemoteActive = (ra) => ra?.activeProvider != null && (ra.providers[ra.activeProvider]?.enabled ?? false);
 var RemoteTunnelService = class {
   manager = new TunnelProcessManager();
@@ -283394,7 +283958,7 @@ var RemoteTunnelService = class {
   async checkTailscaleDaemonReady() {
     let stdout = "";
     try {
-      const result = await execFileAsync34("tailscale", ["status", "--json"], {
+      const result = await execFileAsync35("tailscale", ["status", "--json"], {
         timeout: 5e3,
         maxBuffer: 8 * 1024 * 1024
       });
@@ -283442,7 +284006,7 @@ var RemoteTunnelService = class {
   async checkExecutableAvailable(command) {
     const checker = process.platform === "win32" ? "where" : "which";
     try {
-      await execFileAsync34(checker, [command]);
+      await execFileAsync35(checker, [command]);
       return { available: true };
     } catch {
       return {
@@ -283625,7 +284189,7 @@ function emitMergeRequestShadowDequeueParityAudit(store, legacyTaskId, shadowTas
     metadata: { legacyTaskId, shadowTaskId, agree }
   }, { log: runtimeLog });
 }
-var execFileAsync35 = promisify89(execFile41);
+var execFileAsync36 = promisify90(execFile42);
 var MERGE_HANDOFF_GRACE_MS = 300;
 function isActiveMergeRequestState(state) {
   return state === "running" || state === "retrying";
@@ -283671,7 +284235,7 @@ async function verifyMergeConfirmedReachability(args) {
     return { reachable: true, skipped: "no-integration-branch" };
   }
   try {
-    await execFileAsync35("git", ["cat-file", "-e", `${commitSha}^{commit}`], {
+    await execFileAsync36("git", ["cat-file", "-e", `${commitSha}^{commit}`], {
       cwd,
       timeout: 1e4
     });
@@ -283680,7 +284244,7 @@ async function verifyMergeConfirmedReachability(args) {
     return { reachable: false, reason: "commit-missing", diagnostic };
   }
   try {
-    await execFileAsync35(
+    await execFileAsync36(
       "git",
       ["merge-base", "--is-ancestor", commitSha, `refs/heads/${integrationBranch}`],
       { cwd, timeout: 1e4 }
@@ -283756,6 +284320,7 @@ var ProjectEngine = class _ProjectEngine {
       }
     });
   }
+  staleContentRerouteAuditKeys = /* @__PURE__ */ new Set();
   runtime;
   started = false;
   specDriftReconciler;
@@ -285552,11 +286117,44 @@ ${detail}`);
       workspaceRootDir: this.config.workingDirectory,
       settings
     });
-    return getTaskMergeBlocker(task, {
+    const blocker = getTaskMergeBlocker(task, {
       reviewColumns: mergeGate.reviewColumns.size > 0 ? mergeGate.reviewColumns : /* @__PURE__ */ new Set(["in-review"]),
       requiredPreMergeStepIds: mergeGate.requiredPreMergeStepIds,
       mergeContent
     });
+    if (blocker === "task has a pre-merge approval recorded against different content" && mergeContent.kind === "singular") {
+      const reroute = await rerouteSingularStaleContentToReview(store, task, {
+        requiredPreMergeStepIds: mergeGate.requiredPreMergeStepIds,
+        mergeContent
+      }).catch(() => ({
+        rerouted: false,
+        reason: "no-progress",
+        nodeId: void 0,
+        workflowStepId: void 0
+      }));
+      if (reroute.rerouted) {
+        await store.logEntry(task.id, `[pre-merge] Code Review re-entry is owned by the workflow graph after stale content evidence was refused.`);
+      }
+      const auditKey = `${task.id}:${reroute.reason}`;
+      if (!this.staleContentRerouteAuditKeys.has(auditKey)) {
+        this.staleContentRerouteAuditKeys.add(auditKey);
+        await emitBoundedRunAudit2(store, {
+          taskId: task.id,
+          agentId: "merge-gate",
+          runId: `${task.id}:merge-gate`,
+          domain: "database",
+          mutationType: "task:merge-stale-content-review-rerouted",
+          target: task.id,
+          metadata: {
+            taskId: task.id,
+            nodeId: reroute.nodeId,
+            workflowStepId: reroute.workflowStepId,
+            reason: reroute.reason
+          }
+        });
+      }
+    }
+    return blocker;
   }
   /**
    * Remove and return the highest-priority taskId from the merge queue.
@@ -286402,7 +287000,7 @@ ${detail}`);
               }
               const checklist = planConfirmedMergeChecklistReconciliation(task);
               if (checklist.skippedStepIndexes.length > 0 || checklist.reconciledWorkflowStepIds.length > 0) {
-                const steps = task.steps.map((step, index2) => checklist.skippedStepIndexes.includes(index2) ? { ...step, status: "skipped" } : step);
+                const steps = (task.steps ?? []).map((step, index2) => checklist.skippedStepIndexes.includes(index2) ? { ...step, status: "skipped" } : step);
                 const workflowStepResults = (task.workflowStepResults ?? []).map((result) => checklist.reconciledWorkflowStepIds.includes(result.workflowStepId) ? { ...result, status: "skipped" } : result);
                 await store.updateTask(taskId, { steps, workflowStepResults });
                 task.steps = steps;