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

package/dist/child-process-worker.js

@@ -1919,10 +1919,11 @@ function toSnapshot(result) {
   const { priorAttempts: _drop, ...rest } = result;
   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 = (result) => isTerminalFailure(result) && (!options.workflowStepIds || options.workflowStepIds.has(result.workflowStepId));
+  if (!results?.some(inScope)) return results;
   return results.map((result) => {
-    if (!isTerminalFailure(result)) return result;
+    if (!inScope(result)) return result;
     const snapshot = toSnapshot(result);
     const priorAttempts = [snapshot, ...result.priorAttempts ?? []].slice(0, MAX_WORKFLOW_STEP_PRIOR_ATTEMPTS);
     const {
@@ -2098,6 +2099,26 @@ function isAuditedOperatorBypass(result) {
     actor && !AUTOMATED_BYPASS_ACTORS.has(actor) && result.bypassedAt?.trim() && result.bypassReason?.trim()
   );
 }
+function resolveCollateralArchivedReviewGate(result, options) {
+  const archivedFrom = result.remediationArchivedFromStatus;
+  if ((result.phase ?? "pre-merge") !== "pre-merge" || result.status !== "skipped" || result.remediationArchivedAt == null || result.bypassedBy !== void 0 || archivedFrom !== "failed" && archivedFrom !== "advisory_failure" || options.remediationGateIds.has(result.workflowStepId)) {
+    return void 0;
+  }
+  const {
+    remediationArchivedAt: _archivedAt,
+    remediationArchivedFromStatus: _archivedFrom,
+    ...rest
+  } = result;
+  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(result, options) {
   if ((result.phase ?? "pre-merge") !== "pre-merge" || !requiresContentReviewProof(result.workflowStepId, result) || options.workspace || result.status !== "passed" || result.verdict !== "APPROVE" && result.verdict !== "APPROVE_WITH_NOTES" || result.reviewInputFingerprint !== void 0 || result.bypassedBy !== void 0 || result.remediationArchivedAt != null) {
     return void 0;
@@ -2129,9 +2150,10 @@ function evaluateStep(workflowStepId, results, task, descriptor) {
     const isPlanDomain = workflowStepId === PLAN_REVIEW_GROUP_ID || result.reviewKind === "plan";
     const notRunApproves = isWorkflowStepNotRun(result) && !requiresAuthoredVerdict && !isPlanDomain;
     const approved = result.status === "passed" && (requiresAuthoredVerdict ? approvedVerdict : result.verdict === void 0 || approvedVerdict) || result.status === "skipped" && !!result.bypassedBy || notRunApproves;
-    if (!approved || !!result.remediationArchivedAt) return { workflowStepId, state: "not-approved" };
+    const auditedOperatorWaiver = isAuditedOperatorBypass(result) && descriptor?.kind !== "workspace";
+    if (!approved || result.remediationArchivedAt != null && !auditedOperatorWaiver) return { workflowStepId, state: "not-approved" };
     if (result.reviewKind === "plan") return { workflowStepId, state: "approved" };
-    if (isAuditedOperatorBypass(result) && descriptor?.kind !== "workspace") {
+    if (auditedOperatorWaiver) {
       return { workflowStepId, state: "approved" };
     }
     const bindsContent = requiresExplicitVerdict || result.reviewInputFingerprint !== void 0;
@@ -2164,7 +2186,7 @@ function evaluateStep(workflowStepId, results, task, descriptor) {
   if (stale.length) return { workflowStepId, state: "stale-content", repositories: stale };
   return { workflowStepId, state: "approved" };
 }
-var AUTOMATED_BYPASS_ACTORS, UNPROVEN_REVIEW_APPROVAL_DIAGNOSTIC;
+var 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";
@@ -2173,6 +2195,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.";
   }
 });
 
@@ -2281,6 +2304,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;
@@ -2302,8 +2328,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((result) => {
     const phase = result.phase || "pre-merge";
@@ -2320,11 +2348,14 @@ function getTaskMergeBlocker(task, options = {}) {
   return void 0;
 }
 function getLatestFailedPreMergeReviewStep(task) {
-  return (task.workflowStepResults ?? []).filter((result) => (result.phase || "pre-merge") === "pre-merge" && result.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 = (result) => (result.phase || "pre-merge") === "pre-merge";
+  return results.filter((result) => isPreMerge(result) && result.status === "failed").sort(recentFirst)[0] ?? results.filter((result) => isPreMerge(result) && isArchivedRemediationCarrier(result) && (result.remediationArchivedFromStatus === "failed" || result.remediationArchivedFromStatus === "advisory_failure") && !result.bypassedBy && !result.supersededAt).sort(recentFirst)[0];
 }
 function clearMergeConfirmedTransientStatus(status) {
   return status !== void 0 && MERGE_CONFIRMED_TRANSIENT_STATUSES.has(status) ? void 0 : status;
@@ -2408,13 +2439,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([
@@ -2458,6 +2490,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;
@@ -6437,8 +6470,9 @@ function renderValidationCause(diagnostics) {
 }
 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")
   };
 }
@@ -6502,7 +6536,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"];
@@ -13609,7 +13644,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 open3 = all.filter(isActionableReviewFinding);
   const resolved = all.filter((finding) => !isActionableReviewFinding(finding));
@@ -13617,6 +13652,7 @@ function applyReviewSeverityGate({ verdict, findings, threshold }) {
   const advisory = open3.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) {
@@ -18358,6 +18394,18 @@ function detectWorkflowDrift(ir2, pin) {
 function defaultCodingWorkflowIr() {
   return resolveDefaultWorkflowIr();
 }
+async function prefetchWorkflowSelections(store, taskIds, cache) {
+  const missingIds = [...new Set(taskIds)].filter((id) => !cache.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) cache.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;
@@ -18576,9 +18624,9 @@ function resolveLifecycleColumns(ir2) {
     archived: first(LIFECYCLE_ROLE_FLAGS.archived)
   };
 }
-async function resolveTaskLifecycleColumns(store, taskId, cache) {
+async function resolveTaskLifecycleColumns(store, taskId, cache, selectionCache) {
   try {
-    const ir2 = await resolveWorkflowIrForTask(store, taskId, cache);
+    const ir2 = await resolveWorkflowIrForTask(store, taskId, cache, selectionCache);
     return resolveLifecycleColumns(ir2);
   } catch {
     return void 0;
@@ -30574,18 +30622,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 match;
   while ((match = stepRegex.exec(content)) !== null) {
     const heading = /^###\s+Step\s+(\d+)/.exec(match[0]);
-    if (heading) {
-      matches.push({ full: match[0], name: match[1], headingNumber: Number(heading[1]) });
-    }
+    if (!heading) continue;
+    const index2 = match.index;
+    const newline = content.indexOf("\n", index2);
+    matches.push({
+      headingNumber: Number(heading[1]),
+      index: index2,
+      headingLineEnd: newline === -1 ? content.length : newline,
+      match: match[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 match;
   const offset = resolveAuthoredStepHeadingOffset(matches.map((entry) => entry.headingNumber));
   for (const { full, name: legacyName } of matches) {
     if (!full.includes("(depends:")) {
@@ -75182,8 +75245,8 @@ function appendAgentLogEntriesSync(taskDir, entries) {
   if (entries.length === 0) return [];
   const filePath = getAgentLogFilePath(taskDir);
   mkdirSync5(dirname14(filePath), { recursive: true });
-  const startingLineNo = countLineNumbers(filePath);
-  const payload = entries.map((entry) => serializeEntry(entry)).join("");
+  const { lineCount: startingLineNo, endsWithNewline } = inspectAgentLogTail(filePath);
+  const payload = `${startingLineNo > 0 && !endsWithNewline ? "\n" : ""}${entries.map((entry) => serializeEntry(entry)).join("")}`;
   appendFileSync(filePath, payload, "utf8");
   return entries.map((entry, index2) => materializeEntry(entry, startingLineNo + index2 + 1));
 }
@@ -75219,6 +75282,7 @@ function readAllAgentLogEntries(taskDir, options = {}) {
   }
   const lines = content.split("\n");
   const entries = [];
+  const skippedLines = [];
   for (let index2 = 0; index2 < lines.length; index2 += 1) {
     const rawLine = lines[index2];
     if (!rawLine) continue;
@@ -75240,9 +75304,18 @@ function readAllAgentLogEntries(taskDir, options = {}) {
       }
       entries.push(entry);
     } catch (error2) {
-      log7.warn(`Skipping malformed JSONL line ${lineNo} in ${filePath}`, error2);
+      skippedLines.push({
+        lineNo,
+        message: error2 instanceof Error ? error2.message : String(error2)
+      });
     }
   }
+  const firstSkipped = skippedLines[0];
+  if (firstSkipped) {
+    log7.warn(
+      `Skipped ${skippedLines.length} malformed JSONL line(s) in ${filePath}; first line ${firstSkipped.lineNo}: ${firstSkipped.message}`
+    );
+  }
   return entries;
 }
 function normalizeTimingMs(value) {
@@ -75285,16 +75358,19 @@ function materializeEntry(entry, lineNo) {
     sourceRef: buildAgentLogSourceRef(entry.taskId, lineNo)
   };
 }
-function countLineNumbers(filePath) {
+function inspectAgentLogTail(filePath) {
   if (!existsSync16(filePath)) {
-    return 0;
+    return { lineCount: 0, endsWithNewline: true };
   }
   const content = readFileSync7(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 || !existsSync16(tasksDir)) {
@@ -79084,6 +79160,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);
@@ -79108,7 +79188,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) {
@@ -79117,8 +79232,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);
@@ -79128,7 +79242,9 @@ ${reasonText}` : void 0)].filter(Boolean).join("\n\n") || void 0;
         }
         return {
           supersededCount: supersededFeatureIds.length,
-          featureIds: supersededFeatureIds
+          featureIds: supersededFeatureIds,
+          repairedCount: repairedFeatureIds.length,
+          repairedFeatureIds
         };
       }
       /**
@@ -82472,10 +82588,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);
@@ -82505,14 +82623,14 @@ var init_async_mission_store = __esm({
           let updated;
           let run;
           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");
             }
@@ -82524,13 +82642,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);
@@ -82998,10 +83116,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();
@@ -83009,13 +83177,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);
@@ -83030,13 +83197,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);
@@ -88668,19 +88836,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 [index2, result] of settled.entries()) {
+      const id = ids[index2];
+      if (result.status === "fulfilled") {
+        archived.push(result.value);
+        archivedIds.add(id);
+      } else {
+        const error2 = result.reason;
+        const blockers = error2 instanceof TaskHasLineageChildrenError ? error2.childIds : error2 instanceof TaskHasDependentsError ? error2.dependentIds : [];
+        skipped.push({ id, reason: "archive-failed", blockers, message: error2 instanceof Error ? error2.message : String(error2) });
+      }
+      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 lifecycle = taskId ? await resolveTaskLifecycleColumns(store, taskId) : void 0;
@@ -89144,6 +89374,7 @@ var init_task_artifacts_ops = __esm({
     init_types();
     init_store();
     init_project_lane_vocabulary();
+    init_errors3();
     LEGACY_ARCHIVE_LANES = ["archived"];
   }
 });
@@ -107015,18 +107246,18 @@ function hasFreshAgentLogActivitySinceTaskUpdate(store, task, now, reviewColumns
   }
   return Math.max(0, now - latestAgentLogMs) < DEFAULT_STALE_MERGING_MIN_AGE_MS;
 }
-async function resolveHoldColumnForTask(store, taskId, cache) {
+async function resolveHoldColumnForTask(store, taskId, cache, selectionCache) {
   try {
-    const lifecycle = resolveLifecycleColumns(await resolveWorkflowIrForTask(store, taskId, cache));
+    const lifecycle = resolveLifecycleColumns(await resolveWorkflowIrForTask(store, taskId, cache, selectionCache));
     return lifecycle?.hold ?? "todo";
   } catch {
     return "todo";
   }
 }
-async function resolveReviewColumnsForTask(store, taskId, cache) {
+async function resolveReviewColumnsForTask(store, taskId, cache, selectionCache) {
   const columns = /* @__PURE__ */ new Set(["in-review"]);
   try {
-    const ir2 = await resolveWorkflowIrForTask(store, taskId, cache);
+    const ir2 = await resolveWorkflowIrForTask(store, taskId, cache, selectionCache);
     if (ir2) for (const id of resolveReviewColumns(ir2)) columns.add(id);
   } catch {
   }
@@ -107147,6 +107378,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,
@@ -107157,7 +107394,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, {
@@ -107189,7 +107426,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
     });
@@ -107199,7 +107436,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;
@@ -107278,12 +107515,14 @@ async function listTasksModifiedSinceImpl(store, since, limit, 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) => {
@@ -107401,10 +107640,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, {
@@ -108644,6 +108885,7 @@ var init_store = __esm({
     init_async_self_healing();
     init_task_merge();
     init_required_pre_merge_steps();
+    init_pre_merge_approval();
     init_logger2();
     init_project_root_guard();
     init_agent_store();
@@ -110409,29 +110651,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((result) => result.workflowStepId === workflowStepId)) : void 0;
-          if (!failedTarget && !absentStepId) {
+          const requiredForBypass = reviewIrForBypass ? [...resolveRequiredPreMergeStepIds(reviewIrForBypass, task.enabledWorkflowSteps, task)] : [];
+          const absentStepId = requiredForBypass.find((workflowStepId) => !results.some((result) => result.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((result) => result.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,
@@ -110465,8 +110713,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
             }
           });
@@ -110528,9 +110776,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 = {
@@ -141038,6 +141285,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,
@@ -141440,6 +141688,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,
@@ -142169,6 +142418,7 @@ __export(src_exports, {
   isSqliteLockError: () => isSqliteLockError,
   isSqliteMigrationComplete: () => isSqliteMigrationComplete,
   isStaleBlockedByBlocker: () => isStaleBlockedByBlocker,
+  isStaleContentApprovalBlocker: () => isStaleContentApprovalBlocker,
   isStoredAuthCredential: () => isStoredAuthCredential,
   isStrictDescendantPath: () => isStrictDescendantPath,
   isTailscaleCgnatIpv4: () => isTailscaleCgnatIpv4,
@@ -142248,6 +142498,7 @@ __export(src_exports, {
   mapRoleToCapability: () => mapRoleToCapability,
   markDraftSummarized: () => markDraftSummarized,
   markdownHtmlCommentUnits: () => markdownHtmlCommentUnits,
+  matchStepHeadings: () => matchStepHeadings,
   matchesFrontendUxPath: () => matchesFrontendUxPath,
   matchesPatchnodeQuery: () => matchesPatchnodeQuery,
   materializeMcpServerSecrets: () => materializeMcpServerSecrets,
@@ -142361,6 +142612,7 @@ __export(src_exports, {
   postMergeOptionalGroupNode: () => postMergeOptionalGroupNode,
   postMergeVerificationOptionalGroupNode: () => postMergeVerificationOptionalGroupNode,
   postgresSchema: () => schema_exports,
+  prefetchWorkflowSelections: () => prefetchWorkflowSelections,
   prepareAgentCompaniesImport: () => prepareAgentCompaniesImport,
   pricingAsOf: () => pricingAsOf,
   probeGitCliStatus: () => probeGitCliStatus,
@@ -142472,6 +142724,7 @@ __export(src_exports, {
   resolveBackupSettingsMigrationConflict: () => resolveBackupSettingsMigrationConflict,
   resolveCapacityPoolId: () => resolveCapacityPoolId,
   resolveClaudeCodeClientVersion: () => resolveClaudeCodeClientVersion,
+  resolveCollateralArchivedReviewGate: () => resolveCollateralArchivedReviewGate,
   resolveColumnAdjacency: () => resolveColumnAdjacency,
   resolveColumnAgentBinding: () => resolveColumnAgentBinding,
   resolveColumnCapacity: () => resolveColumnCapacity,
@@ -149531,7 +149784,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));
@@ -152369,7 +152625,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") {
@@ -152382,8 +152638,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;
@@ -179652,7 +179909,7 @@ function extractMarkdownSection(document2, headingName) {
   return document2.slice(start, end).trim();
 }
 function compactTaskPromptStepsSection(section) {
-  const stepTitles = Array.from(section.matchAll(/^### Step \d+:.*$/gm), (match) => match[0].trim());
+  const stepTitles = matchStepHeadings(section).map(({ index: index2, headingLineEnd }) => section.slice(index2, headingLineEnd).trim());
   if (stepTitles.length === 0) {
     return section.trim();
   }
@@ -190744,7 +191001,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";
@@ -190835,7 +191092,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)" })),
@@ -211838,7 +212095,7 @@ function extractPromptSection(promptContent, sectionName) {
   return promptContent.slice(start, end).trim();
 }
 function summarizePromptSteps(promptContent) {
-  const stepTitles = Array.from(promptContent.matchAll(/^### Step \d+:.*$/gm), (match) => match[0].trim());
+  const stepTitles = matchStepHeadings(promptContent).map(({ index: index2, headingLineEnd }) => promptContent.slice(index2, headingLineEnd).trim());
   if (stepTitles.length === 0) {
     return "";
   }
@@ -214862,7 +215119,6 @@ init_transient_error_detector();
 // ../engine/src/self-healing.ts
 init_src2();
 init_src2();
-init_logger();
 import { execSync as execSync7 } from "node:child_process";
 import { setImmediate as setImmediateCb2 } from "node:timers";
 import { existsSync as existsSync64, mkdirSync as mkdirSync10, readdirSync as readdirSync10, readFileSync as readFileSync25, realpathSync as realpathSync9, rmdirSync as rmdirSync3, rmSync as rmSync6, statSync as statSync12, writeFileSync as writeFileSync11 } from "node:fs";
@@ -214870,6 +215126,21 @@ import { readFile as readFile46 } from "node:fs/promises";
 import { tmpdir as tmpdir8 } from "node:os";
 import { basename as basename22, dirname as dirname42, isAbsolute as isAbsolute19, join as join82, relative as relative19, resolve as resolve49 } from "node:path";
 
+// ../engine/src/merge/stale-content-park.ts
+init_src2();
+var AUTO_MERGE_RETRY_REJECTED_PREFIX = "AUTO_MERGE_RETRY_REJECTED:";
+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;
+}
+
+// ../engine/src/self-healing.ts
+init_logger();
+
 // ../engine/src/execution/lifecycle-move-log.ts
 init_src2();
 function laneRole(column, lanes) {
@@ -221295,6 +221566,30 @@ var AutoRecoveryDispatcher = class {
 // ../engine/src/self-healing.ts
 init_active_session_registry();
 
+// ../engine/src/agents/planning-liveness.ts
+var probes = /* @__PURE__ */ new Set();
+var planningLivenessRegistry = {
+  registerPlanningLivenessProbe(probe) {
+    probes.add(probe);
+    return () => probes.delete(probe);
+  },
+  isPlanningLive(taskId) {
+    for (const probe of probes) {
+      try {
+        if (probe(taskId)) return true;
+      } catch {
+        return true;
+      }
+    }
+    return false;
+  },
+  hasRegisteredProbe() {
+    return probes.size > 0;
+  }
+};
+var registerPlanningLivenessProbe = planningLivenessRegistry.registerPlanningLivenessProbe.bind(planningLivenessRegistry);
+var isPlanningLive = planningLivenessRegistry.isPlanningLive.bind(planningLivenessRegistry);
+
 // ../engine/src/execution/replan-target.ts
 init_src2();
 init_logger();
@@ -222634,6 +222929,17 @@ var STRANDED_COMPLETED_TODO_ACTIVE_STATUSES = /* @__PURE__ */ new Set([
 ]);
 var ORPHANED_WITH_WORKTREE_GRACE_MS = 3e5;
 var MAX_TASK_DONE_RETRIES = 3;
+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"}`;
+}
 var RECONCILE_SCOPE_OVERRIDE_MERGE_ACTIVE_STATUS_SET = new Set(MERGE_ACTIVE_MISSING_WORKTREE_STATUSES);
 async function resolveNoOpFinalizeGateIds2(store, task) {
   const selection = store.getTaskWorkflowSelectionAsync ? await store.getTaskWorkflowSelectionAsync(task.id) : store.getTaskWorkflowSelection?.(task.id);
@@ -222766,6 +223072,9 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
   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();
@@ -223484,6 +223793,13 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       { 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;
@@ -224364,6 +224680,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
           */
           { 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() },
@@ -227850,29 +228167,28 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
   /** 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((path6) => activeSessionRegistry.isPathActive(path6)) || 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 (error2) {
-          if (!isTaskNotFoundError2(error2)) throw error2;
-        }
-        const current = await this.store.getTask(snapshot.id).catch((error2) => {
-          if (isTaskNotFoundError2(error2)) return void 0;
-          throw error2;
-        });
+        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((path6) => activeSessionRegistry.isPathActive(path6)) || 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 (error2) {
+          if (isMissingTaskLookupError(error2)) {
+            log34.debug(`reconcileMissingDependencies: skipped unreadable ${current.id} dependency ${dependencyId}`);
+            continue;
+          }
           if (!/does not depend on/i.test(error2 instanceof Error ? error2.message : String(error2))) throw error2;
         }
       }
@@ -228638,7 +228954,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       const graceMs = 10 * 6e4;
       const now = Date.now();
       const nowIso3 = new Date(now).toISOString();
-      const live = (taskId) => activeSessionRegistry.pathsForTask(taskId).some((path6) => activeSessionRegistry.isPathActive(path6)) || executingTaskLock.has(taskId) || this.options.isTaskActive?.(taskId) === true;
+      const live = (taskId) => activeSessionRegistry.pathsForTask(taskId).some((path6) => activeSessionRegistry.isPathActive(path6)) || executingTaskLock.has(taskId) || isPlanningLive(taskId) || this.options.isTaskActive?.(taskId) === true;
       const due = await this.store.listDueWorkflowWorkItems({
         now: nowIso3,
         states: [...ACTIVE_WORKFLOW_WORK_ITEM_STATES]
@@ -229015,6 +229331,109 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       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((path6) => activeSessionRegistry.isPathActive(path6)) || 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((result) => resolveCollateralArchivedReviewGate(result, { 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((result) => {
+              if (!requiredPreMergeStepIds.has(result.workflowStepId)) return result;
+              const resolution = resolveCollateralArchivedReviewGate(result, { remediationGateIds });
+              if (!resolution) return result;
+              restoredStepIds.push(result.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 (error2) {
+          log34.warn(`reconcileCollateralArchivedReviewGates: failed for ${fresh.id}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+          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 (error2) {
+      log34.error(`reconcileCollateralArchivedReviewGates failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      return 0;
+    }
+  }
   /**
    * Backward lifecycle move gated on triple proof (FN-5335).
    * When the unproven fallback predicate fails, emits `task:finalize-no-op-review-no-action` and skips lifecycle mutation.
@@ -229374,25 +229793,14 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
   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,
@@ -229403,11 +229811,25 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       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, {
@@ -229422,21 +229844,23 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
           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) {
@@ -229511,11 +229935,62 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       for (const task of mergeable) {
         const reviewColumns = await ownReviewLanesFor(task);
         if (!reviewColumns.has(task.column)) continue;
-        if (await this.routeStaleSingularApprovalBackToReview(task, reviewColumns, settings)) continue;
-        if (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.`
@@ -229538,6 +230013,9 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       );
       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) {
@@ -229553,19 +230031,22 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
                 await this.store.updateTask(task.id, { status: "failed", error: error2 });
                 await this.store.logEntry(task.id, error2);
                 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 errorMessage2 = err instanceof Error ? err.message : String(err);
@@ -229573,7 +230054,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
         }
       }
       if (recovered > 0) {
-        log34.log(`Recovered ${recovered} mergeable review task(s) \u2192 done`);
+        log34.log(formatMergeableReviewRecoverySummary({ enqueued, merged, parked }));
       }
       return recovered;
     } catch (err) {
@@ -236389,23 +236870,63 @@ init_context_limit_detector();
 init_usage_limit_detector();
 init_agent_tools();
 init_worktree_backend();
-init_worktree_prune();
-init_active_session_registry();
 import { exec as exec40 } from "node:child_process";
 import { promisify as promisify57 } from "node:util";
 import { existsSync as existsSync66 } from "node:fs";
 import { rm as rm10 } from "node:fs/promises";
+
+// ../engine/src/execution/resolve-activity-run-agent-id.ts
+init_src2();
+var WORKFLOW_STEP_RUN_ATTRIBUTION_TIMEOUT_MS = 2e3;
+async function resolveWorkflowStepRunAgentId(store, candidate, options = {}) {
+  if (!candidate?.trim()) return null;
+  const resolve53 = 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(resolve53());
+  } 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);
+      }
+    );
+  });
+}
+
+// ../engine/src/execution/step-session-executor.ts
+init_worktree_prune();
+init_active_session_registry();
 var execAsync37 = promisify57(exec40);
 var stepExecLog = createLogger("step-session-executor");
 function parseStepFileScopes(prompt) {
   const result = /* @__PURE__ */ new Map();
   if (!prompt) return result;
-  const stepRegex = /^### Step (\d+):.*/gm;
-  const splits = [];
-  let match;
-  while ((match = stepRegex.exec(prompt)) !== null) {
-    splits.push({ index: match.index, stepNum: parseInt(match[1], 10) });
-  }
+  const splits = matchStepHeadings(prompt).map(({ index: index2, headingNumber }) => ({ index: index2, stepNum: headingNumber }));
   if (splits.length === 0) return result;
   for (let i = 0; i < splits.length; i++) {
     const start = splits[i].index;
@@ -236681,12 +237202,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 match;
-  while ((match = stepRegex.exec(prompt)) !== null) {
-    splits.push({ index: match.index, stepNum: parseInt(match[1], 10) });
-  }
+  const splits = matchStepHeadings(prompt).map(({ index: index2, headingNumber }) => ({ index: index2, stepNum: headingNumber }));
   const offset = resolveAuthoredStepHeadingOffset(splits.map((split) => split.stepNum));
   const targetSplit = splits.find((s3) => s3.stepNum === stepIndex + offset);
   if (!targetSplit) return "";
@@ -236696,9 +237212,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);
@@ -236800,6 +237314,8 @@ var StepSessionExecutor = class {
   credentialInstanceId;
   reusablePrimaryRetargetPending = false;
   reusablePrimaryAttemptActive = false;
+  workflowStepRunAgentId;
+  warnedUnattributableWorkflowStepRun = false;
   registerActiveStepSession(stepIndex, handle2, worktreePath) {
     this.activeSessions.set(stepIndex, handle2);
     activeSessionRegistry.registerPath(worktreePath, {
@@ -237144,10 +237660,20 @@ var StepSessionExecutor = class {
       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,
@@ -237167,6 +237693,7 @@ var StepSessionExecutor = class {
         taskTitle: taskDetail.title,
         assignedAgentId: taskDetail.assignedAgentId,
         effectiveAgentId: this.options.effectiveAgentId,
+        agentIdCandidate,
         agentId,
         stepIndex,
         stepName: step?.name ?? `Step ${stepIndex}`
@@ -237181,6 +237708,7 @@ var StepSessionExecutor = class {
     };
   }
   async saveWorkflowStepActivityRun(run) {
+    if (!run) return;
     const saveRun2 = this.options.agentStore?.saveRun?.bind(this.options.agentStore);
     if (!saveRun2) return;
     try {
@@ -237193,6 +237721,7 @@ var StepSessionExecutor = class {
     }
   }
   async completeWorkflowStepActivityRun(run, status, result) {
+    if (!run) return;
     const terminalRun = {
       ...run,
       endedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -237252,7 +237781,7 @@ var StepSessionExecutor = class {
     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;
@@ -238181,10 +238710,23 @@ function normalizeOptionalStepRevisionKey2(value) {
 function optionalStepRevisionKey2(nodeId, stepName) {
   return normalizeOptionalStepRevisionKey2(nodeId) || normalizeOptionalStepRevisionKey2(stepName) || "pre-merge-optional-step";
 }
+var OPTIONAL_STEP_REVISION_RESET_MARKER = "Workflow revision ledger reset:";
+function resetIndexFor(log42, normalizedKey) {
+  for (let index2 = log42.length - 1; index2 >= 0; index2 -= 1) {
+    const outcome = log42[index2]?.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 index2;
+  }
+  return -1;
+}
 function countOptionalStepRevisionAttempts2(task, key, stepName) {
   const normalizedKey = normalizeOptionalStepRevisionKey2(key);
   const normalizedStepName = normalizeOptionalStepRevisionKey2(stepName);
-  return (task.log ?? []).filter((entry) => {
+  const log42 = task.log ?? [];
+  const since = resetIndexFor(log42, normalizedKey);
+  return (since >= 0 ? log42.slice(since + 1) : log42).filter((entry) => {
     const action = entry.action ?? "";
     const outcome = entry.outcome ?? "";
     if (!/attempt \d+\//.test(action)) return false;
@@ -239011,10 +239553,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) {
@@ -252725,7 +253269,7 @@ async function routeGraphMergeFailureToRetry(deps, live, result, abortProvenance
   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
   );
@@ -257222,9 +257766,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.
@@ -261806,10 +262354,22 @@ async function terminateAllChildren(deps, parentTaskId) {
 
 // ../engine/src/executor/clear-terminal-step-failures-for-retry.ts
 init_src2();
+function latestTerminalPreMergeFailureId(results) {
+  return (results ?? []).filter((result) => (result.phase || "pre-merge") === "pre-merge" && (result.status === "failed" || result.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));
   }
@@ -270446,10 +271006,14 @@ var MissionExecutionLoop = class extends EventEmitter26 {
           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;
             }
@@ -271828,6 +272392,7 @@ init_agent_session_helpers();
 init_effective_settings();
 
 // ../engine/src/spec-validation/task-document-references.ts
+init_src2();
 import { access as access11 } from "node:fs/promises";
 import { join as join95 } from "node:path";
 var TASK_PATH_REGEX = /\.fusion\/tasks\/[A-Z0-9]+(?:-[A-Z0-9]+)*\/[^\s`'"\]]+/g;
@@ -271840,12 +272405,11 @@ function collectTaskPaths(text2) {
 }
 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;
 }
@@ -271979,30 +272543,6 @@ var PlanningResetFence = class {
   }
 };
 
-// ../engine/src/agents/planning-liveness.ts
-var probes = /* @__PURE__ */ new Set();
-var planningLivenessRegistry = {
-  registerPlanningLivenessProbe(probe) {
-    probes.add(probe);
-    return () => probes.delete(probe);
-  },
-  isPlanningLive(taskId) {
-    for (const probe of probes) {
-      try {
-        if (probe(taskId)) return true;
-      } catch {
-        return true;
-      }
-    }
-    return false;
-  },
-  hasRegisteredProbe() {
-    return probes.size > 0;
-  }
-};
-var registerPlanningLivenessProbe = planningLivenessRegistry.registerPlanningLivenessProbe.bind(planningLivenessRegistry);
-var isPlanningLive = planningLivenessRegistry.isPlanningLive.bind(planningLivenessRegistry);
-
 // ../engine/src/triage.ts
 init_agent_instructions();
 init_fallback_model_observer();
@@ -274239,7 +274779,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
@@ -274276,9 +274816,13 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
               const retryMessage = `Generated plan failed deterministic validation (${deterministicSpecFailure}) \u2014 retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay3}.`;
               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
@@ -274448,9 +274992,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
@@ -274480,7 +275025,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,
@@ -274532,7 +275077,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,
@@ -274816,11 +275361,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), (match) => Number(match[1]));
+    const headingNumbers = matchStepHeadings(promptContent).map((match) => match.headingNumber);
     if (headingNumbers.length > 0 && !headingNumbers.every((heading, index2) => heading === index2)) {
       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}`);
@@ -287735,7 +288291,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
@@ -287745,9 +288301,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);