@runfusion/fusion 0.78.0-beta.2 → 0.78.0-beta.3

package/dist/bin.js

@@ -1956,10 +1956,11 @@ function toSnapshot(result2) {
   const { priorAttempts: _drop, ...rest } = result2;
   return rest;
 }
-function archiveTerminalWorkflowStepFailures(results, archivedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  if (!results?.some(isTerminalFailure)) return results;
+function archiveTerminalWorkflowStepFailures(results, archivedAt = (/* @__PURE__ */ new Date()).toISOString(), options = {}) {
+  const inScope = (result2) => isTerminalFailure(result2) && (!options.workflowStepIds || options.workflowStepIds.has(result2.workflowStepId));
+  if (!results?.some(inScope)) return results;
   return results.map((result2) => {
-    if (!isTerminalFailure(result2)) return result2;
+    if (!inScope(result2)) return result2;
     const snapshot = toSnapshot(result2);
     const priorAttempts = [snapshot, ...result2.priorAttempts ?? []].slice(0, MAX_WORKFLOW_STEP_PRIOR_ATTEMPTS);
     const {
@@ -2135,6 +2136,26 @@ function isAuditedOperatorBypass(result2) {
     actor && !AUTOMATED_BYPASS_ACTORS.has(actor) && result2.bypassedAt?.trim() && result2.bypassReason?.trim()
   );
 }
+function resolveCollateralArchivedReviewGate(result2, options) {
+  const archivedFrom = result2.remediationArchivedFromStatus;
+  if ((result2.phase ?? "pre-merge") !== "pre-merge" || result2.status !== "skipped" || result2.remediationArchivedAt == null || result2.bypassedBy !== void 0 || archivedFrom !== "failed" && archivedFrom !== "advisory_failure" || options.remediationGateIds.has(result2.workflowStepId)) {
+    return void 0;
+  }
+  const {
+    remediationArchivedAt: _archivedAt,
+    remediationArchivedFromStatus: _archivedFrom,
+    ...rest
+  } = result2;
+  return {
+    restored: {
+      ...rest,
+      status: archivedFrom,
+      output: COLLATERAL_ARCHIVED_REVIEW_GATE_DIAGNOSTIC,
+      notes: COLLATERAL_ARCHIVED_REVIEW_GATE_DIAGNOSTIC
+    },
+    reason: COLLATERAL_ARCHIVED_REVIEW_GATE_DIAGNOSTIC
+  };
+}
 function resolveUnprovenReviewApproval(result2, options) {
   if ((result2.phase ?? "pre-merge") !== "pre-merge" || !requiresContentReviewProof(result2.workflowStepId, result2) || options.workspace || result2.status !== "passed" || result2.verdict !== "APPROVE" && result2.verdict !== "APPROVE_WITH_NOTES" || result2.reviewInputFingerprint !== void 0 || result2.bypassedBy !== void 0 || result2.remediationArchivedAt != null) {
     return void 0;
@@ -2166,9 +2187,10 @@ function evaluateStep(workflowStepId, results, task, descriptor) {
     const isPlanDomain = workflowStepId === PLAN_REVIEW_GROUP_ID || result2.reviewKind === "plan";
     const notRunApproves = isWorkflowStepNotRun(result2) && !requiresAuthoredVerdict && !isPlanDomain;
     const approved = result2.status === "passed" && (requiresAuthoredVerdict ? approvedVerdict : result2.verdict === void 0 || approvedVerdict) || result2.status === "skipped" && !!result2.bypassedBy || notRunApproves;
-    if (!approved || !!result2.remediationArchivedAt) return { workflowStepId, state: "not-approved" };
+    const auditedOperatorWaiver = isAuditedOperatorBypass(result2) && descriptor?.kind !== "workspace";
+    if (!approved || result2.remediationArchivedAt != null && !auditedOperatorWaiver) return { workflowStepId, state: "not-approved" };
     if (result2.reviewKind === "plan") return { workflowStepId, state: "approved" };
-    if (isAuditedOperatorBypass(result2) && descriptor?.kind !== "workspace") {
+    if (auditedOperatorWaiver) {
       return { workflowStepId, state: "approved" };
     }
     const bindsContent = requiresExplicitVerdict || result2.reviewInputFingerprint !== void 0;
@@ -2201,7 +2223,7 @@ function evaluateStep(workflowStepId, results, task, descriptor) {
   if (stale2.length) return { workflowStepId, state: "stale-content", repositories: stale2 };
   return { workflowStepId, state: "approved" };
 }
-var AUTOMATED_BYPASS_ACTORS, UNPROVEN_REVIEW_APPROVAL_DIAGNOSTIC;
+var AUTOMATED_BYPASS_ACTORS, UNPROVEN_REVIEW_APPROVAL_DIAGNOSTIC, COLLATERAL_ARCHIVED_REVIEW_GATE_DIAGNOSTIC;
 var init_pre_merge_approval = __esm({
   "../core/src/merge/pre-merge-approval.ts"() {
     "use strict";
@@ -2210,6 +2232,7 @@ var init_pre_merge_approval = __esm({
     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.";
+    COLLATERAL_ARCHIVED_REVIEW_GATE_DIAGNOSTIC = "Gate archived as collateral of another gate's remediation and restored to its recoverable failed state by self-healing. No reviewer verdict was fabricated; re-run or bypass this gate to clear the merge door.";
   }
 });
 
@@ -2318,6 +2341,9 @@ function hasNonTerminalSteps(task) {
 function isPreMergeStepsNotRunBlocker(blocker) {
   return blocker === PRE_MERGE_STEPS_NOT_RUN_BLOCKER;
 }
+function isStaleContentApprovalBlocker(blocker) {
+  return typeof blocker === "string" && blocker.trim().endsWith(STALE_CONTENT_APPROVAL_BLOCKER);
+}
 function getTaskMergeBlocker(task, options = {}) {
   if (!options.skipColumnIdentityCheck) {
     const reviewColumns = options.reviewColumns?.size ? options.reviewColumns : void 0;
@@ -2339,8 +2365,10 @@ function getTaskMergeBlocker(task, options = {}) {
   }
   const approval = evaluatePreMergeApprovals(task, options).find((candidate) => candidate.state !== "approved");
   if (approval?.state === "missing") return PRE_MERGE_STEPS_NOT_RUN_BLOCKER;
-  if (approval?.state === "not-approved") return "task has enabled pre-merge workflow steps without a current approval";
-  if (approval?.state === "stale-content") return "task has a pre-merge approval recorded against different content";
+  if (approval?.state === "not-approved") {
+    return `task has enabled pre-merge workflow steps without a current approval (gate '${approval.workflowStepId}')`;
+  }
+  if (approval?.state === "stale-content") return STALE_CONTENT_APPROVAL_BLOCKER;
   if (approval?.state === "unprovable-content") return "task has no provable approval for the content being merged";
   if (task.workflowStepResults?.some((result2) => {
     const phase = result2.phase || "pre-merge";
@@ -2357,11 +2385,14 @@ function getTaskMergeBlocker(task, options = {}) {
   return void 0;
 }
 function getLatestFailedPreMergeReviewStep(task) {
-  return (task.workflowStepResults ?? []).filter((result2) => (result2.phase || "pre-merge") === "pre-merge" && result2.status === "failed").sort((a, b3) => {
+  const results = task.workflowStepResults ?? [];
+  const recentFirst = (a, b3) => {
     const aTs = Date.parse(a.completedAt || a.startedAt || "");
     const bTs = Date.parse(b3.completedAt || b3.startedAt || "");
     return (Number.isFinite(bTs) ? bTs : 0) - (Number.isFinite(aTs) ? aTs : 0);
-  })[0];
+  };
+  const isPreMerge = (result2) => (result2.phase || "pre-merge") === "pre-merge";
+  return results.filter((result2) => isPreMerge(result2) && result2.status === "failed").sort(recentFirst)[0] ?? results.filter((result2) => isPreMerge(result2) && isArchivedRemediationCarrier(result2) && (result2.remediationArchivedFromStatus === "failed" || result2.remediationArchivedFromStatus === "advisory_failure") && !result2.bypassedBy && !result2.supersededAt).sort(recentFirst)[0];
 }
 function clearMergeConfirmedTransientStatus(status) {
   return status !== void 0 && MERGE_CONFIRMED_TRANSIENT_STATUSES.has(status) ? void 0 : status;
@@ -2445,13 +2476,14 @@ function findPendingPreMergeStep(task) {
     (a, b3) => new Date(b3.startedAt ?? 0).getTime() - new Date(a.startedAt ?? 0).getTime()
   )[0];
 }
-var FUSION_SIBLING_BRANCH_RE, AWAITING_APPROVAL_PAUSE_REASON, HARD_BLOCKING_TASK_STATUSES, SCHEDULER_TRANSIENT_STATUSES, BLOCKING_TASK_STATUSES, NON_TERMINAL_STEP_STATUSES, NON_TERMINAL_WORKFLOW_STATUSES, PRE_MERGE_STEPS_NOT_RUN_BLOCKER, PreMergeStepsNotRunError, REVIEW_ELIGIBLE_SENTINEL_COLUMN, MERGE_CONFIRMED_TRANSIENT_STATUSES;
+var FUSION_SIBLING_BRANCH_RE, AWAITING_APPROVAL_PAUSE_REASON, HARD_BLOCKING_TASK_STATUSES, SCHEDULER_TRANSIENT_STATUSES, BLOCKING_TASK_STATUSES, NON_TERMINAL_STEP_STATUSES, NON_TERMINAL_WORKFLOW_STATUSES, PRE_MERGE_STEPS_NOT_RUN_BLOCKER, STALE_CONTENT_APPROVAL_BLOCKER, PreMergeStepsNotRunError, REVIEW_ELIGIBLE_SENTINEL_COLUMN, MERGE_CONFIRMED_TRANSIENT_STATUSES;
 var init_task_merge = __esm({
   "../core/src/merge/task-merge.ts"() {
     "use strict";
     init_branch_group_completion();
     init_task_helpers();
     init_pre_merge_approval();
+    init_workflow_step_results();
     FUSION_SIBLING_BRANCH_RE = /^fusion\/fn-/i;
     AWAITING_APPROVAL_PAUSE_REASON = "awaiting-approval";
     HARD_BLOCKING_TASK_STATUSES = /* @__PURE__ */ new Set([
@@ -2495,6 +2527,7 @@ var init_task_merge = __esm({
       "pending"
     ]);
     PRE_MERGE_STEPS_NOT_RUN_BLOCKER = "task has enabled pre-merge workflow steps that never ran";
+    STALE_CONTENT_APPROVAL_BLOCKER = "task has a pre-merge approval recorded against different content";
     PreMergeStepsNotRunError = class extends Error {
       code = "pre-merge-steps-not-run";
       taskId;
@@ -6474,8 +6507,9 @@ function renderValidationCause(diagnostics8) {
 }
 function featureValidationRepairEligibility(feature) {
   const repairableLoop = feature.loopState === "blocked" || feature.loopState === "needs_fix";
+  const unvalidatedPassedMarker = feature.lastValidatorStatus === "passed" && !feature.lastValidatorRunId;
   return {
-    clear: repairableLoop || feature.status === "blocked",
+    clear: repairableLoop || feature.status === "blocked" || unvalidatedPassedMarker,
     reRun: repairableLoop || feature.status === "blocked" && (feature.loopState === void 0 || feature.loopState === "idle")
   };
 }
@@ -6539,7 +6573,8 @@ var init_mission_types = __esm({
       implementing: [],
       validating: [],
       needs_fix: ["idle", "implementing"],
-      passed: [],
+      /* FNXC:Missions 2026-09-05-22:07: Explicit repair may return a fabricated unvalidated passed marker to idle (issue #3574). */
+      passed: ["idle"],
       blocked: ["idle", "implementing"]
     };
     VALIDATOR_RUN_STATUSES = ["running", "passed", "failed", "blocked", "error"];
@@ -13646,7 +13681,7 @@ function isBlockingFinding(finding, threshold) {
   if (!finding.severity) return true;
   return SEVERITY_RANK[finding.severity] >= SEVERITY_RANK[threshold];
 }
-function applyReviewSeverityGate({ verdict, findings, threshold }) {
+function applyReviewSeverityGate({ verdict, findings, threshold, findingsUnreadable }) {
   const all = findings ?? [];
   const open7 = all.filter(isActionableReviewFinding);
   const resolved = all.filter((finding) => !isActionableReviewFinding(finding));
@@ -13654,6 +13689,7 @@ function applyReviewSeverityGate({ verdict, findings, threshold }) {
   const advisory = open7.filter((finding) => !isBlockingFinding(finding, threshold));
   if (verdict !== "REVISE") return { verdict, downgraded: false, blocking, advisory, resolved };
   if (blocking.length > 0) return { verdict, downgraded: false, blocking, advisory, resolved };
+  if (findingsUnreadable) return { verdict, downgraded: false, blocking, advisory, resolved };
   return { verdict: "APPROVE_WITH_NOTES", downgraded: true, blocking, advisory, resolved };
 }
 function formatFindingsByPriority(findings) {
@@ -18395,6 +18431,18 @@ function detectWorkflowDrift(ir2, pin) {
 function defaultCodingWorkflowIr() {
   return resolveDefaultWorkflowIr();
 }
+async function prefetchWorkflowSelections(store, taskIds, cache8) {
+  const missingIds = [...new Set(taskIds)].filter((id) => !cache8.has(id));
+  if (missingIds.length === 0) return { batched: 0, singles: 0 };
+  if (!store.getTaskWorkflowSelectionsAsync) return { batched: 0, singles: missingIds.length };
+  try {
+    const selections = await store.getTaskWorkflowSelectionsAsync(missingIds);
+    for (const id of missingIds) cache8.set(id, selections.get(id));
+    return { batched: 1, singles: 0 };
+  } catch {
+    return { batched: 0, singles: missingIds.length };
+  }
+}
 function resolveSeamPromptFromIr(ir2, seam) {
   for (const node of ir2.nodes) {
     if (node.kind !== "prompt") continue;
@@ -18613,9 +18661,9 @@ function resolveLifecycleColumns(ir2) {
     archived: first(LIFECYCLE_ROLE_FLAGS.archived)
   };
 }
-async function resolveTaskLifecycleColumns(store, taskId, cache8) {
+async function resolveTaskLifecycleColumns(store, taskId, cache8, selectionCache) {
   try {
-    const ir2 = await resolveWorkflowIrForTask(store, taskId, cache8);
+    const ir2 = await resolveWorkflowIrForTask(store, taskId, cache8, selectionCache);
     return resolveLifecycleColumns(ir2);
   } catch {
     return void 0;
@@ -30611,18 +30659,33 @@ function isValidPluginParserId(id) {
   const seg = /^[a-z0-9-]+$/;
   return seg.test(parts[1]) && seg.test(parts[2]);
 }
-function parseStepHeadings(content) {
-  const steps = [];
+function matchStepHeadings(content) {
   const stepRegex = /^###\s+Step\s+\d+[^:]*:\s*(.+)$/gm;
-  const annotatedRegex = /^###\s+Step\s+\d+\s*\(depends:\s*([^)]*)\)\s*:\s*([^\n]+)$/;
   const matches = [];
   let match2;
   while ((match2 = stepRegex.exec(content)) !== null) {
     const heading = /^###\s+Step\s+(\d+)/.exec(match2[0]);
-    if (heading) {
-      matches.push({ full: match2[0], name: match2[1], headingNumber: Number(heading[1]) });
-    }
+    if (!heading) continue;
+    const index3 = match2.index;
+    const newline = content.indexOf("\n", index3);
+    matches.push({
+      headingNumber: Number(heading[1]),
+      index: index3,
+      headingLineEnd: newline === -1 ? content.length : newline,
+      match: match2[0]
+    });
   }
+  return matches;
+}
+function parseStepHeadings(content) {
+  const steps = [];
+  const annotatedRegex = /^###\s+Step\s+\d+\s*\(depends:\s*([^)]*)\)\s*:\s*([^\n]+)$/;
+  const matches = matchStepHeadings(content).map((entry) => ({
+    full: entry.match,
+    name: /^###\s+Step\s+\d+[^:]*:\s*(.+)$/m.exec(entry.match)?.[1] ?? "",
+    headingNumber: entry.headingNumber
+  }));
+  let match2;
   const offset = resolveAuthoredStepHeadingOffset(matches.map((entry) => entry.headingNumber));
   for (const { full, name: legacyName } of matches) {
     if (!full.includes("(depends:")) {
@@ -61919,12 +61982,12 @@ async function listGlobalConfigurationRevisions(layer, configKind, configTarget,
   });
 }
 async function listConfigurationRevisionsPage(handle2, params) {
-  const clampInteger2 = (value2, fallback2, minimum, maximum = Number.MAX_SAFE_INTEGER) => {
+  const clampInteger3 = (value2, fallback2, minimum, maximum = Number.MAX_SAFE_INTEGER) => {
     const integer3 = typeof value2 === "number" && Number.isFinite(value2) ? Math.trunc(value2) : fallback2;
     return Math.min(maximum, Math.max(minimum, integer3));
   };
-  const limit2 = clampInteger2(params.limit, 100, 1, 500);
-  const offset = clampInteger2(params.offset, 0, 0);
+  const limit2 = clampInteger3(params.limit, 100, 1, 500);
+  const offset = clampInteger3(params.offset, 0, 0);
   const rows = await handle2.select().from(schema_exports.project.configurationRevisions).where(and(
     eq(schema_exports.project.configurationRevisions.projectId, params.projectId),
     eq(schema_exports.project.configurationRevisions.configKind, params.configKind),
@@ -75219,8 +75282,8 @@ function appendAgentLogEntriesSync(taskDir, entries2) {
   if (entries2.length === 0) return [];
   const filePath = getAgentLogFilePath(taskDir);
   mkdirSync5(dirname15(filePath), { recursive: true });
-  const startingLineNo = countLineNumbers(filePath);
-  const payload = entries2.map((entry) => serializeEntry(entry)).join("");
+  const { lineCount: startingLineNo, endsWithNewline } = inspectAgentLogTail(filePath);
+  const payload = `${startingLineNo > 0 && !endsWithNewline ? "\n" : ""}${entries2.map((entry) => serializeEntry(entry)).join("")}`;
   appendFileSync(filePath, payload, "utf8");
   return entries2.map((entry, index3) => materializeEntry(entry, startingLineNo + index3 + 1));
 }
@@ -75256,6 +75319,7 @@ function readAllAgentLogEntries(taskDir, options = {}) {
   }
   const lines = content.split("\n");
   const entries2 = [];
+  const skippedLines = [];
   for (let index3 = 0; index3 < lines.length; index3 += 1) {
     const rawLine = lines[index3];
     if (!rawLine) continue;
@@ -75277,9 +75341,18 @@ function readAllAgentLogEntries(taskDir, options = {}) {
       }
       entries2.push(entry);
     } catch (error3) {
-      log7.warn(`Skipping malformed JSONL line ${lineNo} in ${filePath}`, error3);
+      skippedLines.push({
+        lineNo,
+        message: error3 instanceof Error ? error3.message : String(error3)
+      });
     }
   }
+  const firstSkipped = skippedLines[0];
+  if (firstSkipped) {
+    log7.warn(
+      `Skipped ${skippedLines.length} malformed JSONL line(s) in ${filePath}; first line ${firstSkipped.lineNo}: ${firstSkipped.message}`
+    );
+  }
   return entries2;
 }
 function normalizeTimingMs(value2) {
@@ -75322,16 +75395,19 @@ function materializeEntry(entry, lineNo) {
     sourceRef: buildAgentLogSourceRef(entry.taskId, lineNo)
   };
 }
-function countLineNumbers(filePath) {
+function inspectAgentLogTail(filePath) {
   if (!existsSync17(filePath)) {
-    return 0;
+    return { lineCount: 0, endsWithNewline: true };
   }
   const content = readFileSync8(filePath, "utf8");
   if (content.length === 0) {
-    return 0;
+    return { lineCount: 0, endsWithNewline: true };
   }
   const lines = content.split("\n");
-  return lines.at(-1) === "" ? lines.length - 1 : lines.length;
+  return {
+    lineCount: lines.at(-1) === "" ? lines.length - 1 : lines.length,
+    endsWithNewline: content.endsWith("\n")
+  };
 }
 function pruneAgentLogFiles(tasksDir, retentionDays, scanTaskIds) {
   if (!Number.isFinite(retentionDays) || retentionDays <= 0 || !existsSync17(tasksDir)) {
@@ -79121,6 +79197,10 @@ ${reasonText}` : void 0)].filter(Boolean).join("\n\n") || void 0;
        * FNXC:Missions 2026-07-11-12:35:
        * A generated fix can also supersede itself once its own validator/loop evidence has passed.
        * Reconciliation treats that as terminal evidence so a completed fix does not stay active only because its ancestor previously failed.
+       *
+       * FNXC:Missions 2026-09-05-22:07:
+       * Superseding a generated fix means it is no longer needed, not that it passed validation.
+       * Never stamp unearned validator evidence because that re-arms the reconciler's own trigger (issue #3574).
        */
       reconcileSupersededGeneratedFixFeatures(sliceId) {
         const features = this.listFeatures(sliceId);
@@ -79145,7 +79225,42 @@ ${reasonText}` : void 0)].filter(Boolean).join("\n\n") || void 0;
           ancestorPassedMemo.set(feature.id, passed);
           return passed;
         };
-        const supersededFeatureIds = features.filter((feature) => feature.generatedFromFeatureId && (featureHasPassed(feature) || hasPassedAncestor(feature))).filter((feature) => feature.status !== "done" || feature.loopState !== "passed" || feature.lastValidatorStatus !== "passed" || feature.taskId).map((feature) => feature.id);
+        const isFabricatedMarker = (feature) => Boolean(
+          (feature.generatedFromFeatureId || feature.generatedFromRunId) && feature.lastValidatorStatus === "passed" && !feature.lastValidatorRunId && !feature.taskId && feature.status === "done" && !hasPassedAncestor(feature)
+        );
+        const repairedFeatureIds = features.filter(isFabricatedMarker).map((feature) => feature.id);
+        const repairedIds = new Set(repairedFeatureIds);
+        const supersededFeatureIds = features.filter((feature) => !repairedIds.has(feature.id)).filter((feature) => feature.generatedFromFeatureId && (featureHasPassed(feature) || hasPassedAncestor(feature))).filter((feature) => feature.status !== "done" || feature.loopState !== "passed" || feature.taskId).map((feature) => feature.id);
+        if (repairedFeatureIds.length > 0) {
+          this.db.transaction(() => {
+            const hasCurrentPassedAncestor = (feature, seen = /* @__PURE__ */ new Set()) => {
+              const sourceFeatureId = feature.generatedFromFeatureId;
+              if (!sourceFeatureId || seen.has(sourceFeatureId)) return false;
+              seen.add(sourceFeatureId);
+              const sourceFeature = this.getFeature(sourceFeatureId);
+              return featureHasPassed(sourceFeature) || (sourceFeature ? hasCurrentPassedAncestor(sourceFeature, seen) : false);
+            };
+            const isCurrentFabricatedMarker = (feature) => Boolean(
+              (feature.generatedFromFeatureId || feature.generatedFromRunId) && feature.lastValidatorStatus === "passed" && !feature.lastValidatorRunId && !feature.taskId && feature.status === "done" && !hasCurrentPassedAncestor(feature)
+            );
+            for (const featureId of repairedFeatureIds) {
+              const feature = this.getFeature(featureId);
+              if (!feature || !isCurrentFabricatedMarker(feature)) continue;
+              this.updateFeature(featureId, { status: "defined", taskId: void 0, loopState: "idle", lastValidatorStatus: void 0 });
+              const slice = this.getSlice(feature.sliceId);
+              const milestone = slice ? this.getMilestone(slice.milestoneId) : void 0;
+              if (milestone) {
+                this.logMissionEvent(milestone.missionId, "feature_status_changed", `Feature status changed from ${feature.status} to defined`, {
+                  featureId,
+                  field: "status",
+                  from: feature.status,
+                  to: "defined",
+                  source: "superseded-fix-marker-repair"
+                });
+              }
+            }
+          });
+        }
         if (supersededFeatureIds.length > 0) {
           this.db.transaction(() => {
             for (const featureId of supersededFeatureIds) {
@@ -79154,8 +79269,7 @@ ${reasonText}` : void 0)].filter(Boolean).join("\n\n") || void 0;
               this.updateFeature(featureId, {
                 status: "done",
                 taskId: void 0,
-                loopState: "passed",
-                lastValidatorStatus: "passed"
+                loopState: "passed"
               });
               if (feature.taskId) {
                 this.db.prepare('UPDATE tasks SET missionId = NULL, sliceId = NULL WHERE id = ? AND "deletedAt" IS NULL').run(feature.taskId);
@@ -79165,7 +79279,9 @@ ${reasonText}` : void 0)].filter(Boolean).join("\n\n") || void 0;
         }
         return {
           supersededCount: supersededFeatureIds.length,
-          featureIds: supersededFeatureIds
+          featureIds: supersededFeatureIds,
+          repairedCount: repairedFeatureIds.length,
+          repairedFeatureIds
         };
       }
       /**
@@ -82509,10 +82625,12 @@ var init_async_mission_store = __esm({
             throw new RepairNotEligibleError(featureId, options.action);
           }
           const now = (/* @__PURE__ */ new Date()).toISOString();
+          const hasUnvalidatedMarker = options.action === "clear" && feature.lastValidatorStatus === "passed" && !feature.lastValidatorRunId;
+          const appliesUnvalidatedMarker = hasUnvalidatedMarker && Boolean(feature.generatedFromFeatureId || feature.generatedFromRunId) && !feature.taskId && feature.status === "done";
           const priorLoopState = feature.loopState;
           const priorStatus = feature.status;
           let groundTruthMetadata = {};
-          if (options.action === "clear" && feature.status === "blocked") {
+          if (options.action === "clear" && (feature.status === "blocked" || appliesUnvalidatedMarker)) {
             const fence = options.groundTruth;
             if (!fence || fence.featureId !== featureId || fence.taskId !== (feature.taskId ?? null)) {
               throw new RepairGroundTruthStaleError(featureId);
@@ -82542,14 +82660,14 @@ var init_async_mission_store = __esm({
           let updated;
           let run2;
           if (options.action === "clear") {
-            const currentLoop = feature.loopState;
-            const appliesLoop = currentLoop === "blocked" || currentLoop === "needs_fix";
+            const currentLoop = feature.loopState ?? "idle";
+            const appliesLoop = currentLoop === "blocked" || currentLoop === "needs_fix" || appliesUnvalidatedMarker;
             const nextLoop = appliesLoop ? options.resolvedLoopState ?? "idle" : currentLoop;
             if (appliesLoop && !FEATURE_LOOP_REPAIR_TRANSITIONS[currentLoop].includes(nextLoop)) {
               throw new Error(`Invalid validation repair transition from '${currentLoop}' to '${nextLoop}'`);
             }
-            const appliesStatus = feature.status === "blocked";
-            const nextStatus = appliesStatus ? options.resolvedStatus : feature.status;
+            const appliesStatus = feature.status === "blocked" || appliesUnvalidatedMarker;
+            const nextStatus = appliesUnvalidatedMarker ? "defined" : appliesStatus ? options.resolvedStatus : feature.status;
             if (appliesStatus && (nextStatus !== "in-progress" && nextStatus !== "triaged" && nextStatus !== "defined")) {
               throw new Error("Validation repair requires resolvedStatus of in-progress, triaged, or defined");
             }
@@ -82561,13 +82679,13 @@ var init_async_mission_store = __esm({
               const matchesLane = nextStatus === "in-progress" && fence.taskLiveness === "live" && fence.laneRole === "wip" || nextStatus === "triaged" && fence.taskLiveness === "live" && fence.laneRole === "planner" || nextStatus === "defined" && fence.taskLiveness === "absent" && fence.laneRole === "none";
               if (!matchesLane) throw new RepairGroundTruthStaleError(featureId);
             }
-            if (!appliesLoop && !appliesStatus) throw new RepairNotEligibleError(featureId, options.action);
+            if (!appliesLoop && !appliesStatus && !hasUnvalidatedMarker) throw new RepairNotEligibleError(featureId, options.action);
             updated = {
               ...feature,
               loopState: nextLoop,
               status: nextStatus,
               implementationAttemptCount: 0,
-              ...feature.lastValidatorStatus === "blocked" || feature.lastValidatorStatus === "failed" ? { lastValidatorStatus: void 0 } : {},
+              ...feature.lastValidatorStatus === "blocked" || feature.lastValidatorStatus === "failed" || hasUnvalidatedMarker ? { lastValidatorStatus: void 0 } : {},
               updatedAt: now
             };
             await updateFeature(tx, updated);
@@ -83035,10 +83153,60 @@ ${reasonText}` : void 0)].filter(Boolean).join("\n\n") || void 0,
           const source = byId.get(sourceId);
           return passed(source) || (source ? hasPassedAncestor(source, seen) : false);
         };
+        const isFabricatedMarker = (feature) => Boolean(
+          (feature.generatedFromFeatureId || feature.generatedFromRunId) && feature.lastValidatorStatus === "passed" && !feature.lastValidatorRunId && !feature.taskId && feature.status === "done" && !hasPassedAncestor(feature)
+        );
+        const repairIds = new Set(features.filter(isFabricatedMarker).map((feature) => feature.id));
         const ids = [];
         for (const feature of features) {
-          if (!feature.generatedFromFeatureId || !(passed(feature) || hasPassedAncestor(feature))) continue;
-          if (feature.status !== "done" || feature.loopState !== "passed" || feature.lastValidatorStatus !== "passed" || feature.taskId) ids.push(feature.id);
+          if (repairIds.has(feature.id) || !feature.generatedFromFeatureId || !(passed(feature) || hasPassedAncestor(feature))) continue;
+          if (feature.status !== "done" || feature.loopState !== "passed" || feature.taskId) ids.push(feature.id);
+        }
+        const repairedFeatureIds = [];
+        if (repairIds.size > 0) {
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          const repaired = await this.layer.transactionImmediate(async (tx) => {
+            const locked = await tx.select({ id: project_exports.missionFeatures.id }).from(project_exports.missionFeatures).where(inArray(project_exports.missionFeatures.id, [...repairIds])).for("update");
+            const preImages = locked.length > 0 ? await listFeaturesByIds(tx, locked.map((row) => row.id)) : [];
+            const currentById = new Map(preImages.map((feature) => [feature.id, feature]));
+            let missingAncestorIds = [...new Set(preImages.map((feature) => feature.generatedFromFeatureId).filter((id) => Boolean(id) && !currentById.has(id)))];
+            while (missingAncestorIds.length > 0) {
+              const lockedAncestors = await tx.select({ id: project_exports.missionFeatures.id }).from(project_exports.missionFeatures).where(inArray(project_exports.missionFeatures.id, missingAncestorIds)).for("update");
+              const ancestors = lockedAncestors.length > 0 ? await listFeaturesByIds(tx, lockedAncestors.map((row) => row.id)) : [];
+              for (const ancestor of ancestors) currentById.set(ancestor.id, ancestor);
+              missingAncestorIds = [...new Set(ancestors.map((ancestor) => ancestor.generatedFromFeatureId).filter((id) => Boolean(id) && !currentById.has(id)))];
+            }
+            const hasCurrentPassedAncestor = (feature, seen = /* @__PURE__ */ new Set()) => {
+              const sourceId = feature.generatedFromFeatureId;
+              if (!sourceId || seen.has(sourceId)) return false;
+              seen.add(sourceId);
+              const source = currentById.get(sourceId);
+              return passed(source) || (source ? hasCurrentPassedAncestor(source, seen) : false);
+            };
+            const changed = preImages.filter((feature) => Boolean(
+              (feature.generatedFromFeatureId || feature.generatedFromRunId) && feature.lastValidatorStatus === "passed" && !feature.lastValidatorRunId && !feature.taskId && feature.status === "done" && !hasCurrentPassedAncestor(feature)
+            ));
+            if (changed.length === 0) return { events: [], features: [] };
+            await tx.update(project_exports.missionFeatures).set({
+              status: "defined",
+              taskId: null,
+              loopState: "idle",
+              lastValidatorStatus: null,
+              updatedAt: now
+            }).where(inArray(project_exports.missionFeatures.id, changed.map((feature) => feature.id)));
+            let seq = await getMaxEventSeq(tx);
+            const events = [];
+            for (const feature of changed) {
+              const event = await this.recordFeatureStatusChange(tx, feature, "defined", { type: "system", id: "mission-store", source: "superseded-fix-marker-repair" }, void 0, ++seq);
+              if (event) events.push(event);
+            }
+            return { events, features: changed };
+          });
+          for (const event of repaired.events) this.emit("mission:event", event);
+          for (const feature of repaired.features) {
+            this.emit("feature:updated", { ...feature, status: "defined", taskId: void 0, loopState: "idle", lastValidatorStatus: void 0, updatedAt: now });
+            repairedFeatureIds.push(feature.id);
+          }
         }
         if (ids.length > 0) {
           const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -83046,13 +83214,12 @@ ${reasonText}` : void 0)].filter(Boolean).join("\n\n") || void 0,
             const locked = await tx.select({ id: project_exports.missionFeatures.id }).from(project_exports.missionFeatures).where(inArray(project_exports.missionFeatures.id, ids)).for("update");
             const lockedIds = locked.map((row) => row.id);
             const preImages = lockedIds.length > 0 ? await listFeaturesByIds(tx, lockedIds) : [];
-            const changed = preImages.filter((feature) => feature.status !== "done" || feature.loopState !== "passed" || feature.lastValidatorStatus !== "passed" || feature.taskId);
+            const changed = preImages.filter((feature) => feature.status !== "done" || feature.loopState !== "passed" || feature.taskId);
             if (changed.length === 0) return { events: [], updatedFeatures: [] };
             await tx.update(project_exports.missionFeatures).set({
               status: "done",
               taskId: null,
               loopState: "passed",
-              lastValidatorStatus: "passed",
               updatedAt: now
             }).where(inArray(project_exports.missionFeatures.id, changed.map((feature) => feature.id)));
             let seq = await getMaxEventSeq(tx);
@@ -83067,13 +83234,14 @@ ${reasonText}` : void 0)].filter(Boolean).join("\n\n") || void 0,
           });
           for (const event of events) this.emit("mission:event", event);
           for (const feature of updatedFeatures) {
-            const updated = { ...feature, status: "done", taskId: void 0, loopState: "passed", lastValidatorStatus: "passed", updatedAt: now };
+            const updated = { ...feature, status: "done", taskId: void 0, loopState: "passed", updatedAt: now };
             this.emit("feature:updated", updated);
             if (feature.taskId) await clearTaskMissionLinkage(this.db, feature.taskId);
           }
           if (updatedFeatures.length > 0) await this.recomputeSliceStatus(sliceId);
         }
-        return { supersededCount: ids.length, featureIds: ids };
+        if (repairedFeatureIds.length > 0) await this.recomputeSliceStatus(sliceId);
+        return { supersededCount: ids.length, featureIds: ids, repairedCount: repairedFeatureIds.length, repairedFeatureIds };
       }
       async transitionLoopState(featureId, newState) {
         const feature = await getFeature(this.db, featureId);
@@ -88705,19 +88873,81 @@ async function archiveAllDoneImpl(store, options) {
   for (const column of completeColumns) {
     for (const task of await store.listTasks({ slim: true, column })) doneById.set(task.id, task);
   }
-  const doneTasks = [...doneById.values()];
-  if (doneTasks.length === 0) {
-    return [];
+  if (doneById.size === 0) return { archived: [], skipped: [] };
+  const archivedColumns = await resolveArchivedLanes(store).catch(() => void 0) ?? new Set(LEGACY_ARCHIVE_LANES);
+  const liveTasks = (await store.listTasks({ slim: true, includeArchived: false })).filter((task) => !task.deletedAt && !archivedColumns.has(task.column));
+  const childrenByParentId = /* @__PURE__ */ new Map();
+  for (const task of liveTasks) {
+    if (!task.sourceParentTaskId) continue;
+    const children = childrenByParentId.get(task.sourceParentTaskId) ?? [];
+    children.push(task.id);
+    childrenByParentId.set(task.sourceParentTaskId, children);
+  }
+  for (const children of childrenByParentId.values()) children.sort();
+  const bypassLineageGate = options?.removeLineageReferences === true;
+  const archivableIds = new Set(doneById.keys());
+  const skipped = [];
+  if (!bypassLineageGate) {
+    let firstRemovalWave = true;
+    while (true) {
+      const removals = [...archivableIds].filter(
+        (id) => (childrenByParentId.get(id) ?? []).some((childId) => !archivableIds.has(childId))
+      ).sort();
+      if (removals.length === 0) break;
+      for (const id of removals) {
+        const blockers = (childrenByParentId.get(id) ?? []).filter((childId) => !archivableIds.has(childId));
+        skipped.push({
+          id,
+          reason: firstRemovalWave ? "open-lineage-children" : "blocked-by-unarchived-batch-member",
+          blockers,
+          message: firstRemovalWave ? `Live lineage children prevent archiving ${id}.` : `Unarchived batch members prevent archiving ${id}.`
+        });
+        archivableIds.delete(id);
+      }
+      firstRemovalWave = false;
+    }
+  }
+  const archived = [];
+  const remaining = new Set(archivableIds);
+  const archivedIds = /* @__PURE__ */ new Set();
+  const archiveWave = async (ids) => {
+    const settled = await Promise.allSettled(ids.map((id) => store.archiveTask(id, {
+      cleanup: true,
+      removeLineageReferences: options?.removeLineageReferences
+    })));
+    for (const [index3, result2] of settled.entries()) {
+      const id = ids[index3];
+      if (result2.status === "fulfilled") {
+        archived.push(result2.value);
+        archivedIds.add(id);
+      } else {
+        const error3 = result2.reason;
+        const blockers = error3 instanceof TaskHasLineageChildrenError ? error3.childIds : error3 instanceof TaskHasDependentsError ? error3.dependentIds : [];
+        skipped.push({ id, reason: "archive-failed", blockers, message: error3 instanceof Error ? error3.message : String(error3) });
+      }
+      remaining.delete(id);
+    }
+  };
+  while (remaining.size > 0) {
+    const wave = [...remaining].filter(
+      (id) => bypassLineageGate ? (childrenByParentId.get(id) ?? []).filter((childId) => remaining.has(childId)).length === 0 : (childrenByParentId.get(id) ?? []).filter((childId) => archivableIds.has(childId)).every((childId) => archivedIds.has(childId))
+    ).sort();
+    if (wave.length > 0) {
+      await archiveWave(wave);
+      continue;
+    }
+    if (bypassLineageGate) {
+      await archiveWave([...remaining].sort());
+    } else {
+      for (const id of [...remaining].sort()) {
+        const blockers = (childrenByParentId.get(id) ?? []).filter((childId) => remaining.has(childId) || !archivedIds.has(childId));
+        skipped.push({ id, reason: "blocked-by-unarchived-batch-member", blockers, message: `Unarchived batch members prevent archiving ${id}.` });
+        remaining.delete(id);
+      }
+    }
   }
-  const archivedTasks3 = await Promise.all(
-    doneTasks.map(
-      (task) => store.archiveTask(task.id, {
-        cleanup: true,
-        removeLineageReferences: options?.removeLineageReferences
-      })
-    )
-  );
-  return archivedTasks3;
+  skipped.sort((left, right) => left.id.localeCompare(right.id));
+  return { archived, skipped };
 }
 async function resolveUnarchiveTargetColumnImpl(store, preArchiveColumn, taskId) {
   const lifecycle2 = taskId ? await resolveTaskLifecycleColumns(store, taskId) : void 0;
@@ -89181,6 +89411,7 @@ var init_task_artifacts_ops = __esm({
     init_types();
     init_store();
     init_project_lane_vocabulary();
+    init_errors3();
     LEGACY_ARCHIVE_LANES = ["archived"];
   }
 });
@@ -107052,18 +107283,18 @@ function hasFreshAgentLogActivitySinceTaskUpdate(store, task, now, reviewColumns
   }
   return Math.max(0, now - latestAgentLogMs) < DEFAULT_STALE_MERGING_MIN_AGE_MS;
 }
-async function resolveHoldColumnForTask(store, taskId, cache8) {
+async function resolveHoldColumnForTask(store, taskId, cache8, selectionCache) {
   try {
-    const lifecycle2 = resolveLifecycleColumns(await resolveWorkflowIrForTask(store, taskId, cache8));
+    const lifecycle2 = resolveLifecycleColumns(await resolveWorkflowIrForTask(store, taskId, cache8, selectionCache));
     return lifecycle2?.hold ?? "todo";
   } catch {
     return "todo";
   }
 }
-async function resolveReviewColumnsForTask(store, taskId, cache8) {
+async function resolveReviewColumnsForTask(store, taskId, cache8, selectionCache) {
   const columns = /* @__PURE__ */ new Set(["in-review"]);
   try {
-    const ir2 = await resolveWorkflowIrForTask(store, taskId, cache8);
+    const ir2 = await resolveWorkflowIrForTask(store, taskId, cache8, selectionCache);
     if (ir2) for (const id of resolveReviewColumns(ir2)) columns.add(id);
   } catch {
   }
@@ -107184,6 +107415,12 @@ async function listTasksImpl(store, options) {
   const settings = await store.getSettingsFast();
   const mergeQueuedTaskIds = await store.getMergeQueuedTaskIdsAsync();
   const listPassIrCache = /* @__PURE__ */ new Map();
+  const listPassSelectionCache = options?.selectionCache ?? /* @__PURE__ */ new Map();
+  const listSelectionReads = await prefetchWorkflowSelections(store, filteredRows.map((row) => String(row.id)), listPassSelectionCache);
+  if (options?.selectionReadTally) {
+    options.selectionReadTally.batched += listSelectionReads.batched;
+    options.selectionReadTally.singles += listSelectionReads.singles;
+  }
   const staleThresholds = {
     inProgressWarningMs: settings.staleInProgressWarningMs,
     inProgressCriticalMs: settings.staleInProgressCriticalMs,
@@ -107194,7 +107431,7 @@ async function listTasksImpl(store, options) {
     const row = store.pgRowToTaskRow(pgRow);
     const task = store.rowToTask(row);
     const isMergeQueued = mergeQueuedTaskIds.has(task.id);
-    const reviewColumnsForRow = await resolveReviewColumnsForTask(store, task.id, listPassIrCache);
+    const reviewColumnsForRow = await resolveReviewColumnsForTask(store, task.id, listPassIrCache, listPassSelectionCache);
     const hasFreshAgentLogActivity = hasFreshAgentLogActivitySinceTaskUpdate(store, task, now, reviewColumnsForRow);
     const executingTaskIds = hasFreshAgentLogActivity ? /* @__PURE__ */ new Set([task.id]) : void 0;
     task.inReviewStall = isMergeQueued ? void 0 : getInReviewStallReason(task, {
@@ -107226,7 +107463,7 @@ async function listTasksImpl(store, options) {
       thresholdMs: settings.stalePausedTodoThresholdMs,
       // Paused-only (the signal is a no-op otherwise), sharing the list-pass
       // IR cache so one workflow is read once per pass, not once per card.
-      holdColumn: task.paused === true ? await resolveHoldColumnForTask(store, task.id, listPassIrCache) : void 0,
+      holdColumn: task.paused === true ? await resolveHoldColumnForTask(store, task.id, listPassIrCache, listPassSelectionCache) : void 0,
       engineActiveSinceMs: settings.engineActiveSinceMs,
       engineActivationGraceMs: settings.engineActivationGraceMs
     });
@@ -107236,7 +107473,7 @@ async function listTasksImpl(store, options) {
         thresholds: staleThresholds,
         engineActiveSinceMs: settings.engineActiveSinceMs,
         engineActivationGraceMs: settings.engineActivationGraceMs,
-        lifecycle: await resolveTaskLifecycleColumns(store, task.id, listPassIrCache)
+        lifecycle: await resolveTaskLifecycleColumns(store, task.id, listPassIrCache, listPassSelectionCache)
       });
     } catch (err) {
       if (!(err instanceof RangeError)) throw err;
@@ -107315,12 +107552,14 @@ async function listTasksModifiedSinceImpl(store, since, limit2, opts) {
   const lifecycleByTaskId = /* @__PURE__ */ new Map();
   {
     const irCache = /* @__PURE__ */ new Map();
+    const selectionCache = /* @__PURE__ */ new Map();
+    await prefetchWorkflowSelections(store, pageRows.map((row) => row.id), selectionCache);
     for (const pgRow of pageRows) {
       const row = store.pgRowToTaskRow(pgRow);
-      reviewColumnsByTaskId.set(row.id, await resolveReviewColumnsForTask(store, row.id, irCache));
-      lifecycleByTaskId.set(row.id, await resolveTaskLifecycleColumns(store, row.id, irCache));
+      reviewColumnsByTaskId.set(row.id, await resolveReviewColumnsForTask(store, row.id, irCache, selectionCache));
+      lifecycleByTaskId.set(row.id, await resolveTaskLifecycleColumns(store, row.id, irCache, selectionCache));
       if (store.rowToTask(row).paused !== true) continue;
-      holdColumnByTaskId.set(row.id, await resolveHoldColumnForTask(store, row.id, irCache));
+      holdColumnByTaskId.set(row.id, await resolveHoldColumnForTask(store, row.id, irCache, selectionCache));
     }
   }
   const tasks2 = pageRows.map((pgRow) => {
@@ -107438,10 +107677,12 @@ async function searchTasksImpl(store, query, options) {
   const settings = await store.getSettingsFast();
   const mergeQueuedTaskIds = await store.getMergeQueuedTaskIdsAsync();
   const searchPassIrCache = /* @__PURE__ */ new Map();
+  const searchPassSelectionCache = /* @__PURE__ */ new Map();
+  await prefetchWorkflowSelections(store, pgRows.map((row) => String(row.id)), searchPassSelectionCache);
   const tasks2 = await Promise.all(pgRows.map(async (pgRow) => {
     const task = store.rowToTask(store.pgRowToTaskRow(pgRow));
     const isMergeQueued = mergeQueuedTaskIds.has(task.id);
-    const reviewColumnsForRow = await resolveReviewColumnsForTask(store, task.id, searchPassIrCache);
+    const reviewColumnsForRow = await resolveReviewColumnsForTask(store, task.id, searchPassIrCache, searchPassSelectionCache);
     const hasFreshAgentLogActivity = hasFreshAgentLogActivitySinceTaskUpdate(store, task, now, reviewColumnsForRow);
     const executingTaskIds = hasFreshAgentLogActivity ? /* @__PURE__ */ new Set([task.id]) : void 0;
     task.inReviewStall = isMergeQueued ? void 0 : getInReviewStallReason(task, {
@@ -108681,6 +108922,7 @@ var init_store = __esm({
     init_async_self_healing();
     init_task_merge();
     init_required_pre_merge_steps();
+    init_pre_merge_approval();
     init_logger();
     init_project_root_guard();
     init_agent_store();
@@ -110446,29 +110688,35 @@ var init_store = __esm({
           const results = task.workflowStepResults ?? [];
           const failedTarget = getLatestFailedPreMergeReviewStep(task);
           const reviewIrForBypass = failedTarget ? void 0 : await resolveWorkflowIrForTask(this, task.id);
-          const absentStepId = reviewIrForBypass ? [...resolveRequiredPreMergeStepIds(reviewIrForBypass, task.enabledWorkflowSteps, task)].find((workflowStepId) => !results.some((result2) => result2.workflowStepId === workflowStepId)) : void 0;
-          if (!failedTarget && !absentStepId) {
+          const requiredForBypass = reviewIrForBypass ? [...resolveRequiredPreMergeStepIds(reviewIrForBypass, task.enabledWorkflowSteps, task)] : [];
+          const absentStepId = requiredForBypass.find((workflowStepId) => !results.some((result2) => result2.workflowStepId === workflowStepId));
+          const unapprovedTarget = !failedTarget && !absentStepId && requiredForBypass.length > 0 ? (() => {
+            const blocked = evaluatePreMergeApprovals(task, { requiredPreMergeStepIds: new Set(requiredForBypass) }).find((approval) => approval.state !== "approved");
+            return blocked ? results.find((result2) => result2.workflowStepId === blocked.workflowStepId) : void 0;
+          })() : void 0;
+          if (!failedTarget && !absentStepId && !unapprovedTarget) {
             throw new Error(`Cannot bypass review lane for ${id}: no failed pre-merge review step found`);
           }
-          const target = failedTarget ?? {
+          const target = failedTarget ?? unapprovedTarget ?? {
             workflowStepId: absentStepId,
             workflowStepName: absentStepId,
             phase: "pre-merge",
             status: "absent"
           };
-          const targetIndex = failedTarget ? results.indexOf(failedTarget) : -1;
-          if (failedTarget && targetIndex === -1) {
+          const rowTarget = failedTarget ?? unapprovedTarget;
+          const targetIndex = rowTarget ? results.indexOf(rowTarget) : -1;
+          if (rowTarget && targetIndex === -1) {
             throw new Error(`Cannot bypass review lane for ${id}: failed step result not found`);
           }
           const now = (/* @__PURE__ */ new Date()).toISOString();
-          const bypassed = failedTarget ? {
-            ...failedTarget,
+          const bypassed = rowTarget ? {
+            ...rowTarget,
             status: "skipped",
             bypassedBy: actor,
             bypassedAt: now,
             bypassReason: reason,
-            bypassedFromStatus: failedTarget.status,
-            bypassedFromVerdict: failedTarget.verdict
+            bypassedFromStatus: rowTarget.remediationArchivedFromStatus ?? rowTarget.status,
+            bypassedFromVerdict: rowTarget.verdict ?? rowTarget.priorAttempts?.[0]?.verdict
           } : {
             workflowStepId: absentStepId,
             workflowStepName: absentStepId,
@@ -110502,8 +110750,8 @@ var init_store = __esm({
             metadata: {
               workflowStepId: target.workflowStepId,
               workflowStepName: target.workflowStepName,
-              bypassedFromStatus: target.status,
-              bypassedFromVerdict: failedTarget?.verdict ?? null,
+              bypassedFromStatus: bypassed.bypassedFromStatus,
+              bypassedFromVerdict: bypassed.bypassedFromVerdict ?? null,
               reason
             }
           });
@@ -110565,9 +110813,8 @@ var init_store = __esm({
             );
           }
           if (target.status !== "pending") {
-            throw new Error(
-              `Cannot resume workflow step for ${id}: only pending steps can be resumed`
-            );
+            const archivedFailure = target.remediationArchivedAt != null && (target.remediationArchivedFromStatus === "failed" || target.remediationArchivedFromStatus === "advisory_failure") && !target.bypassedBy && !target.supersededAt;
+            throw new Error(`Cannot resume workflow step for ${id}: only pending steps can be resumed${archivedFailure ? ` (step '${stepId}' is an archived remediation carrier \u2014 use fn_task_bypass_review / POST /tasks/:id/bypass-review to clear it)` : ""}`);
           }
           const now = (/* @__PURE__ */ new Date()).toISOString();
           const resumed = {
@@ -141075,6 +141322,7 @@ __export(src_exports, {
   CLOUD_TICKET_QUERY: () => CLOUD_TICKET_QUERY,
   CODE_REVIEW_BLOCKING_SEVERITY_SETTING_ID: () => CODE_REVIEW_BLOCKING_SEVERITY_SETTING_ID,
   CODE_REVIEW_MAX_REVISIONS_SETTING_ID: () => CODE_REVIEW_MAX_REVISIONS_SETTING_ID,
+  COLLATERAL_ARCHIVED_REVIEW_GATE_DIAGNOSTIC: () => COLLATERAL_ARCHIVED_REVIEW_GATE_DIAGNOSTIC,
   COLOR_THEMES: () => COLOR_THEMES,
   COLUMNS: () => COLUMNS,
   COLUMN_DESCRIPTIONS: () => COLUMN_DESCRIPTIONS,
@@ -141477,6 +141725,7 @@ __export(src_exports, {
   SLICE_PLAN_STATES: () => SLICE_PLAN_STATES,
   SLICE_STATUSES: () => SLICE_STATUSES,
   SPEC_LOCK_PARSER_VERSION: () => SPEC_LOCK_PARSER_VERSION,
+  STALE_CONTENT_APPROVAL_BLOCKER: () => STALE_CONTENT_APPROVAL_BLOCKER,
   STALE_HIGH_FANOUT_BLOCKER_AGE_THRESHOLD_MS: () => STALE_HIGH_FANOUT_BLOCKER_AGE_THRESHOLD_MS,
   STALLED_REVIEW_INVALID_TRANSITION_PATTERN: () => STALLED_REVIEW_INVALID_TRANSITION_PATTERN,
   STALLED_REVIEW_INVALID_TRANSITION_THRESHOLD: () => STALLED_REVIEW_INVALID_TRANSITION_THRESHOLD,
@@ -142206,6 +142455,7 @@ __export(src_exports, {
   isSqliteLockError: () => isSqliteLockError,
   isSqliteMigrationComplete: () => isSqliteMigrationComplete,
   isStaleBlockedByBlocker: () => isStaleBlockedByBlocker,
+  isStaleContentApprovalBlocker: () => isStaleContentApprovalBlocker,
   isStoredAuthCredential: () => isStoredAuthCredential,
   isStrictDescendantPath: () => isStrictDescendantPath,
   isTailscaleCgnatIpv4: () => isTailscaleCgnatIpv4,
@@ -142285,6 +142535,7 @@ __export(src_exports, {
   mapRoleToCapability: () => mapRoleToCapability,
   markDraftSummarized: () => markDraftSummarized,
   markdownHtmlCommentUnits: () => markdownHtmlCommentUnits,
+  matchStepHeadings: () => matchStepHeadings,
   matchesFrontendUxPath: () => matchesFrontendUxPath,
   matchesPatchnodeQuery: () => matchesPatchnodeQuery,
   materializeMcpServerSecrets: () => materializeMcpServerSecrets,
@@ -142398,6 +142649,7 @@ __export(src_exports, {
   postMergeOptionalGroupNode: () => postMergeOptionalGroupNode,
   postMergeVerificationOptionalGroupNode: () => postMergeVerificationOptionalGroupNode,
   postgresSchema: () => schema_exports,
+  prefetchWorkflowSelections: () => prefetchWorkflowSelections,
   prepareAgentCompaniesImport: () => prepareAgentCompaniesImport,
   pricingAsOf: () => pricingAsOf,
   probeGitCliStatus: () => probeGitCliStatus,
@@ -142509,6 +142761,7 @@ __export(src_exports, {
   resolveBackupSettingsMigrationConflict: () => resolveBackupSettingsMigrationConflict,
   resolveCapacityPoolId: () => resolveCapacityPoolId,
   resolveClaudeCodeClientVersion: () => resolveClaudeCodeClientVersion,
+  resolveCollateralArchivedReviewGate: () => resolveCollateralArchivedReviewGate,
   resolveColumnAdjacency: () => resolveColumnAdjacency,
   resolveColumnAgentBinding: () => resolveColumnAgentBinding,
   resolveColumnCapacity: () => resolveColumnCapacity,
@@ -154389,7 +154642,10 @@ async function runHoldReleaseSweep(store, deps) {
     const settings = await store.getSettings();
     if (expired()) return logPreambleTruncation(0);
     counters.tasks += 1;
-    const allTasks = await store.listTasks({ includeArchived: false });
+    const selectionReadTally = { batched: 0, singles: 0 };
+    const allTasks = await store.listTasks({ includeArchived: false, selectionCache, selectionReadTally });
+    counters.batchSelections += selectionReadTally.batched;
+    counters.selections += selectionReadTally.singles;
     if (expired()) return logPreambleTruncation(allTasks.length);
     const effectiveWorkflowIdByTask = /* @__PURE__ */ new Map();
     const missingIds = [...new Set(allTasks.map((task) => task.id))].filter((id) => !selectionCache.has(id));
@@ -180117,7 +180373,7 @@ function extractMarkdownSection(document2, headingName) {
   return document2.slice(start, end).trim();
 }
 function compactTaskPromptStepsSection(section) {
-  const stepTitles = Array.from(section.matchAll(/^### Step \d+:.*$/gm), (match2) => match2[0].trim());
+  const stepTitles = matchStepHeadings(section).map(({ index: index3, headingLineEnd }) => section.slice(index3, headingLineEnd).trim());
   if (stepTitles.length === 0) {
     return section.trim();
   }
@@ -189473,7 +189729,7 @@ var init_scheduler = __esm({
             for (const slice of hierarchy.milestones.flatMap((milestone) => milestone.slices).filter((slice2) => slice2.status === "active")) {
               try {
                 const superseded = await missionStore.reconcileSupersededGeneratedFixFeatures(slice.id);
-                fixed += superseded.supersededCount;
+                fixed += superseded.supersededCount + (superseded.repairedCount ?? 0);
                 if (superseded.supersededCount > 0) {
                   const refreshed = await missionStore.getSlice(slice.id);
                   if (refreshed?.status === "complete") {
@@ -189486,8 +189742,9 @@ var init_scheduler = __esm({
                 const supersededFeatureIds = new Set(superseded.featureIds ?? []);
                 const autoTriage = mission.autopilotEnabled === true || mission.autoAdvance === true;
                 for (const feature of features) {
-                  if (supersededFeatureIds.has(feature.id) || feature.taskId || !autoTriage || feature.status === "blocked") continue;
+                  if (supersededFeatureIds.has(feature.id) || feature.taskId || !autoTriage || feature.status === "blocked" || feature.status === "done") continue;
                   if (feature.status !== "defined" && this.isGeneratedFixFeature(feature)) {
+                    schedulerLog.warn(`Parking stranded generated Fix feature ${feature.id} from ${feature.status}: not triageable without a defined state`);
                     await missionStore.updateFeature(feature.id, { status: "blocked", loopState: "blocked", taskId: void 0 });
                     fixed++;
                     continue;
@@ -190539,12 +190796,12 @@ function createTaskSearchTool(store) {
     }
   };
 }
-function createPatchnodeReadTool(store) {
+function createHistoryReadTool(store) {
   return {
-    name: "fn_patchnode_read",
+    name: "fn_history_read",
     label: "Read History",
     description: "Read the permanent daily history of completed and reverted task deliveries.",
-    parameters: patchnodeReadParams,
+    parameters: historyReadParams,
     execute: async (_id, params) => {
       const limit2 = Math.min(50, Math.max(1, Math.floor(params.limit ?? 20)));
       const result2 = await store.listPatchnodeEntries({
@@ -190804,7 +191061,7 @@ function createTaskDocumentReadTool(store, taskId) {
   };
 }
 function createInstallWorktreeDependenciesTool(store, taskId, options) {
-  const errorResult = (message) => ({
+  const errorResult2 = (message) => ({
     content: [{ type: "text", text: `ERROR: ${message}` }],
     details: {},
     isError: true
@@ -190817,33 +191074,33 @@ function createInstallWorktreeDependenciesTool(store, taskId, options) {
     parameters: installWorktreeDependenciesParams,
     execute: async (_id, params) => {
       const task = await store.getTask(taskId);
-      if (!task) return errorResult(`Task ${taskId} no longer exists.`);
+      if (!task) return errorResult2(`Task ${taskId} no longer exists.`);
       const workspaceRepos = (await loadWorkspaceConfig(options.rootDir))?.repos ?? [];
       const requestedRepository = params.repository?.trim();
       let worktreePath;
       let repositoryLabel;
       if (workspaceRepos.length > 0) {
         if (workspaceRepos.length > 1 && !requestedRepository) {
-          return errorResult("repository is required for a workspace with multiple configured repositories.");
+          return errorResult2("repository is required for a workspace with multiple configured repositories.");
         }
         if (workspaceRepos.length === 1 && requestedRepository && requestedRepository !== workspaceRepos[0]) {
-          return errorResult(`Unknown workspace repository: ${requestedRepository}`);
+          return errorResult2(`Unknown workspace repository: ${requestedRepository}`);
         }
         const repository = requestedRepository ?? workspaceRepos[0];
-        if (!workspaceRepos.includes(repository)) return errorResult(`Unknown workspace repository: ${repository}`);
+        if (!workspaceRepos.includes(repository)) return errorResult2(`Unknown workspace repository: ${repository}`);
         worktreePath = task.workspaceWorktrees?.[repository]?.worktreePath;
         repositoryLabel = repository;
       } else {
-        if (requestedRepository) return errorResult("repository is only valid for a configured workspace task.");
+        if (requestedRepository) return errorResult2("repository is only valid for a configured workspace task.");
         worktreePath = task.worktree;
       }
       if (!worktreePath || !existsSync56(worktreePath)) {
-        return errorResult(`No acquired task worktree is available${repositoryLabel ? ` for ${repositoryLabel}` : ""}.`);
+        return errorResult2(`No acquired task worktree is available${repositoryLabel ? ` for ${repositoryLabel}` : ""}.`);
       }
       const settings = await options.getSettings();
       if (params.action === "none") {
         const reason = params.reason?.trim();
-        if (!reason) return errorResult("reason is required for action=none.");
+        if (!reason) return errorResult2("reason is required for action=none.");
         const readiness2 = recordPlannerDependencyResolution({
           worktreePath,
           action: "none",
@@ -190862,7 +191119,7 @@ function createInstallWorktreeDependenciesTool(store, taskId, options) {
         };
       }
       const command2 = params.command?.trim();
-      if (!command2) return errorResult("command is required for action=install.");
+      if (!command2) return errorResult2("command is required for action=install.");
       let result2;
       try {
         result2 = await options.runConfiguredCommand(
@@ -194132,7 +194389,7 @@ ${lines.join("\n")}`
     }
   };
 }
-var TASK_CREATE_PRIORITY_VALUES, missionLineageParams, taskCreateParams, taskLogParams, agentLogTypeParams, agentLogDetailModeParams, taskLogsReadParams, chatTaskLogsReadParams, taskListParams, taskShowParams, taskSearchParams, patchnodeReadParams, installWorktreeDependenciesParams, taskDocumentWriteParams, taskDocumentReadParams, taskPromptWriteParams, taskFileScopeAddParams, chatTaskDocumentWriteParams, chatTaskDocumentReadParams, ARTIFACT_TYPE_VALUES, artifactTypeSchema, artifactRegisterParams, artifactListParams, artifactViewParams, chatArtifactRegisterParams, chatArtifactListParams, workflowListParams, workflowGetParams, workflowSelectParams, taskPromoteParams, taskArchiveParams, taskDeleteParams, taskUnarchiveParams, taskRetryParams, taskPauseParams, taskUnpauseParams, taskDuplicateParams, taskMergeParams, taskAddDepParams, STEP_STATUSES, taskUpdateParams, workflowCreateParams, workflowValidateParams, workflowUpdateParams, workflowDeleteParams, workflowSettingsParams, traitListParams, reflectOnPerformanceParams, readEvaluationsParams, updateIdentityParams, goalListParams, goalShowParams, listAgentsParams, delegateTaskParams, taskAssignParams, getAgentConfigParams, updateAgentConfigParams, createAgentParams, deleteAgentParams, sendMessageParams, readMessagesParams, postRoomMessageParams, askQuestionParams, memorySearchParams, memoryGetParams, webFetchParams, researchRunParams, researchListParams, researchGetParams, researchCancelParams, researchRetryParams, memoryAppendParams, log25, MAX_INSTRUCTIONS_TEXT_LENGTH, MAX_MEMORY_LENGTH, MAX_SOUL_LENGTH, AGENT_MEMORY_ROOT3, AGENT_MEMORY_FILENAME2, AGENT_DREAMS_FILENAME2, agentQmdRefreshState, AGENT_QMD_REFRESH_INTERVAL_MS, DAILY_AGENT_MEMORY_RE2, SEMANTIC_TOOL_READ_MAX_CHARS, AGENT_LOG_READ_DETAIL_PREVIEW_MAX, ARTIFACT_FILE_MAX_BYTES, ARTIFACT_EXTENSION_MIME_TYPES, GOAL_LIST_HARD_LIMIT, GOAL_LIST_SOFT_WARNING_THRESHOLD, GOAL_SNIPPET_MAX_CHARS, missionListParams, missionShowParams, missionCreateParams, missionUpdateParams, missionDeleteParams, missionSetStatusParams, missionReconcileParams, milestoneAddParams, milestoneUpdateParams, milestoneDeleteParams, sliceAddParams, sliceActivateParams, sliceDeleteParams, featureAddParams, featureUpdateParams, featureDeleteParams, featureSetStatusParams, featureLinkTaskParams, featureRepointTaskParams, featureUnlinkTaskParams, featureRepairValidationParams, researchFindingPromoteParams, missionToolResult, optionalText, updateFields, ideationStartParams, ideationDivergeParams, ideationShowParams, ideationConvergeParams, ideationToolResult, formatIdeationCandidate;
+var TASK_CREATE_PRIORITY_VALUES, missionLineageParams, taskCreateParams, taskLogParams, agentLogTypeParams, agentLogDetailModeParams, taskLogsReadParams, chatTaskLogsReadParams, taskListParams, taskShowParams, taskSearchParams, historyReadParams, installWorktreeDependenciesParams, taskDocumentWriteParams, taskDocumentReadParams, taskPromptWriteParams, taskFileScopeAddParams, chatTaskDocumentWriteParams, chatTaskDocumentReadParams, ARTIFACT_TYPE_VALUES, artifactTypeSchema, artifactRegisterParams, artifactListParams, artifactViewParams, chatArtifactRegisterParams, chatArtifactListParams, workflowListParams, workflowGetParams, workflowSelectParams, taskPromoteParams, taskArchiveParams, taskDeleteParams, taskUnarchiveParams, taskRetryParams, taskPauseParams, taskUnpauseParams, taskDuplicateParams, taskMergeParams, taskAddDepParams, STEP_STATUSES, taskUpdateParams, workflowCreateParams, workflowValidateParams, workflowUpdateParams, workflowDeleteParams, workflowSettingsParams, traitListParams, reflectOnPerformanceParams, readEvaluationsParams, updateIdentityParams, goalListParams, goalShowParams, listAgentsParams, delegateTaskParams, taskAssignParams, getAgentConfigParams, updateAgentConfigParams, createAgentParams, deleteAgentParams, sendMessageParams, readMessagesParams, postRoomMessageParams, askQuestionParams, memorySearchParams, memoryGetParams, webFetchParams, researchRunParams, researchListParams, researchGetParams, researchCancelParams, researchRetryParams, memoryAppendParams, log25, MAX_INSTRUCTIONS_TEXT_LENGTH, MAX_MEMORY_LENGTH, MAX_SOUL_LENGTH, AGENT_MEMORY_ROOT3, AGENT_MEMORY_FILENAME2, AGENT_DREAMS_FILENAME2, agentQmdRefreshState, AGENT_QMD_REFRESH_INTERVAL_MS, DAILY_AGENT_MEMORY_RE2, SEMANTIC_TOOL_READ_MAX_CHARS, AGENT_LOG_READ_DETAIL_PREVIEW_MAX, ARTIFACT_FILE_MAX_BYTES, ARTIFACT_EXTENSION_MIME_TYPES, GOAL_LIST_HARD_LIMIT, GOAL_LIST_SOFT_WARNING_THRESHOLD, GOAL_SNIPPET_MAX_CHARS, missionListParams, missionShowParams, missionCreateParams, missionUpdateParams, missionDeleteParams, missionSetStatusParams, missionReconcileParams, milestoneAddParams, milestoneUpdateParams, milestoneDeleteParams, sliceAddParams, sliceActivateParams, sliceDeleteParams, featureAddParams, featureUpdateParams, featureDeleteParams, featureSetStatusParams, featureLinkTaskParams, featureRepointTaskParams, featureUnlinkTaskParams, featureRepairValidationParams, researchFindingPromoteParams, missionToolResult, optionalText, updateFields, ideationStartParams, ideationDivergeParams, ideationShowParams, ideationConvergeParams, ideationToolResult, formatIdeationCandidate;
 var init_agent_tools = __esm({
   "../engine/src/agent-tools.ts"() {
     "use strict";
@@ -194223,7 +194480,7 @@ var init_agent_tools = __esm({
       includeArchived: Type2.Optional(Type2.Boolean({ description: "Include archived tasks (default true)" })),
       limit: Type2.Optional(Type2.Number({ minimum: 1, maximum: 50, description: "Max results (default 20, max 50)" }))
     });
-    patchnodeReadParams = Type2.Object({
+    historyReadParams = Type2.Object({
       query: Type2.Optional(Type2.String({ description: "Search task IDs, titles, and completion summaries" })),
       from: Type2.Optional(Type2.String({ description: "First UTC day, YYYY-MM-DD (inclusive)" })),
       to: Type2.Optional(Type2.String({ description: "Last UTC day, YYYY-MM-DD (inclusive)" })),
@@ -197433,6 +197690,55 @@ var init_fallback_model_observer = __esm({
   }
 });
 
+// ../engine/src/execution/resolve-activity-run-agent-id.ts
+async function resolveWorkflowStepRunAgentId(store, candidate, options = {}) {
+  if (!candidate?.trim()) return null;
+  const resolve120 = async () => {
+    if (typeof store?.getAgent === "function") {
+      const agent = await store.getAgent(candidate);
+      if (agent) return agent.id;
+    }
+    if (typeof store?.listAgents !== "function") return null;
+    const matches = (await store.listAgents({ includeEphemeral: true })).filter(
+      (agent) => agent.role === candidate || agent.roles?.includes(candidate)
+    );
+    const builtInOwners = matches.filter(
+      (agent) => isBuiltinWorkflowRoleAgent(agent) && agent.metadata?.workflowRole === candidate
+    );
+    if (builtInOwners.length === 1) return builtInOwners[0].id;
+    return matches.length === 1 ? matches[0].id : null;
+  };
+  let lookup2;
+  try {
+    lookup2 = Promise.resolve(resolve120());
+  } catch {
+    return null;
+  }
+  void lookup2.catch(() => void 0);
+  return await new Promise((complete) => {
+    const timer2 = setTimeout(() => complete(null), options.timeoutMs ?? WORKFLOW_STEP_RUN_ATTRIBUTION_TIMEOUT_MS);
+    timer2.unref?.();
+    void lookup2.then(
+      (agentId) => {
+        clearTimeout(timer2);
+        complete(agentId);
+      },
+      () => {
+        clearTimeout(timer2);
+        complete(null);
+      }
+    );
+  });
+}
+var WORKFLOW_STEP_RUN_ATTRIBUTION_TIMEOUT_MS;
+var init_resolve_activity_run_agent_id = __esm({
+  "../engine/src/execution/resolve-activity-run-agent-id.ts"() {
+    "use strict";
+    init_src2();
+    WORKFLOW_STEP_RUN_ATTRIBUTION_TIMEOUT_MS = 2e3;
+  }
+});
+
 // ../engine/src/execution/step-session-executor.ts
 import { exec as exec20 } from "node:child_process";
 import { promisify as promisify27 } from "node:util";
@@ -197441,12 +197747,7 @@ import { rm as rm8 } from "node:fs/promises";
 function parseStepFileScopes(prompt) {
   const result2 = /* @__PURE__ */ new Map();
   if (!prompt) return result2;
-  const stepRegex = /^### Step (\d+):.*/gm;
-  const splits = [];
-  let match2;
-  while ((match2 = stepRegex.exec(prompt)) !== null) {
-    splits.push({ index: match2.index, stepNum: parseInt(match2[1], 10) });
-  }
+  const splits = matchStepHeadings(prompt).map(({ index: index3, headingNumber }) => ({ index: index3, stepNum: headingNumber }));
   if (splits.length === 0) return result2;
   for (let i = 0; i < splits.length; i++) {
     const start = splits[i].index;
@@ -197722,12 +198023,7 @@ function scopePromptToWorktree(prompt, rootDir, worktreePath) {
   return prompt.replaceAll(`${rootDir}/`, `${worktreePath}/`).replaceAll(`${worktreePath}/.fusion/`, `${rootDir}/.fusion/`);
 }
 function extractStepSection(prompt, stepIndex) {
-  const stepRegex = /^### Step (\d+):.*/gm;
-  const splits = [];
-  let match2;
-  while ((match2 = stepRegex.exec(prompt)) !== null) {
-    splits.push({ index: match2.index, stepNum: parseInt(match2[1], 10) });
-  }
+  const splits = matchStepHeadings(prompt).map(({ index: index3, headingNumber }) => ({ index: index3, stepNum: headingNumber }));
   const offset = resolveAuthoredStepHeadingOffset(splits.map((split) => split.stepNum));
   const targetSplit = splits.find((s3) => s3.stepNum === stepIndex + offset);
   if (!targetSplit) return "";
@@ -197737,9 +198033,7 @@ function extractStepSection(prompt, stepIndex) {
   return prompt.slice(start, end).trim();
 }
 function countSteps(prompt) {
-  const stepRegex = /^### Step \d+:/gm;
-  const matches = prompt.match(stepRegex);
-  return matches ? matches.length : 0;
+  return matchStepHeadings(prompt).length;
 }
 function resolveStepSection(taskDetail, prompt, stepIndex, authoredStepCount) {
   const authoredSection = extractStepSection(prompt, stepIndex);
@@ -197834,6 +198128,7 @@ var init_step_session_executor = __esm({
     init_usage_limit_detector();
     init_agent_tools();
     init_worktree_backend();
+    init_resolve_activity_run_agent_id();
     init_worktree_prune();
     init_active_session_registry();
     execAsync18 = promisify27(exec20);
@@ -197866,6 +198161,8 @@ var init_step_session_executor = __esm({
       credentialInstanceId;
       reusablePrimaryRetargetPending = false;
       reusablePrimaryAttemptActive = false;
+      workflowStepRunAgentId;
+      warnedUnattributableWorkflowStepRun = false;
       registerActiveStepSession(stepIndex, handle2, worktreePath) {
         this.activeSessions.set(stepIndex, handle2);
         activeSessionRegistry.registerPath(worktreePath, {
@@ -198210,10 +198507,20 @@ var init_step_session_executor = __esm({
           modelId: current.modelId
         };
       }
-      createWorkflowStepActivityRun(stepIndex, startedAt) {
+      async createWorkflowStepActivityRun(stepIndex, startedAt) {
         const { taskDetail } = this.options;
         const step = taskDetail.steps?.[stepIndex];
-        const agentId = this.options.effectiveAgentId ?? taskDetail.assignedAgentId ?? "executor";
+        if (typeof this.options.agentStore?.saveRun !== "function") return null;
+        const agentIdCandidate = this.options.effectiveAgentId ?? taskDetail.assignedAgentId ?? "executor";
+        this.workflowStepRunAgentId ??= resolveWorkflowStepRunAgentId(this.options.agentStore, agentIdCandidate);
+        const agentId = await this.workflowStepRunAgentId;
+        if (!agentId) {
+          if (!this.warnedUnattributableWorkflowStepRun) {
+            this.warnedUnattributableWorkflowStepRun = true;
+            stepExecLog.warn(`Skipping unattributable workflow-step activity runs for task ${taskDetail.id} (candidate: ${agentIdCandidate})`);
+          }
+          return null;
+        }
         return {
           id: `${generateSyntheticRunId("workflow-step", taskDetail.id)}-step-${stepIndex}`,
           agentId,
@@ -198233,6 +198540,7 @@ var init_step_session_executor = __esm({
             taskTitle: taskDetail.title,
             assignedAgentId: taskDetail.assignedAgentId,
             effectiveAgentId: this.options.effectiveAgentId,
+            agentIdCandidate,
             agentId,
             stepIndex,
             stepName: step?.name ?? `Step ${stepIndex}`
@@ -198247,6 +198555,7 @@ var init_step_session_executor = __esm({
         };
       }
       async saveWorkflowStepActivityRun(run2) {
+        if (!run2) return;
         const saveRun2 = this.options.agentStore?.saveRun?.bind(this.options.agentStore);
         if (!saveRun2) return;
         try {
@@ -198259,6 +198568,7 @@ var init_step_session_executor = __esm({
         }
       }
       async completeWorkflowStepActivityRun(run2, status, result2) {
+        if (!run2) return;
         const terminalRun = {
           ...run2,
           endedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -198318,7 +198628,7 @@ var init_step_session_executor = __esm({
         if (semaphore) {
           await semaphore.acquire();
         }
-        const activityRun = this.createWorkflowStepActivityRun(stepIndex, (/* @__PURE__ */ new Date()).toISOString());
+        const activityRun = await this.createWorkflowStepActivityRun(stepIndex, (/* @__PURE__ */ new Date()).toISOString());
         await this.saveWorkflowStepActivityRun(activityRun);
         const trackingKey = this.makeTrackingKey(stepIndex);
         let retries = 0;
@@ -198867,12 +199177,11 @@ function collectTaskPaths(text4) {
 }
 function collectStepSections(stepsSection) {
   const sections2 = [];
-  const headingMatches = Array.from(stepsSection.matchAll(/^### Step (\d+):[^\n]*$/gm));
+  const headingMatches = matchStepHeadings(stepsSection);
   for (let i = 0; i < headingMatches.length; i += 1) {
     const heading = headingMatches[i];
-    const start = (heading.index ?? 0) + heading[0].length;
-    const end = i + 1 < headingMatches.length ? headingMatches[i + 1].index ?? stepsSection.length : stepsSection.length;
-    sections2.push({ name: `Step ${heading[1]}`, body: stepsSection.slice(start, end).trim() });
+    const end = i + 1 < headingMatches.length ? headingMatches[i + 1].index : stepsSection.length;
+    sections2.push({ name: `Step ${heading.headingNumber}`, body: stepsSection.slice(heading.headingLineEnd, end).trim() });
   }
   return sections2;
 }
@@ -198964,6 +199273,7 @@ var TASK_PATH_REGEX;
 var init_task_document_references = __esm({
   "../engine/src/spec-validation/task-document-references.ts"() {
     "use strict";
+    init_src2();
     init_step_session_executor();
     TASK_PATH_REGEX = /\.fusion\/tasks\/[A-Z0-9]+(?:-[A-Z0-9]+)*\/[^\s`'"\]]+/g;
   }
@@ -199990,6 +200300,24 @@ var init_configured_command = __esm({
   }
 });
 
+// ../engine/src/merge/stale-content-park.ts
+function classifyStaleContentPark(task) {
+  if (task.paused || task.userPaused || task.deletedAt) return void 0;
+  if (typeof task.error !== "string" || !isStaleContentApprovalBlocker(task.error)) return void 0;
+  if (task.status === "failed") {
+    return task.error.startsWith(AUTO_MERGE_RETRY_REJECTED_PREFIX) ? "retry-rejected" : "raw-blocker";
+  }
+  return task.status == null ? "retry-exhausted" : void 0;
+}
+var AUTO_MERGE_RETRY_REJECTED_PREFIX;
+var init_stale_content_park = __esm({
+  "../engine/src/merge/stale-content-park.ts"() {
+    "use strict";
+    init_src2();
+    AUTO_MERGE_RETRY_REJECTED_PREFIX = "AUTO_MERGE_RETRY_REJECTED:";
+  }
+});
+
 // ../engine/src/execution/lifecycle-move-log.ts
 function laneRole(column, lanes) {
   if (!lanes) return void 0;
@@ -223770,6 +224098,17 @@ function isRecoveryRetryDue(task, now) {
   const retryAt = Date.parse(task.nextRecoveryAt);
   return !Number.isFinite(retryAt) || retryAt <= now;
 }
+function formatMergeableReviewRecoverySummary({
+  enqueued,
+  merged,
+  parked
+}) {
+  const outcomes = [];
+  if (enqueued > 0) outcomes.push(`${enqueued} re-enqueued for merge`);
+  if (merged > 0) outcomes.push(`${merged} merged \u2192 done`);
+  if (parked > 0) outcomes.push(`${parked} parked after enqueue starvation`);
+  return `Mergeable review recovery: ${outcomes.join(", ") || "no tasks recovered"}`;
+}
 async function resolveNoOpFinalizeGateIds2(store, task) {
   const selection = store.getTaskWorkflowSelectionAsync ? await store.getTaskWorkflowSelectionAsync(task.id) : store.getTaskWorkflowSelection?.(task.id);
   if (!selection) return void 0;
@@ -223816,6 +224155,7 @@ var init_self_healing = __esm({
     "use strict";
     init_src2();
     init_src2();
+    init_stale_content_park();
     init_logger3();
     init_lifecycle_move_log();
     init_lifecycle_move();
@@ -223836,6 +224176,7 @@ var init_self_healing = __esm({
     init_post_landing_worktree_cleanup();
     init_auto_recovery();
     init_active_session_registry();
+    init_planning_liveness();
     init_replan_target();
     init_planning_handoff_recovery();
     init_spec_staleness();
@@ -224002,6 +224343,9 @@ var init_self_healing = __esm({
       maintenanceTickCounter = 0;
       taskLifecycleRetentionLastPrunedAt = /* @__PURE__ */ new Map();
       staleContentRerouteAuditKeys = /* @__PURE__ */ new Set();
+      mergeRecoveryBlockerWarnKeys = /* @__PURE__ */ new Set();
+      staleContentParkRecoveryAttempts = /* @__PURE__ */ new Map();
+      staleContentParkRecoveryBudgetLogged = /* @__PURE__ */ new Set();
       unrunPreMergeGateRerouteAuditKeys = /* @__PURE__ */ new Set();
       githubCheckStateRetentionLastPrunedAt = /* @__PURE__ */ new Map();
       processBootStartedAt = Date.now();
@@ -224720,6 +225064,13 @@ var init_self_healing = __esm({
           { name: "reconcile-orphaned-pending-step-results", fn: () => this.reconcileOrphanedPendingStepResults().then(() => void 0) },
           { name: "reconcile-unproven-review-approvals", fn: () => this.reconcileUnprovenReviewApprovals().then(() => void 0) },
           /*
+          FNXC:PreMergeApproval 2026-09-05-22:11:
+          Runs AFTER the orphaned-step sweep, because that sweep is what produces the `failed` row this
+          defect archives, and BEFORE failed-step recovery, so the restored gate is visible to it in the
+          same startup pass instead of one cycle later.
+          */
+          { name: "reconcile-collateral-archived-review-gates", fn: () => this.reconcileCollateralArchivedReviewGates().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
           timer is gone, so clear only an unowned wait before ordinary dispatch classification;
@@ -225600,6 +225951,7 @@ var init_self_healing = __esm({
               */
               { name: "reconcile-orphaned-pending-step-results", fn: () => this.reconcileOrphanedPendingStepResults() },
               { name: "reconcile-unproven-review-approvals", fn: () => this.reconcileUnprovenReviewApprovals() },
+              { name: "reconcile-collateral-archived-review-gates", fn: () => this.reconcileCollateralArchivedReviewGates() },
               { 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() },
@@ -229086,29 +229438,28 @@ var init_self_healing = __esm({
       /** Repair legacy dependency residue before it can re-enter executor dispatch. */
       async reconcileMissingDependencies() {
         let repaired = 0;
-        const tasks2 = await this.store.listTasks({ slim: true });
+        const archivedColumns = new Set(await Promise.resolve().then(() => resolveProjectColumnsForRoles(this.store, ["archived"])).catch(() => /* @__PURE__ */ new Set()));
+        archivedColumns.add("archived");
+        const tasks2 = await this.store.listTasks({ slim: true, includeArchived: false });
         for (const snapshot of tasks2) {
+          if (snapshot.deletedAt || archivedColumns.has(snapshot.column)) continue;
           if (!snapshot.dependencies.length || snapshot.userPaused || snapshot.paused || snapshot.autoMerge === false) continue;
           const livePaths = activeSessionRegistry.pathsForTask(snapshot.id);
           const liveExecution = livePaths.some((path18) => activeSessionRegistry.isPathActive(path18)) || executingTaskLock.has(snapshot.id) || this.options.getExecutingTaskIds?.().has(snapshot.id) === true || this.options.isTaskActive?.(snapshot.id) === true || Boolean(snapshot.checkedOutBy);
           if (liveExecution) continue;
           let removed = 0;
           for (const dependencyId of snapshot.dependencies) {
-            try {
-              const dependency = await this.store.getTask(dependencyId, { includeDeleted: true });
-              if (!dependency.deletedAt) continue;
-            } catch (error3) {
-              if (!isTaskNotFoundError2(error3)) throw error3;
-            }
-            const current = await this.store.getTask(snapshot.id).catch((error3) => {
-              if (isTaskNotFoundError2(error3)) return void 0;
-              throw error3;
-            });
+            if (await readLinkedTaskOrUndefined(this.store, dependencyId)) continue;
+            const current = await readLinkedTaskOrUndefined(this.store, snapshot.id);
             if (!current || current.userPaused || current.paused || current.autoMerge === false || current.checkedOutBy || activeSessionRegistry.pathsForTask(current.id).some((path18) => activeSessionRegistry.isPathActive(path18)) || executingTaskLock.has(current.id) || this.options.getExecutingTaskIds?.().has(current.id) === true || this.options.isTaskActive?.(current.id) === true || !current.dependencies.includes(dependencyId)) continue;
             try {
               await this.store.updateTaskDependencies(current.id, { operation: "remove", dependency: dependencyId });
               removed += 1;
             } catch (error3) {
+              if (isMissingTaskLookupError(error3)) {
+                log34.debug(`reconcileMissingDependencies: skipped unreadable ${current.id} dependency ${dependencyId}`);
+                continue;
+              }
               if (!/does not depend on/i.test(error3 instanceof Error ? error3.message : String(error3))) throw error3;
             }
           }
@@ -229874,7 +230225,7 @@ var init_self_healing = __esm({
           const graceMs = 10 * 6e4;
           const now = Date.now();
           const nowIso3 = new Date(now).toISOString();
-          const live = (taskId) => activeSessionRegistry.pathsForTask(taskId).some((path18) => activeSessionRegistry.isPathActive(path18)) || executingTaskLock.has(taskId) || this.options.isTaskActive?.(taskId) === true;
+          const live = (taskId) => activeSessionRegistry.pathsForTask(taskId).some((path18) => activeSessionRegistry.isPathActive(path18)) || executingTaskLock.has(taskId) || isPlanningLive(taskId) || this.options.isTaskActive?.(taskId) === true;
           const due = await this.store.listDueWorkflowWorkItems({
             now: nowIso3,
             states: [...ACTIVE_WORKFLOW_WORK_ITEM_STATES]
@@ -230251,6 +230602,109 @@ var init_self_healing = __esm({
           return 0;
         }
       }
+      /**
+       * FNXC:PreMergeApproval 2026-09-05-22:11:
+       * FN-295: restore a required pre-merge gate that was archived as COLLATERAL of another gate's
+       * remediation, so the card stops being permanently unmergeable with no owner.
+       *
+       * The wedge needs four ingredients, none of which is individually wrong: a review row left
+       * `pending` by a dead session, the orphaned-step sweep rewriting it to `failed`, the remediation
+       * archiver stamping EVERY terminal failure (not just its own gate), and the merge door treating
+       * `remediationArchivedAt` as an unconditional veto. The result is a row the reseed cannot re-run
+       * (it handles `missing`), the stale-content reroute cannot re-run (it handles `stale-content`),
+       * and the operator bypass cannot select (it selects `status:"failed"`). Measured on FN-295: three
+       * review restarts re-ran Code Review and Documentation to APPROVE and merged nothing.
+       *
+       * This sweep does NOT approve or merge anything: it undoes the collateral archive so the gate is
+       * once again a visible failed step that the ordinary FN-7720 audited bypass — or a genuine re-run
+       * — can clear. It never touches an operator waiver, the gate that owns the remediation wave, a
+       * workspace card, a user-paused card, or a card with a live session, and it re-validates every
+       * condition inside the atomic mutation.
+       */
+      async reconcileCollateralArchivedReviewGates() {
+        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);
+          }
+          let repairedTasks = 0;
+          const isSessionLive = (taskId) => {
+            const livePaths = activeSessionRegistry.pathsForTask(taskId);
+            return livePaths.some((path18) => activeSessionRegistry.isPathActive(path18)) || executingTaskLock.has(taskId) || this.options.isTaskActive?.(taskId) === true;
+          };
+          const remediationGateIdsFor = (task) => new Set(
+            (task.steps ?? []).map((step) => step.remediation?.gateStepId).filter((gateStepId) => typeof gateStepId === "string" && gateStepId.length > 0)
+          );
+          for (const candidate of candidates.values()) {
+            if (candidate.userPaused === true || candidate.workspaceWorktrees !== void 0 || isSessionLive(candidate.id)) 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;
+            if (!(fresh.workflowStepResults ?? []).some((result2) => resolveCollateralArchivedReviewGate(result2, { remediationGateIds: remediationGateIdsFor(fresh) }))) continue;
+            let requiredPreMergeStepIds;
+            try {
+              requiredPreMergeStepIds = (await resolvePreMergeGateForTask(
+                this.store,
+                fresh.id,
+                fresh.enabledWorkflowSteps,
+                fresh
+              )).requiredPreMergeStepIds;
+            } catch {
+              continue;
+            }
+            if (requiredPreMergeStepIds.size === 0) 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 remediationGateIds = remediationGateIdsFor(live);
+                const restoredStepIds = [];
+                const results = (live.workflowStepResults ?? []).map((result2) => {
+                  if (!requiredPreMergeStepIds.has(result2.workflowStepId)) return result2;
+                  const resolution = resolveCollateralArchivedReviewGate(result2, { remediationGateIds });
+                  if (!resolution) return result2;
+                  restoredStepIds.push(result2.workflowStepId);
+                  return resolution.restored;
+                });
+                if (restoredStepIds.length === 0) return null;
+                repair = { stepIds: restoredStepIds, column: live.column, resultCount: results.length };
+                return { workflowStepResults: results };
+              });
+              if (!repair) continue;
+              repairedTasks += 1;
+            } catch (error3) {
+              log34.warn(`reconcileCollateralArchivedReviewGates: failed for ${fresh.id}: ${error3 instanceof Error ? error3.message : String(error3)}`);
+              continue;
+            }
+            await this.store.logEntry(
+              fresh.id,
+              `[pre-merge] Restored collaterally archived review gate(s): ${repair.stepIds.join(", ")}`,
+              COLLATERAL_ARCHIVED_REVIEW_GATE_DIAGNOSTIC
+            ).catch(() => void 0);
+            await emitBoundedRunAudit2(this.store, {
+              taskId: fresh.id,
+              agentId: "self-healing",
+              runId: generateSyntheticRunId("reconcile-collateral-archived-review-gate", fresh.id),
+              domain: "database",
+              mutationType: "task:reconcile-collateral-archived-review-gate",
+              target: fresh.id,
+              metadata: {
+                taskId: fresh.id,
+                column: repair.column,
+                workflowStepId: repair.stepIds[0],
+                restoredCount: repair.stepIds.length,
+                resultCount: repair.resultCount
+              }
+            }, { log: log34 });
+          }
+          if (repairedTasks > 0) log34.log(`Restored collaterally archived review gates on ${repairedTasks} task(s)`);
+          return repairedTasks;
+        } catch (error3) {
+          log34.error(`reconcileCollateralArchivedReviewGates failed: ${error3 instanceof Error ? error3.message : String(error3)}`);
+          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.
@@ -230610,25 +231064,14 @@ var init_self_healing = __esm({
       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
-        });
+      async routeStaleSingularApprovalBackToReview(task, reviewColumns, mergeGate, mergeContent, parkShape) {
         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;
+        if (!isStaleContentApprovalBlocker(blocker) || mergeContent.kind !== "singular") {
+          return { handled: false, seeded: false, parkCleared: false, mergeRetriesReset: false };
         }
         const reroute = await rerouteSingularStaleContentToReview(this.store, task, {
           requiredPreMergeStepIds: mergeGate.requiredPreMergeStepIds,
@@ -230639,11 +231082,25 @@ var init_self_healing = __esm({
           nodeId: void 0,
           workflowStepId: void 0
         }));
+        let parkCleared = false;
+        if (reroute.rerouted && parkShape) {
+          await this.store.updateTaskAtomic(task.id, (live) => {
+            if (classifyStaleContentPark(live) !== parkShape || live.paused || live.userPaused || live.deletedAt) {
+              return null;
+            }
+            parkCleared = true;
+            return { status: null, error: null, mergeRetries: 0 };
+          });
+        }
+        const mergeRetriesReset = parkCleared;
         if (reroute.rerouted) {
-          await this.store.logEntry(task.id, "[pre-merge] Self-healing re-seeded Code Review after stale content evidence blocked merge.");
+          await this.store.logEntry(task.id, `[pre-merge] Review lane '${reroute.nodeId ?? "code-review"}' approved older content; self-healing re-seeded it against current content.`);
+          if (parkCleared) {
+            await this.store.logEntry(task.id, `[pre-merge] Cleared the stale-content merge park after re-seeding review lane '${reroute.nodeId ?? "code-review"}' against current content.`);
+          }
           log34.warn(`Stale content approval for ${task.id} re-seeded at ${reroute.nodeId ?? "code-review"}`);
         }
-        const auditKey = `${task.id}:${reroute.reason}:${reroute.nodeId ?? ""}`;
+        const auditKey = `${task.id}:${reroute.reason}:${reroute.nodeId ?? ""}:${parkShape ?? ""}`;
         if (!this.staleContentRerouteAuditKeys.has(auditKey)) {
           this.staleContentRerouteAuditKeys.add(auditKey);
           await emitBoundedRunAudit2(this.store, {
@@ -230658,21 +231115,23 @@ var init_self_healing = __esm({
               nodeId: reroute.nodeId,
               workflowStepId: reroute.workflowStepId,
               reason: reroute.reason,
-              source: "self-healing"
+              source: "self-healing",
+              parkShape,
+              parkCleared,
+              mergeRetriesReset
             }
           });
         }
-        return true;
+        return {
+          handled: true,
+          seeded: reroute.rerouted,
+          nodeId: reroute.nodeId,
+          parkShape,
+          parkCleared,
+          mergeRetriesReset
+        };
       }
-      async routeUnrunPreMergeGateBackToReview(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 });
+      async routeUnrunPreMergeGateBackToReview(task, reviewColumns, mergeGate, mergeContent) {
         if (getTaskMergeBlocker(task, { reviewColumns, requiredPreMergeStepIds: mergeGate.requiredPreMergeStepIds, mergeContent }) !== "task has enabled pre-merge workflow steps that never ran") return false;
         const reroute = await rerouteUnrunPreMergeGateToReview(this.store, task, { requiredPreMergeStepIds: mergeGate.requiredPreMergeStepIds, mergeContent }).catch(() => ({ rerouted: false, reason: "no-unrun-gate", nodeId: void 0, workflowStepId: void 0 }));
         if (reroute.rerouted) {
@@ -230747,11 +231206,62 @@ var init_self_healing = __esm({
           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 (await this.routeUnrunPreMergeGateBackToReview(task, reviewColumns, settings)) continue;
-            if (getTaskMergeBlocker(task, { reviewColumns }) !== void 0) continue;
+            let mergeGate;
+            try {
+              mergeGate = await resolvePreMergeGateForTask(this.store, task.id, task.enabledWorkflowSteps, task);
+            } catch {
+              continue;
+            }
+            if (mergeGate.provenance === "default" && !mergeGate.selectionAbsent) continue;
+            const mergeContent = await captureMergeContentDescriptor(task, { workspaceRootDir: this.options.rootDir, settings });
+            if ((await this.routeStaleSingularApprovalBackToReview(task, reviewColumns, mergeGate, mergeContent)).handled) continue;
+            if (await this.routeUnrunPreMergeGateBackToReview(task, reviewColumns, mergeGate, mergeContent)) continue;
+            const blocker = getTaskMergeBlocker(task, {
+              reviewColumns,
+              requiredPreMergeStepIds: mergeGate.requiredPreMergeStepIds,
+              mergeContent
+            });
+            if (blocker !== void 0) {
+              const warningKey = `${task.id}:${blocker}`;
+              if (!this.mergeRecoveryBlockerWarnKeys.has(warningKey)) {
+                this.mergeRecoveryBlockerWarnKeys.add(warningKey);
+                log34.warn(`mergeable-review recovery declined ${task.id}: ${blocker}`);
+              }
+              continue;
+            }
             laneQualifiedMergeable.push(task);
           }
+          const hiddenStaleContentCandidateIds = /* @__PURE__ */ new Set();
+          for (const task of tasks2) {
+            if (mergeable.includes(task)) continue;
+            const parkShape = classifyStaleContentPark(task);
+            if (!parkShape || mergeAdmissionByTaskId.get(task.id) !== true || executingIds.has(task.id) || task.status === "merging" || task.status === "merging-pr") continue;
+            const reviewColumns = await ownReviewLanesFor(task);
+            if (!reviewColumns.has(task.column)) continue;
+            hiddenStaleContentCandidateIds.add(task.id);
+            const attempts = (this.staleContentParkRecoveryAttempts.get(task.id) ?? 0) + 1;
+            this.staleContentParkRecoveryAttempts.set(task.id, attempts);
+            if (attempts === MAX_STARVATION_DROPS && !this.staleContentParkRecoveryBudgetLogged.has(task.id)) {
+              this.staleContentParkRecoveryBudgetLogged.add(task.id);
+              await this.store.logEntry(task.id, `[pre-merge] Stopped stale-content park recovery after ${MAX_STARVATION_DROPS} attempts; operator attention is required.`);
+            }
+            if (attempts > MAX_STARVATION_DROPS) continue;
+            let mergeGate;
+            try {
+              mergeGate = await resolvePreMergeGateForTask(this.store, task.id, task.enabledWorkflowSteps, task);
+            } catch {
+              continue;
+            }
+            if (mergeGate.provenance === "default" && !mergeGate.selectionAbsent) continue;
+            const mergeContent = await captureMergeContentDescriptor(task, { workspaceRootDir: this.options.rootDir, settings });
+            await this.routeStaleSingularApprovalBackToReview(task, reviewColumns, mergeGate, mergeContent, parkShape);
+          }
+          for (const taskId of this.staleContentParkRecoveryAttempts.keys()) {
+            if (!hiddenStaleContentCandidateIds.has(taskId)) {
+              this.staleContentParkRecoveryAttempts.delete(taskId);
+              this.staleContentParkRecoveryBudgetLogged.delete(taskId);
+            }
+          }
           if (unresolvedMergeableCards.length > 0) {
             log34.warn(
               `mergeable-review recovery: ${unresolvedMergeableCards.length} card(s) measured against the built-in review lane because their own workflow could not be resolved (${unresolvedMergeableCards.slice(0, 5).join(", ")}); a renamed review lane there stays stuck.`
@@ -230774,6 +231284,9 @@ var init_self_healing = __esm({
           );
           const enqueueMerge = this.options.enqueueMerge;
           let recovered = 0;
+          let enqueued = 0;
+          let merged = 0;
+          let parked = 0;
           for (const task of unownedMergeable) {
             try {
               if (enqueueMerge) {
@@ -230789,19 +231302,22 @@ var init_self_healing = __esm({
                     await this.store.updateTask(task.id, { status: "failed", error: error3 });
                     await this.store.logEntry(task.id, error3);
                     this.mergeStarvationDrops.delete(task.id);
+                    parked++;
                     recovered++;
                   }
                   continue;
                 }
                 this.mergeStarvationDrops.delete(task.id);
+                enqueued++;
               } else {
                 await this.store.mergeTask(task.id);
+                merged++;
               }
               await this.store.logEntry(
                 task.id,
                 enqueueMerge ? "Auto-recovered: eligible in-review task re-enqueued for merge" : "Auto-recovered: eligible in-review task was merged and moved to done"
               );
-              log34.log(`Recovered mergeable review task ${task.id}`);
+              log34.log(enqueueMerge ? `Re-enqueued mergeable review task ${task.id} for merge` : `Merged review task ${task.id} and moved it to done`);
               recovered++;
             } catch (err) {
               const errorMessage6 = err instanceof Error ? err.message : String(err);
@@ -230809,7 +231325,7 @@ var init_self_healing = __esm({
             }
           }
           if (recovered > 0) {
-            log34.log(`Recovered ${recovered} mergeable review task(s) \u2192 done`);
+            log34.log(formatMergeableReviewRecoverySummary({ enqueued, merged, parked }));
           }
           return recovered;
         } catch (err) {
@@ -238801,7 +239317,7 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
                   planLog.warn(`${task.id} ${retryMessage}`);
                   await this.store.logEntry(task.id, retryMessage);
                   await this.updatePlanningStateIfStillCurrent(task, {
-                    status: this.restoreStatusAfterInterruptedTriageWork(task),
+                    status: await this.resolvePlanningRetryHoldStatus(task, written),
                     error: null,
                     recoveryRetryCount: decision.nextState.recoveryRetryCount,
                     nextRecoveryAt: decision.nextState.nextRecoveryAt
@@ -238838,9 +239354,13 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
                   const retryMessage = `Generated plan failed deterministic validation (${deterministicSpecFailure}) \u2014 retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay5}.`;
                   planLog.warn(`${task.id} ${retryMessage}`);
                   await this.store.logEntry(task.id, retryMessage);
-                  const restoreStatus = this.restoreStatusAfterInterruptedTriageWork(task);
+                  await this.store.logEntry(
+                    task.id,
+                    "AI spec revision requested",
+                    `Deterministic plan validation rejected the generated plan: ${deterministicSpecFailure}`
+                  ).catch(() => void 0);
                   await this.updatePlanningStateIfStillCurrent(task, {
-                    status: restoreStatus,
+                    status: await this.resolvePlanningRetryHoldStatus(task, written),
                     error: null,
                     recoveryRetryCount: decision.nextState.recoveryRetryCount,
                     nextRecoveryAt: decision.nextState.nextRecoveryAt
@@ -239010,9 +239530,10 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
                 const retryMessage = `${failureMessage} \u2014 retry ${decision.nextState.recoveryRetryCount}/${MAX_RECOVERY_RETRIES} in ${formatDelay(decision.delayMs)}.`;
                 planLog.warn(`${task.id} ${retryMessage}`);
                 await this.store.logEntry(task.id, retryMessage).catch(() => void 0);
+                const retryHoldStatus = await this.resolvePlanningRetryHoldStatus(task);
                 await this.updatePlanningStateIfStillCurrent(task, (live) => ({
                   ...persistMarker(live),
-                  status: this.restoreStatusAfterInterruptedTriageWork(task),
+                  status: retryHoldStatus,
                   error: null,
                   recoveryRetryCount: decision.nextState.recoveryRetryCount,
                   nextRecoveryAt: decision.nextState.nextRecoveryAt
@@ -239042,7 +239563,7 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
                     planLog.warn(`${task.id}: failed to log transient-error retry entry: ${msg}`);
                   });
                 }
-                const restoreStatus = this.restoreStatusAfterInterruptedTriageWork(task);
+                const restoreStatus = await this.resolvePlanningRetryHoldStatus(task);
                 await this.updatePlanningStateIfStillCurrent(task, {
                   status: restoreStatus,
                   recoveryRetryCount: decision.nextState.recoveryRetryCount,
@@ -239094,7 +239615,7 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
                 const msg = logErr instanceof Error ? logErr.message : String(logErr);
                 planLog.warn(`${task.id}: failed to log planning-failure retry entry: ${msg}`);
               });
-              const restoreStatus = this.restoreStatusAfterInterruptedTriageWork(task);
+              const restoreStatus = await this.resolvePlanningRetryHoldStatus(task);
               await this.updatePlanningStateIfStillCurrent(task, {
                 status: restoreStatus,
                 recoveryRetryCount: genericDecision.nextState.recoveryRetryCount,
@@ -239378,11 +239899,22 @@ ${lines.join("\n")}` }],
         }
         return null;
       }
+      /*
+      FNXC:TriagePlanningRetry 2026-09-05-22:06:
+      A retry over a finished-looking PROMPT.md must hold `needs-replan`, matching scheduler validation
+      retries. Clearing status makes the card dispatchable and bypasses finalizeApprovedTask approval.
+      */
+      async resolvePlanningRetryHoldStatus(task, knownPromptContent) {
+        const restored = this.restoreStatusAfterInterruptedTriageWork(task);
+        if (restored) return restored;
+        const content = knownPromptContent ?? await this.readNonEmptyPromptDraft(task.id, "planning retry hold");
+        return content && !isTaskAwaitingPlanning(task, content) ? "needs-replan" : null;
+      }
       async validateGeneratedPrompt(taskId, promptContent) {
         if (!promptContent.trim()) {
           return "PROMPT.md file not found or empty";
         }
-        const headingNumbers = Array.from(promptContent.matchAll(/^### Step (\d+):/gm), (match2) => Number(match2[1]));
+        const headingNumbers = matchStepHeadings(promptContent).map((match2) => match2.headingNumber);
         if (headingNumbers.length > 0 && !headingNumbers.every((heading, index3) => heading === index3)) {
           const diagnostic = `Step headings must be contiguous 0-based execution indices (observed: ${headingNumbers.join(", ")}). Renumber from Step 0 and update prose cross-references.`;
           planLog.warn(`${taskId}: ${diagnostic}`);
@@ -239992,6 +240524,101 @@ ${lines.join("\n")}` }],
   }
 });
 
+// ../engine/src/executor/optional-step-revision.ts
+function normalizeOptionalStepRevisionKey2(value2) {
+  return (value2 ?? "").trim().toLowerCase();
+}
+function optionalStepRevisionKey2(nodeId, stepName) {
+  return normalizeOptionalStepRevisionKey2(nodeId) || normalizeOptionalStepRevisionKey2(stepName) || "pre-merge-optional-step";
+}
+function optionalStepRevisionResetOutcome(key) {
+  return `${OPTIONAL_STEP_REVISION_RESET_MARKER} ${key}`;
+}
+function resetIndexFor(log44, normalizedKey) {
+  for (let index3 = log44.length - 1; index3 >= 0; index3 -= 1) {
+    const outcome = log44[index3]?.outcome ?? "";
+    const markerIndex = outcome.indexOf(OPTIONAL_STEP_REVISION_RESET_MARKER);
+    if (markerIndex < 0) continue;
+    const markerValue = outcome.slice(markerIndex + OPTIONAL_STEP_REVISION_RESET_MARKER.length).split(/\r?\n/, 1)[0]?.trim();
+    if (normalizeOptionalStepRevisionKey2(markerValue) === normalizedKey) return index3;
+  }
+  return -1;
+}
+function countOptionalStepRevisionAttempts2(task, key, stepName) {
+  const normalizedKey = normalizeOptionalStepRevisionKey2(key);
+  const normalizedStepName = normalizeOptionalStepRevisionKey2(stepName);
+  const log44 = task.log ?? [];
+  const since = resetIndexFor(log44, normalizedKey);
+  return (since >= 0 ? log44.slice(since + 1) : log44).filter((entry) => {
+    const action = entry.action ?? "";
+    const outcome = entry.outcome ?? "";
+    if (!/attempt \d+\//.test(action)) return false;
+    const markerIndex = outcome.indexOf(OPTIONAL_STEP_REVISION_KEY_MARKER2);
+    if (markerIndex >= 0) {
+      const markerValue = outcome.slice(markerIndex + OPTIONAL_STEP_REVISION_KEY_MARKER2.length).split(/\r?\n/, 1)[0]?.trim();
+      return normalizeOptionalStepRevisionKey2(markerValue) === normalizedKey;
+    }
+    if (!normalizedStepName) return false;
+    return normalizeOptionalStepRevisionKey2(outcome).includes(`step: ${normalizedStepName}`);
+  }).length;
+}
+function optionalStepRevisionLogOutcome2(details, key) {
+  return `${details}
+${OPTIONAL_STEP_REVISION_KEY_MARKER2} ${key}`;
+}
+function buildReviewConvergenceContext(task, options) {
+  const revisionKey = options.revisionKey;
+  const priorAttemptCount = countPlanReviewRevisionAttempts(task.workflowStepResults, { revisionKey });
+  const attempt = priorAttemptCount + 1;
+  if (attempt <= 1) return "";
+  const history = collectPlanReviewFeedbackHistory(task.workflowStepResults, { revisionKey });
+  const lines = [
+    `## Convergence \u2014 ${options.reviewKind === "plan" ? "Plan Review" : "Code Review"} attempt ${attempt}`
+  ];
+  if (options.changeSummaryBlock?.trim()) lines.push("", options.changeSummaryBlock.trim());
+  lines.push(
+    "Treat the cumulative prior feedback below as a decision primer. Verify each prior blocker against the current PROMPT.md before looking for new findings.",
+    "- Do not re-raise a resolved or semantically duplicate blocker.",
+    "- A newly blocking finding must identify the revision that introduced it, the prior blocker that genuinely masked it, or why it is independently delivery-blocking for correctness, security, data safety, or executability. Record an earlier reviewer miss explicitly; never demote a critical defect merely because it was missed before."
+  );
+  if (attempt >= 3) {
+    lines.push(
+      "- Severity ratchet (attempt 3+): only delivery-blocking critical defects may return REVISE; important/minor wording or implementation-detail findings are advisory."
+    );
+  }
+  if (history.length > 0) {
+    lines.push("", "### Cumulative prior Plan Review ledger");
+    history.forEach((feedback, index3) => lines.push(`#### PR${index3 + 1}`, feedback));
+  }
+  const own2 = task.workflowStepResults?.find((result2) => result2.workflowStepId === revisionKey);
+  const findings = (own2?.priorAttempts ?? []).flatMap((attempt2) => attempt2.findings ?? []).filter(isOpenWorkflowReviewFinding);
+  if (findings.length > 0) {
+    lines.push("", "### Your prior findings on this gate");
+    findings.forEach((finding) => lines.push(`- ${finding.id} \u2014 [${finding.severity ?? "unclassified"}] ${finding.title}: ${finding.body}${finding.filePath ? ` (${finding.filePath}${finding.line ? `:${finding.line}` : ""})` : ""}`));
+    lines.push("Match prior defects by file path, line region, and described behavior; IDs and titles may change between rounds.");
+  }
+  const disputed = findings.filter((finding) => finding.disputedAt);
+  if (disputed.length > 0) {
+    lines.push("", "### Disputed by the implementer");
+    disputed.forEach((finding) => lines.push(`- ${finding.id}: ${finding.disputeRationale ?? "No rationale recorded."}`));
+    lines.push("You MUST rule on each dispute: accept it by listing its ID in supersededFindingIds, or maintain it with a finding whose rebutsDisputedFindingId names it and whose body answers the rationale. A maintained objection needs that reference even if it has a new finding ID.");
+  }
+  return lines.join("\n");
+}
+function buildGraphPlanReviewConvergenceContext(task, revisionKey) {
+  return buildReviewConvergenceContext(task, { revisionKey, reviewKind: "plan" });
+}
+var OPTIONAL_STEP_REVISION_KEY_MARKER2, OPTIONAL_STEP_REVISION_RESET_MARKER;
+var init_optional_step_revision = __esm({
+  "../engine/src/executor/optional-step-revision.ts"() {
+    "use strict";
+    init_src2();
+    init_plan_review_feedback_history();
+    OPTIONAL_STEP_REVISION_KEY_MARKER2 = "Workflow revision key:";
+    OPTIONAL_STEP_REVISION_RESET_MARKER = "Workflow revision ledger reset:";
+  }
+});
+
 // ../engine/src/executor/workflow-gate-activity.ts
 function resolveWorkflowGateActivityClaim(routedPrincipalAgentId, assignedAgentId) {
   const agentId = routedPrincipalAgentId ?? assignedAgentId ?? "executor";
@@ -240823,7 +241450,7 @@ function extractPromptSection(promptContent, sectionName) {
   return promptContent.slice(start, end).trim();
 }
 function summarizePromptSteps(promptContent) {
-  const stepTitles = Array.from(promptContent.matchAll(/^### Step \d+:.*$/gm), (match2) => match2[0].trim());
+  const stepTitles = matchStepHeadings(promptContent).map(({ index: index3, headingLineEnd }) => promptContent.slice(index3, headingLineEnd).trim());
   if (stepTitles.length === 0) {
     return "";
   }
@@ -245594,85 +246221,6 @@ var init_review_inline_fix_recapture = __esm({
   }
 });
 
-// ../engine/src/executor/optional-step-revision.ts
-function normalizeOptionalStepRevisionKey2(value2) {
-  return (value2 ?? "").trim().toLowerCase();
-}
-function optionalStepRevisionKey2(nodeId, stepName) {
-  return normalizeOptionalStepRevisionKey2(nodeId) || normalizeOptionalStepRevisionKey2(stepName) || "pre-merge-optional-step";
-}
-function countOptionalStepRevisionAttempts2(task, key, stepName) {
-  const normalizedKey = normalizeOptionalStepRevisionKey2(key);
-  const normalizedStepName = normalizeOptionalStepRevisionKey2(stepName);
-  return (task.log ?? []).filter((entry) => {
-    const action = entry.action ?? "";
-    const outcome = entry.outcome ?? "";
-    if (!/attempt \d+\//.test(action)) return false;
-    const markerIndex = outcome.indexOf(OPTIONAL_STEP_REVISION_KEY_MARKER2);
-    if (markerIndex >= 0) {
-      const markerValue = outcome.slice(markerIndex + OPTIONAL_STEP_REVISION_KEY_MARKER2.length).split(/\r?\n/, 1)[0]?.trim();
-      return normalizeOptionalStepRevisionKey2(markerValue) === normalizedKey;
-    }
-    if (!normalizedStepName) return false;
-    return normalizeOptionalStepRevisionKey2(outcome).includes(`step: ${normalizedStepName}`);
-  }).length;
-}
-function optionalStepRevisionLogOutcome2(details, key) {
-  return `${details}
-${OPTIONAL_STEP_REVISION_KEY_MARKER2} ${key}`;
-}
-function buildReviewConvergenceContext(task, options) {
-  const revisionKey = options.revisionKey;
-  const priorAttemptCount = countPlanReviewRevisionAttempts(task.workflowStepResults, { revisionKey });
-  const attempt = priorAttemptCount + 1;
-  if (attempt <= 1) return "";
-  const history = collectPlanReviewFeedbackHistory(task.workflowStepResults, { revisionKey });
-  const lines = [
-    `## Convergence \u2014 ${options.reviewKind === "plan" ? "Plan Review" : "Code Review"} attempt ${attempt}`
-  ];
-  if (options.changeSummaryBlock?.trim()) lines.push("", options.changeSummaryBlock.trim());
-  lines.push(
-    "Treat the cumulative prior feedback below as a decision primer. Verify each prior blocker against the current PROMPT.md before looking for new findings.",
-    "- Do not re-raise a resolved or semantically duplicate blocker.",
-    "- A newly blocking finding must identify the revision that introduced it, the prior blocker that genuinely masked it, or why it is independently delivery-blocking for correctness, security, data safety, or executability. Record an earlier reviewer miss explicitly; never demote a critical defect merely because it was missed before."
-  );
-  if (attempt >= 3) {
-    lines.push(
-      "- Severity ratchet (attempt 3+): only delivery-blocking critical defects may return REVISE; important/minor wording or implementation-detail findings are advisory."
-    );
-  }
-  if (history.length > 0) {
-    lines.push("", "### Cumulative prior Plan Review ledger");
-    history.forEach((feedback, index3) => lines.push(`#### PR${index3 + 1}`, feedback));
-  }
-  const own2 = task.workflowStepResults?.find((result2) => result2.workflowStepId === revisionKey);
-  const findings = (own2?.priorAttempts ?? []).flatMap((attempt2) => attempt2.findings ?? []).filter(isOpenWorkflowReviewFinding);
-  if (findings.length > 0) {
-    lines.push("", "### Your prior findings on this gate");
-    findings.forEach((finding) => lines.push(`- ${finding.id} \u2014 [${finding.severity ?? "unclassified"}] ${finding.title}: ${finding.body}${finding.filePath ? ` (${finding.filePath}${finding.line ? `:${finding.line}` : ""})` : ""}`));
-    lines.push("Match prior defects by file path, line region, and described behavior; IDs and titles may change between rounds.");
-  }
-  const disputed = findings.filter((finding) => finding.disputedAt);
-  if (disputed.length > 0) {
-    lines.push("", "### Disputed by the implementer");
-    disputed.forEach((finding) => lines.push(`- ${finding.id}: ${finding.disputeRationale ?? "No rationale recorded."}`));
-    lines.push("You MUST rule on each dispute: accept it by listing its ID in supersededFindingIds, or maintain it with a finding whose rebutsDisputedFindingId names it and whose body answers the rationale. A maintained objection needs that reference even if it has a new finding ID.");
-  }
-  return lines.join("\n");
-}
-function buildGraphPlanReviewConvergenceContext(task, revisionKey) {
-  return buildReviewConvergenceContext(task, { revisionKey, reviewKind: "plan" });
-}
-var OPTIONAL_STEP_REVISION_KEY_MARKER2;
-var init_optional_step_revision = __esm({
-  "../engine/src/executor/optional-step-revision.ts"() {
-    "use strict";
-    init_src2();
-    init_plan_review_feedback_history();
-    OPTIONAL_STEP_REVISION_KEY_MARKER2 = "Workflow revision key:";
-  }
-});
-
 // ../engine/src/executor/execute-workflow-step.ts
 import { exec as exec44 } from "node:child_process";
 import { promisify as promisify63 } from "node:util";
@@ -246438,10 +246986,12 @@ ${JSON.stringify({ verdict: repairedVerdict })}`,
       session.dispose();
       await agentLogger.flush();
       if (parsed.verdict) {
+        const findingsUnreadable = verdictRepairResult === "repaired" && (parsed.findings?.length ?? 0) === 0;
         const gated = reviewBlockingSeverity ? applyReviewSeverityGate({
           verdict: parsed.verdict,
           findings: parsed.findings,
-          threshold: reviewBlockingSeverity
+          threshold: reviewBlockingSeverity,
+          findingsUnreadable
         }) : void 0;
         const effectiveVerdict = gated?.verdict ?? parsed.verdict;
         if (gated?.downgraded) {
@@ -260956,7 +261506,7 @@ async function routeGraphMergeFailureToRetry(deps, live, result2, abortProvenanc
   const parked = await parkTaskFailed(
     deps.store,
     live.id,
-    `AUTO_MERGE_RETRY_REJECTED: ${reason}`,
+    `${AUTO_MERGE_RETRY_REJECTED_PREFIX} ${reason}`,
     deps.getRunContextFor(live.id),
     live.columnMovedAt
   );
@@ -260972,6 +261522,7 @@ var init_route_graph_merge_failure_to_retry = __esm({
     init_logger3();
     init_workflow_merge_nodes();
     init_emit_merge_boundary_unproven_audit();
+    init_stale_content_park();
     BIT_BACKOFF_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 32e3, 64e3];
   }
 });
@@ -265633,9 +266184,13 @@ async function runImplementation(deps, task, graphCompletion, reportImplementati
          */
         credentialInstanceId: detail.credentialInstanceId,
         resolveCredentialInstanceRetarget: nextStepInstance,
-        // Attribute the per-step run auditor to the column agent when it governs
-        // (U4); absent → StepSessionExecutor falls back to assignedAgentId.
-        effectiveAgentId: stepColumnAgent?.agent.id,
+        /*
+        FNXC:ColumnAgent 2026-09-04-14:11:
+        The effective step identity is the governing column agent or the authoritative assignee.
+        Both are existence-proved reads; with empty project.boards the column seam is absent, so
+        retaining only it lost attribution for every assigned task.
+        */
+        effectiveAgentId: stepIdentityAgent?.id,
         actionGateContext: deps.buildActionGateContext(task.id, stepIdentityAgent, settings.defaultAgentPermissionPolicy),
         permanentAgentGating: deps.buildPermanentAgentGatingContext(task.id, stepIdentityAgent, settings.defaultAgentPermissionPolicy),
         // FNXC:McpConfig 2026-06-25-23:03: Per-step workflow sessions are an executor lane, so they inherit the task's resolved MCP set from the effective step identity agent and never re-read or log plaintext secret values.
@@ -270498,10 +271053,22 @@ var init_terminate_all_children = __esm({
 });
 
 // ../engine/src/executor/clear-terminal-step-failures-for-retry.ts
+function latestTerminalPreMergeFailureId(results) {
+  return (results ?? []).filter((result2) => (result2.phase || "pre-merge") === "pre-merge" && (result2.status === "failed" || result2.status === "advisory_failure")).sort((left, right) => {
+    const leftTime = Date.parse(left.completedAt || left.startedAt || "");
+    const rightTime = Date.parse(right.completedAt || right.startedAt || "");
+    return (Number.isFinite(rightTime) ? rightTime : 0) - (Number.isFinite(leftTime) ? leftTime : 0);
+  })[0]?.workflowStepId;
+}
 async function clearTerminalStepFailuresForRetry(deps, taskId, mode) {
   const live = await deps.store.getTask(taskId).catch(() => null);
   if (!live) return;
-  const cleared = mode === "archive" ? archiveTerminalWorkflowStepFailures(live.workflowStepResults) : clearTerminalWorkflowStepFailures(live.workflowStepResults);
+  const remediatedStepId = mode === "archive" ? latestTerminalPreMergeFailureId(live.workflowStepResults) : void 0;
+  const cleared = mode === "archive" ? archiveTerminalWorkflowStepFailures(
+    live.workflowStepResults,
+    void 0,
+    remediatedStepId ? { workflowStepIds: /* @__PURE__ */ new Set([remediatedStepId]) } : {}
+  ) : clearTerminalWorkflowStepFailures(live.workflowStepResults);
   if (cleared !== live.workflowStepResults) {
     await deps.store.updateTask(taskId, { workflowStepResults: cleared }, deps.getRunContextFor(taskId));
   }
@@ -275108,10 +275675,14 @@ var init_mission_execution_loop = __esm({
               for (const slice of milestone.slices) {
                 if (slice.status !== "active") continue;
                 const supersededFixes = await this.missionStore.reconcileSupersededGeneratedFixFeatures(slice.id);
-                const supersededFeatureIds = new Set(supersededFixes.featureIds);
+                const supersededFeatureIds = new Set(supersededFixes.featureIds ?? []);
+                if ((supersededFixes.repairedCount ?? 0) > 0) {
+                  loopLog.warn(`Recovery: restored ${supersededFixes.repairedCount ?? 0} generated Fix Features in slice ${slice.id}: ${(supersededFixes.repairedFeatureIds ?? []).join(", ")}`);
+                  recoveredCount += supersededFixes.repairedCount ?? 0;
+                }
                 if (supersededFixes.supersededCount > 0) {
                   loopLog.warn(
-                    `Recovery: superseded ${supersededFixes.supersededCount} generated Fix Features in slice ${slice.id} because an ancestor feature already passed validation`
+                    `Recovery: superseded ${supersededFixes.supersededCount} generated Fix Features in slice ${slice.id} because an ancestor or the Fix feature's own validation already passed`
                   );
                   recoveredCount += supersededFixes.supersededCount;
                 }
@@ -298121,7 +298692,7 @@ ${detail}`);
             metadata: { taskId: task.id, nodeId: reroute.nodeId, workflowStepId: reroute.workflowStepId, reason: reroute.reason, source: "merge-gate", missingGateCount: mergeGate.requiredPreMergeStepIds.size }
           });
         }
-        if (blocker === "task has a pre-merge approval recorded against different content" && mergeContent.kind === "singular") {
+        if (isStaleContentApprovalBlocker(blocker) && mergeContent.kind === "singular") {
           const reroute = await rerouteSingularStaleContentToReview(store, task, {
             requiredPreMergeStepIds: mergeGate.requiredPreMergeStepIds,
             mergeContent
@@ -298131,9 +298702,10 @@ ${detail}`);
             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.`);
-          }
+          await store.logEntry(
+            task.id,
+            `[pre-merge] Review lane '${reroute.nodeId ?? "unknown"}' approved older content; re-review is owned by the workflow graph (${reroute.reason}).`
+          );
           const auditKey = `${task.id}:${reroute.reason}`;
           if (!this.staleContentRerouteAuditKeys.has(auditKey)) {
             this.staleContentRerouteAuditKeys.add(auditKey);
@@ -302499,6 +303071,7 @@ __export(src_exports2, {
   NotificationService: () => NotificationService,
   NtfyNotificationProvider: () => NtfyNotificationProvider,
   NtfyNotifier: () => NtfyNotifier,
+  OPTIONAL_STEP_REVISION_RESET_MARKER: () => OPTIONAL_STEP_REVISION_RESET_MARKER,
   OVERSEER_ADVISOR_REPLY_CONTRACT: () => OVERSEER_ADVISOR_REPLY_CONTRACT,
   OVERSEER_ADVISOR_SYSTEM_PROMPT: () => OVERSEER_ADVISOR_SYSTEM_PROMPT,
   OVERSEER_WATCHED_STAGES: () => OVERSEER_WATCHED_STAGES,
@@ -302678,6 +303251,7 @@ __export(src_exports2, {
   createFusionModelRegistry: () => createFusionModelRegistry,
   createGetAgentConfigTool: () => createGetAgentConfigTool,
   createGoalRetrievalTools: () => createGoalRetrievalTools,
+  createHistoryReadTool: () => createHistoryReadTool,
   createIdeationTools: () => createIdeationTools,
   createInteractiveAiSessionWith: () => createInteractiveAiSessionWith,
   createListAgentsTool: () => createListAgentsTool,
@@ -302687,7 +303261,6 @@ __export(src_exports2, {
   createNoopLegacySeams: () => createNoopLegacySeams,
   createParseStepsHandler: () => createParseStepsHandler,
   createParsingOverseerAgent: () => createParsingOverseerAgent,
-  createPatchnodeReadTool: () => createPatchnodeReadTool,
   createPrNodeHandlers: () => createPrNodeHandlers,
   createPrimitivePromptLikeHandler: () => createPrimitivePromptLikeHandler,
   createPrimitiveStepReviewHandler: () => createPrimitiveStepReviewHandler,
@@ -302859,6 +303432,7 @@ __export(src_exports2, {
   normalizeAgentLogPaging: () => normalizeAgentLogPaging,
   normalizeJiraIssueKey: () => normalizeJiraIssueKey,
   notifyAutostashOrphans: () => notifyAutostashOrphans,
+  optionalStepRevisionResetOutcome: () => optionalStepRevisionResetOutcome,
   parseAdvisorReplyForAdvice: () => parseAdvisorReplyForAdvice,
   parseInteractiveAgentResponse: () => parseAgentResponse,
   parsePrEntityMarker: () => parsePrEntityMarker,
@@ -303048,6 +303622,7 @@ var init_src5 = __esm({
     init_postgres_migration_notice();
     init_concurrency();
     init_triage();
+    init_optional_step_revision();
     init_executor();
     init_workflow_graph_executor();
     init_workflow_graph_branches();
@@ -326943,6 +327518,13 @@ async function restartTaskStage(deps) {
       fenced = false;
       const preservedWorkspaceRepositoryRecords = Object.keys(task.workspaceWorktrees ?? {}).length;
       await store.logEntry(taskId, `Retry requested from dashboard (${plan.scope} restart in ${task.column}, discarded ${plan.discardedWorkflowStepIds.length} workflow step result(s), preserved ${preservedWorkspaceRepositoryRecords} workspace repository record(s), re-entering at ${plan.entryNodeId})`);
+      for (const workflowStepId of plan.discardedWorkflowStepIds) {
+        await store.logEntry(
+          taskId,
+          `Revision budget reset for '${workflowStepId}' by operator retry`,
+          optionalStepRevisionResetOutcome(workflowStepId)
+        ).catch(() => void 0);
+      }
       const updated = await store.getTask(taskId);
       if (!updated) throw notFound(`Task ${taskId} not found after retry`);
       return updated;
@@ -330057,8 +330639,9 @@ See \`GET /api/tasks/${task.id}/diff\` for the landed diff being reverted.
         );
       }
       const { store: scopedStore } = await getProjectContext2(req);
-      const archived = await scopedStore.archiveAllDone();
-      res.json({ archived });
+      const result2 = await scopedStore.archiveAllDone();
+      const { archived, skipped } = Array.isArray(result2) ? { archived: result2, skipped: [] } : result2;
+      res.json({ archived, skipped });
     } catch (err) {
       if (err instanceof ApiError) {
         throw err;
@@ -335169,6 +335752,261 @@ var init_task_planner_chat_metrics = __esm({
   }
 });
 
+// ../dashboard/src/chat-conversation-references.ts
+function textResult(text4, details = {}) {
+  return { content: [{ type: "text", text: text4 }], details };
+}
+function errorResult(text4 = UNAVAILABLE_TOOL_MESSAGE) {
+  return { content: [{ type: "text", text: text4 }], isError: true, details: {} };
+}
+function clampInteger(value2, fallback2, minimum, maximum) {
+  if (typeof value2 !== "number" || !Number.isFinite(value2)) return fallback2;
+  return Math.min(maximum, Math.max(minimum, Math.trunc(value2)));
+}
+function truncateText2(value2, maximum) {
+  if (value2.length <= maximum) return { text: value2, truncated: false };
+  if (maximum <= 1) return { text: "\u2026".slice(0, maximum), truncated: true };
+  return { text: `${value2.slice(0, maximum - 1)}\u2026`, truncated: true };
+}
+function boundToolResponse(value2, hint) {
+  if (value2.length <= CONVERSATION_TOOL_RESPONSE_MAX_CHARS) return value2;
+  const prefixLength = CONVERSATION_TOOL_RESPONSE_MAX_CHARS - hint.length - 2;
+  return `${value2.slice(0, prefixLength)}
+
+${hint}`;
+}
+function wrapReferenceBlock(id, body) {
+  return `[Referenced Conversation: ${id}]
+${body}
+[/Referenced Conversation: ${id}]`;
+}
+function formatModel(session) {
+  if (session.modelProvider && session.modelId) return `${session.modelProvider}/${session.modelId}`;
+  return session.modelId ?? session.modelProvider ?? "default";
+}
+function formatSessionHeader(session, currentSessionId) {
+  return [
+    `Conversation: ${session.id}${session.id === currentSessionId ? " (current conversation)" : ""}`,
+    `Title: ${session.title ?? "Untitled"}`,
+    `Status: ${session.status}`,
+    `Agent: ${session.agentId}`,
+    `Model: ${formatModel(session)}`,
+    `Created: ${session.createdAt}`,
+    `Updated: ${session.updatedAt}`
+  ].join("\n");
+}
+function formatMessage(message, maximum) {
+  const content = truncateText2(message.content, maximum);
+  return {
+    text: `[${message.role} @ ${message.createdAt}] ${content.text}`,
+    truncated: content.truncated
+  };
+}
+async function resolveProjectSession(chatStore, conversationId, projectId2) {
+  try {
+    const session = await chatStore.getSession(conversationId);
+    return session?.projectId === projectId2 ? session : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseConversationReferences(content) {
+  const references = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pattern = /(?:^|[\s,.;:!?"'()[\]{}])#(chat-[a-zA-Z0-9]{8})(?![./a-zA-Z0-9-])/g;
+  let match2;
+  while ((match2 = pattern.exec(content)) !== null) {
+    const id = match2[1];
+    if (seen.has(id)) continue;
+    seen.add(id);
+    references.push(id);
+    if (references.length >= MAX_REFERENCED_CONVERSATIONS) break;
+  }
+  return references;
+}
+async function buildConversationReferenceContext(input) {
+  const references = parseConversationReferences(input.content);
+  if (references.length === 0) return "";
+  const blocks = await Promise.all(references.map(async (id) => {
+    try {
+      const session = await input.chatStore.getSession(id);
+      if (!session || session.projectId !== input.currentProjectId) {
+        return wrapReferenceBlock(id, UNAVAILABLE_CONTEXT_MESSAGE);
+      }
+      if (session.id === input.currentSessionId) {
+        return wrapReferenceBlock(
+          id,
+          "Current conversation: this ID refers to the current conversation; no preview was added."
+        );
+      }
+      const messages3 = await input.chatStore.getMessages(id, {
+        limit: CONVERSATION_PREVIEW_MESSAGE_COUNT,
+        order: "desc"
+      });
+      const preview2 = messages3.length > 0 ? messages3.map((message) => formatMessage(message, CONVERSATION_PREVIEW_MESSAGE_CHARS).text).join("\n") : "(no messages)";
+      return wrapReferenceBlock(
+        id,
+        [
+          formatSessionHeader(session, input.currentSessionId),
+          "Recent messages (newest first):",
+          preview2,
+          "Use fn_chat_conversation_read or fn_chat_conversation_search for more detail."
+        ].join("\n")
+      );
+    } catch {
+      return wrapReferenceBlock(id, UNAVAILABLE_CONTEXT_MESSAGE);
+    }
+  }));
+  return blocks.join("\n\n");
+}
+function createConversationReadTool(chatStore, options) {
+  return {
+    name: "fn_chat_conversation_read",
+    label: "Read Chat Conversation",
+    description: "Read a bounded page of messages from a conversation in the current Direct chat project. Requires an explicit conversation_id.",
+    parameters: {
+      type: "object",
+      properties: {
+        conversation_id: { type: "string" },
+        limit: { type: "number", minimum: 1 },
+        offset: { type: "number", minimum: 0 },
+        order: { type: "string", enum: ["asc", "desc"] }
+      },
+      required: ["conversation_id"],
+      additionalProperties: false
+    },
+    execute: async (_toolCallId, raw) => {
+      const conversationId = typeof raw.conversation_id === "string" ? raw.conversation_id.trim() : "";
+      if (!conversationId) return errorResult();
+      const session = await resolveProjectSession(chatStore, conversationId, options.projectId);
+      if (!session) return errorResult();
+      const limit2 = clampInteger(raw.limit, CONVERSATION_READ_DEFAULT_LIMIT, 1, CONVERSATION_READ_MAX_LIMIT);
+      const offset = clampInteger(raw.offset, 0, 0, Number.MAX_SAFE_INTEGER);
+      const order = raw.order === "asc" ? "asc" : "desc";
+      try {
+        const messages3 = await chatStore.getMessages(conversationId, { limit: limit2, offset, order });
+        let messageTruncated = false;
+        const rows = messages3.map((message) => {
+          const formatted = formatMessage(message, CONVERSATION_MESSAGE_MAX_CHARS);
+          messageTruncated ||= formatted.truncated;
+          return formatted.text;
+        });
+        const body = [
+          formatSessionHeader(session, options.currentSessionId),
+          `Messages (${order}, limit ${limit2}, offset ${offset}):`,
+          rows.length > 0 ? rows.join("\n") : "(no messages)",
+          ...messageTruncated ? [MESSAGE_TRUNCATION_HINT] : []
+        ].join("\n");
+        return textResult(boundToolResponse(body, READ_GLOBAL_TRUNCATION_HINT), {
+          conversationId,
+          count: messages3.length,
+          limit: limit2,
+          offset,
+          order
+        });
+      } catch {
+        return errorResult(TOOL_READ_ERROR_MESSAGE);
+      }
+    }
+  };
+}
+function createSearchExcerpt(content, matchIndex, queryLength) {
+  if (content.length <= CONVERSATION_SEARCH_EXCERPT_CHARS) return content;
+  const bodyLength = CONVERSATION_SEARCH_EXCERPT_CHARS - 2;
+  const contextBudget = Math.max(0, bodyLength - Math.min(queryLength, bodyLength));
+  let start = Math.max(0, matchIndex - Math.floor(contextBudget / 2));
+  start = Math.min(start, content.length - bodyLength);
+  const end = Math.min(content.length, start + bodyLength);
+  return `${start > 0 ? "\u2026" : ""}${content.slice(start, end)}${end < content.length ? "\u2026" : ""}`;
+}
+function createConversationSearchTool(chatStore, options) {
+  return {
+    name: "fn_chat_conversation_search",
+    label: "Search Chat Conversation",
+    description: "Search recent messages in one conversation in the current Direct chat project using a literal case-insensitive query.",
+    parameters: {
+      type: "object",
+      properties: {
+        conversation_id: { type: "string" },
+        query: { type: "string", minLength: 1 },
+        limit: { type: "number", minimum: 1 }
+      },
+      required: ["conversation_id", "query"],
+      additionalProperties: false
+    },
+    execute: async (_toolCallId, raw) => {
+      const conversationId = typeof raw.conversation_id === "string" ? raw.conversation_id.trim() : "";
+      const query = typeof raw.query === "string" ? raw.query.trim() : "";
+      if (!conversationId) return errorResult();
+      if (!query) return errorResult("ERROR: query must be a non-empty string.");
+      const session = await resolveProjectSession(chatStore, conversationId, options.projectId);
+      if (!session) return errorResult();
+      const limit2 = clampInteger(raw.limit, CONVERSATION_SEARCH_DEFAULT_LIMIT, 1, CONVERSATION_SEARCH_MAX_MATCHES);
+      try {
+        const messages3 = await chatStore.getMessages(conversationId, {
+          limit: CONVERSATION_SEARCH_SCAN_LIMIT,
+          order: "desc"
+        });
+        const normalizedQuery = query.toLocaleLowerCase();
+        const matches = [];
+        for (const message of messages3) {
+          const matchIndex = message.content.toLocaleLowerCase().indexOf(normalizedQuery);
+          if (matchIndex < 0) continue;
+          matches.push(
+            `[${message.role} @ ${message.createdAt}] ${createSearchExcerpt(message.content, matchIndex, query.length)}`
+          );
+          if (matches.length >= limit2) break;
+        }
+        const saturated = messages3.length >= CONVERSATION_SEARCH_SCAN_LIMIT;
+        const body = [
+          formatSessionHeader(session, options.currentSessionId),
+          `Search query: ${query}`,
+          matches.length > 0 ? matches.join("\n") : "(no matches)",
+          ...saturated ? [`[Search window saturated at the ${CONVERSATION_SEARCH_SCAN_LIMIT} most recent messages; older matches may exist.]`] : []
+        ].join("\n");
+        return textResult(boundToolResponse(body, SEARCH_GLOBAL_TRUNCATION_HINT), {
+          conversationId,
+          matchCount: matches.length,
+          limit: limit2,
+          scannedCount: messages3.length,
+          saturated
+        });
+      } catch {
+        return errorResult(TOOL_READ_ERROR_MESSAGE);
+      }
+    }
+  };
+}
+function createChatConversationTools(chatStore, options) {
+  return [
+    createConversationReadTool(chatStore, options),
+    createConversationSearchTool(chatStore, options)
+  ];
+}
+var MAX_REFERENCED_CONVERSATIONS, CONVERSATION_PREVIEW_MESSAGE_COUNT, CONVERSATION_PREVIEW_MESSAGE_CHARS, CONVERSATION_READ_DEFAULT_LIMIT, CONVERSATION_READ_MAX_LIMIT, CONVERSATION_SEARCH_DEFAULT_LIMIT, CONVERSATION_SEARCH_MAX_MATCHES, CONVERSATION_SEARCH_SCAN_LIMIT, CONVERSATION_SEARCH_EXCERPT_CHARS, CONVERSATION_MESSAGE_MAX_CHARS, CONVERSATION_TOOL_RESPONSE_MAX_CHARS, UNAVAILABLE_CONTEXT_MESSAGE, UNAVAILABLE_TOOL_MESSAGE, TOOL_READ_ERROR_MESSAGE, READ_GLOBAL_TRUNCATION_HINT, SEARCH_GLOBAL_TRUNCATION_HINT, MESSAGE_TRUNCATION_HINT;
+var init_chat_conversation_references = __esm({
+  "../dashboard/src/chat-conversation-references.ts"() {
+    "use strict";
+    MAX_REFERENCED_CONVERSATIONS = 3;
+    CONVERSATION_PREVIEW_MESSAGE_COUNT = 5;
+    CONVERSATION_PREVIEW_MESSAGE_CHARS = 300;
+    CONVERSATION_READ_DEFAULT_LIMIT = 30;
+    CONVERSATION_READ_MAX_LIMIT = 100;
+    CONVERSATION_SEARCH_DEFAULT_LIMIT = 10;
+    CONVERSATION_SEARCH_MAX_MATCHES = 25;
+    CONVERSATION_SEARCH_SCAN_LIMIT = 400;
+    CONVERSATION_SEARCH_EXCERPT_CHARS = 200;
+    CONVERSATION_MESSAGE_MAX_CHARS = 1500;
+    CONVERSATION_TOOL_RESPONSE_MAX_CHARS = 12e3;
+    UNAVAILABLE_CONTEXT_MESSAGE = "Unavailable: no conversation with this ID exists in this project.";
+    UNAVAILABLE_TOOL_MESSAGE = "ERROR: no conversation with this ID exists in this project.";
+    TOOL_READ_ERROR_MESSAGE = "ERROR: conversation messages could not be read.";
+    READ_GLOBAL_TRUNCATION_HINT = "[Output truncated. Retry with a smaller limit or a larger offset.]";
+    SEARCH_GLOBAL_TRUNCATION_HINT = "[Output truncated. Retry with a smaller limit or a narrower query.]";
+    MESSAGE_TRUNCATION_HINT = "[Some messages were truncated. Retry with a smaller limit or a different offset.]";
+  }
+});
+
 // ../dashboard/src/chat.ts
 var chat_exports = {};
 __export(chat_exports, {
@@ -335487,15 +336325,32 @@ function createTaskVerificationTools(taskStore, actionGateContext) {
   ];
 }
 async function createChatFusionToolset(options) {
-  const { taskStore, agentStore, rootDir, agentId, missionMutationGated = false, actionGateContext, focus } = options;
+  const {
+    taskStore,
+    agentStore,
+    rootDir,
+    agentId,
+    missionMutationGated = false,
+    actionGateContext,
+    focus,
+    chatStore,
+    currentChatSessionId,
+    currentProjectId
+  } = options;
   const tools = [];
+  if (chatStore && currentChatSessionId) {
+    tools.push(...createChatConversationTools(chatStore, {
+      currentSessionId: currentChatSessionId,
+      projectId: currentProjectId ?? null
+    }));
+  }
   if (taskStore) {
     const settings = await taskStore.getSettings?.();
     tools.push(
       createTaskListTool(taskStore),
       createTaskShowTool(taskStore),
       createTaskSearchTool(taskStore),
-      createPatchnodeReadTool(taskStore),
+      createHistoryReadTool(taskStore),
       ...createTaskVerificationTools(taskStore, options.actionGateContext),
       createTaskCreateTool(taskStore, { sourceType: "api" }, { rootDir })
     );
@@ -335921,6 +336776,7 @@ var init_chat = __esm({
     init_task_planner_chat_context();
     init_task_planner_chat_metrics();
     init_sse2();
+    init_chat_conversation_references();
     init_src5();
     init_src5();
     createFnAgent9 = createFnAgent2;
@@ -337231,7 +338087,16 @@ ${taskContext}`;
 ${mentionContext}`;
             }
           }
-          const resolvedContent = await resolveFileReferences(parsedSkillCommands.strippedContent, this.rootDir);
+          const fileResolvedContent = await resolveFileReferences(parsedSkillCommands.strippedContent, this.rootDir);
+          const conversationReferenceContext = await buildConversationReferenceContext({
+            chatStore: this.chatStore,
+            content: parsedSkillCommands.strippedContent,
+            currentSessionId: sessionId,
+            currentProjectId: session.projectId ?? null
+          });
+          const resolvedContent = conversationReferenceContext ? `${fileResolvedContent}
+
+${conversationReferenceContext}` : fileResolvedContent;
           const attachmentSummary = attachments && attachments.length > 0 ? `[User attached: ${attachments.map((attachment) => `${attachment.originalName} (${attachment.mimeType}, ${formatAttachmentSize(attachment.size)})`).join(", ")}]` : "";
           const { attachmentContents, imageContents } = await readChatAttachmentContents(
             this.rootDir,
@@ -337303,7 +338168,10 @@ ${mentionContext}`;
             toolset applies it only while experimentalFeatures.chatFocus is enabled. Otherwise the
             value is inert and both direct and room chat recall remain whole-project.
             */
-            focus: session?.memoryFocus ?? void 0
+            focus: session?.memoryFocus ?? void 0,
+            chatStore: this.chatStore,
+            currentChatSessionId: sessionId,
+            currentProjectId: session?.projectId ?? null
           });
           const customTools = dedupeChatTools([
             createAskQuestionTool(),
@@ -375222,12 +376090,9 @@ var init_dashboard_views = __esm({
       { id: "board", label: "Board", labelKey: "nav.board" },
       { id: "list", label: "List", labelKey: "nav.list" },
       /*
-        FNXC:PatchnoteNaming 2026-08-30-01:40:
-        Operators call the delivery history Patchnote. Keep the stable `patchnode` identifier and translation key unchanged because routes, storage, and integrations depend on them.
-      
-        FNXC:PatchnoteNaming 2026-08-30-06:36:
-        Operators now call the delivery history History. The stable `patchnode` identifier and translation key remain unchanged for routes, storage, persisted mobile-nav preferences, and integrations.
-        */
+      FNXC:HistoryNaming 2026-09-04-09:35:
+      Operators call this destination History, and chat exposes it as `fn_history_read`. The `patchnode` view id, `nav.patchnode` key, `GET /api/patchnode` route, `project.patchnode_entries` table, and persisted mobile-navigation preferences intentionally remain unchanged.
+      */
       { id: "patchnode", label: "History", labelKey: "nav.patchnode" },
       { id: "graph", label: "Graph" },
       { id: "agents", label: "Agents", labelKey: "nav.agents" },
@@ -397985,12 +398850,12 @@ async function rebuildProjectKnowledgeGraph(store, options = {}) {
     rebuilds.delete(graphDir);
   }
 }
-function clampInteger(value2, fallback2, minimum, maximum) {
+function clampInteger2(value2, fallback2, minimum, maximum) {
   return typeof value2 === "number" && Number.isFinite(value2) ? Math.min(maximum, Math.max(minimum, Math.trunc(value2))) : fallback2;
 }
 function findBoundedShortestPath(graph, fromId, toId, options = {}) {
-  const maxHops = clampInteger(options.maxHops, KNOWLEDGE_GRAPH_PATH_DEFAULT_HOPS, 1, KNOWLEDGE_GRAPH_PATH_MAX_HOPS);
-  const maxExpansions = clampInteger(options.maxExpansions, KNOWLEDGE_GRAPH_PATH_MAX_EXPANSIONS, 1, KNOWLEDGE_GRAPH_PATH_MAX_EXPANSIONS);
+  const maxHops = clampInteger2(options.maxHops, KNOWLEDGE_GRAPH_PATH_DEFAULT_HOPS, 1, KNOWLEDGE_GRAPH_PATH_MAX_HOPS);
+  const maxExpansions = clampInteger2(options.maxExpansions, KNOWLEDGE_GRAPH_PATH_MAX_EXPANSIONS, 1, KNOWLEDGE_GRAPH_PATH_MAX_EXPANSIONS);
   const nodes2 = new Map(graph.nodes.map((node) => [node.id, node]));
   if (!nodes2.has(fromId) || !nodes2.has(toId)) throw new KnowledgeGraphError("Unknown graph node");
   if (fromId === toId) return { outcome: "found", path: { nodes: [nodes2.get(fromId)], edges: [] }, hops: 0, maxHops, expansions: 0, truncated: false };