@runfusion/fusion 0.78.0-beta.5 → 0.78.0-beta.6

package/dist/child-process-worker.js

@@ -1308,7 +1308,43 @@ var init_documents_artifacts = __esm({
   }
 });
 
+// ../core/src/secrets/redact-secrets.ts
+function redactSecrets(text2) {
+  return text2.replace(/(authorization\s*[:=]\s*)(bearer\s+)?[^\s,;"']+/gi, "$1$2[REDACTED]").replace(/\b(bearer)\s+[A-Za-z0-9._\-+/=]+/gi, "$1 [REDACTED]").replace(
+    /\b((?:api[_-]?key|key|token|secret|password|passwd|pwd|access[_-]?token|refresh[_-]?token|client[_-]?secret)\s*[:=]\s*)("?)[^\s,;"']+\2/gi,
+    "$1$2[REDACTED]$2"
+  ).replace(/\b(sk-|ghp_|gho_|github_pat_|xox[abpr]-|AKIA)[A-Za-z0-9_-]{8,}/g, "[REDACTED]").replace(/\b[A-Za-z0-9+/]{40,}={0,2}\b/g, "[REDACTED]").replace(/\b[0-9a-fA-F]{32,}\b/g, "[REDACTED]");
+}
+var init_redact_secrets = __esm({
+  "../core/src/secrets/redact-secrets.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/tasks/task-external-block.ts
+function fallbackReport(block) {
+  const condition = `${block.origin} limitation (${block.code || "UNCLASSIFIED"})`;
+  return {
+    verifiedCondition: `Fusion verified an external ${condition}.`,
+    stopReason: "The task is safely paused to preserve its current execution state.",
+    unimplementedWork: "Remaining implementation work was not performed.",
+    unblockCondition: `Resolve the ${condition} and retry the task.`
+  };
+}
+function sanitizeReportField(value, fallback) {
+  if (typeof value !== "string") return fallback;
+  const sanitized = redactSecrets(value.replace(/[\u0000-\u001F\u007F]/g, " ").replace(/\s+/g, " ").trim()).slice(0, REPORT_FIELD_MAX_LENGTH).trim();
+  return sanitized.length > 0 && !UNSAFE_REPORT_CONTENT.test(sanitized) ? sanitized : fallback;
+}
+function buildTaskExternalBlockReport(block, report2) {
+  const fallback = fallbackReport(block);
+  return {
+    verifiedCondition: sanitizeReportField(report2?.verifiedCondition, fallback.verifiedCondition),
+    stopReason: sanitizeReportField(report2?.stopReason, fallback.stopReason),
+    unimplementedWork: sanitizeReportField(report2?.unimplementedWork, fallback.unimplementedWork),
+    unblockCondition: sanitizeReportField(report2?.unblockCondition, fallback.unblockCondition)
+  };
+}
 function isTaskExternallyBlocked(task) {
   return task.status === EXTERNAL_BLOCK_STATUS && task.externalBlock !== void 0;
 }
@@ -1337,12 +1373,15 @@ function buildTaskExternalBlockClearPatch() {
     externalBlock: null
   };
 }
-var EXTERNAL_BLOCK_STATUS, EXTERNAL_BLOCK_PAUSE_REASON;
+var EXTERNAL_BLOCK_STATUS, EXTERNAL_BLOCK_PAUSE_REASON, REPORT_FIELD_MAX_LENGTH, UNSAFE_REPORT_CONTENT;
 var init_task_external_block = __esm({
   "../core/src/tasks/task-external-block.ts"() {
     "use strict";
+    init_redact_secrets();
     EXTERNAL_BLOCK_STATUS = "blocked";
     EXTERNAL_BLOCK_PAUSE_REASON = "external-block";
+    REPORT_FIELD_MAX_LENGTH = 320;
+    UNSAFE_REPORT_CONTENT = /\b(?:system prompt|tool (?:output|log)|stack trace|\bat \S+ \([^)]*:\d+:\d+\))/i;
   }
 });
 
@@ -1570,7 +1609,7 @@ var init_builtin_plan_review_group = __esm({
 5. **Risk callouts** \u2014 migrations, data-loss paths, external integrations, secrets, or plugin/runtime dependencies that need explicit handling.
 
 ## Environment feasibility
-When the supplied \`## Environment Capabilities\` block lists a runtime as unavailable, REVISE only if a blocking acceptance/completion criterion requires that runtime and the plan provides no runnable substitute. APPROVE when the plan specifies a runnable substitute or records the ideal check under an explicitly non-blocking \`## Environment Constraints\` section (use APPROVE_WITH_NOTES only for a genuine P2 note). Never REVISE merely because a desirable check is unavailable when the plan already marks it non-blocking.
+When the supplied \`## Environment Capabilities\` block confirms a runtime unavailable without an applicable confirmed wrapper, REVISE only if a blocking acceptance/completion criterion requires it and the plan provides no runnable substitute. A documented or configured command using a confirmed wrapper remains binding even when its inner executable is absent from the host PATH. APPROVE a correctly scoped non-blocking \`## Environment Constraints\` substitute (use APPROVE_WITH_NOTES only for a genuine P2 note); unlisted commands are UNKNOWN, never absent.
 
 ${PLAN_REVIEW_COMPLETENESS_POLICY}
 
@@ -3004,6 +3043,9 @@ var init_settings_schema = __esm({
       Grok CLI binary overrides are global operator settings because executable locations are machine-local. Blank/undefined preserves PATH auto-detection through grok.
       */
       grokCliBinaryPath: void 0,
+      // FNXC:AntigravityProvider 2026-09-20-18:32: Default disabled and preserve PATH auto-detection until an operator enables a verified agy binary.
+      useAntigravityCli: void 0,
+      antigravityCliBinaryPath: void 0,
       /*
       FNXC:OmpAcp 2026-07-13-22:50:
       Oh My Pi (omp) CLI enable + binary override are global operator settings (machine-local), mirroring Grok/Cursor.
@@ -6190,19 +6232,6 @@ var init_task_priority = __esm({
   }
 });
 
-// ../core/src/secrets/redact-secrets.ts
-function redactSecrets(text2) {
-  return text2.replace(/(authorization\s*[:=]\s*)(bearer\s+)?[^\s,;"']+/gi, "$1$2[REDACTED]").replace(/\b(bearer)\s+[A-Za-z0-9._\-+/=]+/gi, "$1 [REDACTED]").replace(
-    /\b((?:api[_-]?key|key|token|secret|password|passwd|pwd|access[_-]?token|refresh[_-]?token|client[_-]?secret)\s*[:=]\s*)("?)[^\s,;"']+\2/gi,
-    "$1$2[REDACTED]$2"
-  ).replace(/\b(sk-|ghp_|gho_|github_pat_|xox[abpr]-|AKIA)[A-Za-z0-9_-]{8,}/g, "[REDACTED]").replace(/\b[A-Za-z0-9+/]{40,}={0,2}\b/g, "[REDACTED]").replace(/\b[0-9a-fA-F]{32,}\b/g, "[REDACTED]");
-}
-var init_redact_secrets = __esm({
-  "../core/src/secrets/redact-secrets.ts"() {
-    "use strict";
-  }
-});
-
 // ../core/src/missions/mission-blockers.ts
 function normalizeMissionBlockerReason(raw) {
   if (raw && KNOWN_REASONS.has(raw)) return { reason: raw };
@@ -8382,7 +8411,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       sql2.raw = raw;
-      function join103(chunks, separator) {
+      function join104(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -8392,7 +8421,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      sql2.join = join103;
+      sql2.join = join104;
       function identifier(value) {
         return new Name(value);
       }
@@ -12178,26 +12207,26 @@ function validateParallelism(nodes2, outgoing, nodesById) {
     }
     const joinsReached = /* @__PURE__ */ new Set();
     for (const edge of branchEdges) {
-      const join104 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
-      if (!join104) {
+      const join105 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
+      if (!join105) {
         throw new WorkflowIrError(`split '${split.id}' has a branch with no reachable matching join`);
       }
-      joinsReached.add(join104);
+      joinsReached.add(join105);
     }
     if (joinsReached.size !== 1) {
       throw new WorkflowIrError(`split '${split.id}' branches converge on more than one join`);
     }
     const joinId = [...joinsReached][0];
-    const join103 = nodesById.get(joinId);
-    const mode = join103.config?.mode;
+    const join104 = nodesById.get(joinId);
+    const mode = join104.config?.mode;
     if (mode && typeof mode === "object" && "quorum" in mode) {
       const n = mode.quorum;
       if (typeof n !== "number" || !Number.isInteger(n) || n < 1) {
-        throw new WorkflowIrError(`join '${join103.id}' quorum must be a positive integer`);
+        throw new WorkflowIrError(`join '${join104.id}' quorum must be a positive integer`);
       }
       if (n > branchEdges.length) {
         throw new WorkflowIrError(
-          `join '${join103.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
+          `join '${join104.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
         );
       }
     }
@@ -14748,7 +14777,7 @@ The quality of your spec directly determines execution quality, review churn, an
 - Access to the project's files so you can understand context
 
 ## Environment feasibility
-When an \`## Environment Capabilities\` section is supplied, no acceptance criterion, completion criterion, or required verification command may depend on a runtime listed unavailable. Specify a runnable substitute instead and record the ideal-but-impossible check under an \`## Environment Constraints\` heading marked explicitly non-blocking. Never state that a plan is blocked because a runtime is missing.
+When an \`## Environment Capabilities\` section is supplied, require a runnable substitute only for a runtime confirmed unavailable without an applicable confirmed wrapper. A documented or configured command using a confirmed wrapper remains binding even when its inner executable is absent from the host PATH. Commands not listed are UNKNOWN, never absent; never state that a plan is blocked because a runtime is missing.
 
 ## What you produce
 Write a complete PROMPT.md specification to the given path using the write tool.
@@ -15958,6 +15987,9 @@ var init_builtin_code_review_group = __esm({
     CODE_REVIEW_DESCRIPTION = "Diff-review the task's changes for correctness bugs, regressions, and intent mismatches that tests miss";
     CODE_REVIEW_PROMPT = `You are a senior code reviewer. Review the task's diff for the correctness value automated tests do NOT catch.
 
+## Review stage
+This is a pre-merge review. Evidence that can exist only after landing (for example a push-to-main CI run) belongs to an enabled, blocking post-merge verification gate. Verify that the workflow preserves that requirement before allowing merge; if the gate or its evidence contract is missing, request that concrete configuration fix. Do not request the future run itself as a pre-merge implementation fix, or claim its evidence already exists. Pre-merge correctness and verification requirements still apply.
+
 ## Step 1: Read the change
 1. Read the full diff against the base branch: \`git diff <base>...HEAD\` (or \`git diff <base>\`). Determine the base from the task context / merge target.
 2. Read the changed files in full where the diff is non-trivial, so you see the surrounding code paths the change touches \u2014 not just the hunks.
@@ -16043,9 +16075,17 @@ var init_builtin_post_merge_group = __esm({
 2. Check the final merged diff and task summary for obvious mismatches, missing verification evidence, or integration-only regressions.
 3. If configured test/build commands are available in the task context, inspect their latest result or explain why no post-merge command was applicable.
 
+## Required post-landing Full Suite evidence
+This enabled gate requires post-landing Full Suite evidence. Do NOT approve until its delivery record names all of the following:
+1. The landed SHA and the first Full Suite push-to-main run at or after that SHA, including the run ID and run SHA.
+2. A conclusion for every Test shard: 1/4, 2/4, 3/4, and 4/4.
+3. All four timing artifacts: test-timings-shard-1, test-timings-shard-2, test-timings-shard-3, and test-timings-shard-4.
+
+Pre-landing, unrelated-main, or partial evidence does not satisfy this contract. If the required run or any required evidence is unavailable, return REVISE and state that final completion remains blocked pending the post-landing evidence. Record verified evidence in the task delivery record before approving.
+
 ## Output Requirements
 - APPROVE: post-merge verification is acceptable.
-- APPROVE_WITH_NOTES: completion may proceed with non-blocking notes.
+- APPROVE_WITH_NOTES: completion may proceed with non-blocking notes only when every post-landing evidence item above is recorded.
 - REVISE: completion should be blocked; include the concrete post-merge issue and the needed follow-up.
 - \`notes\` MUST contain one to three non-empty sentences naming what was checked and why the verdict was reached. An empty \`notes\` string is a protocol violation.
 - Final output: output exactly one trailing JSON object on the final line (no markdown fences, no surrounding prose):
@@ -20333,7 +20373,7 @@ var init_select2 = __esm({
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table)) this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join103) => join103.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join104) => join104.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -21868,7 +21908,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join103) => join103.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join104) => join104.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -21964,10 +22004,10 @@ var init_update = __esm({
               const fromFields = this.getTableLikeFields(this.config.from);
               fields[tableName] = fromFields;
             }
-            for (const join103 of this.config.joins) {
-              const tableName2 = getTableLikeName(join103.table);
-              if (typeof tableName2 === "string" && !is(join103.table, SQL)) {
-                const fromFields = this.getTableLikeFields(join103.table);
+            for (const join104 of this.config.joins) {
+              const tableName2 = getTableLikeName(join104.table);
+              if (typeof tableName2 === "string" && !is(join104.table, SQL)) {
+                const fromFields = this.getTableLikeFields(join104.table);
                 fields[tableName2] = fromFields;
               }
             }
@@ -26280,8 +26320,10 @@ var init_schema2 = __esm({
 import { randomUUID as randomUUID2 } from "node:crypto";
 function createAsyncDataLayer(connections, options) {
   const db = connections.runtime;
+  const healthDb = connections.health;
   return {
     db,
+    healthDb,
     projectId: options?.projectId,
     backend: connections.backend,
     async transaction(fn, options2) {
@@ -30427,13 +30469,13 @@ async function detectWorkspaceRepos(dir, runner = runGitCommand, timeout = DEFAU
     return [];
   }
   const { stat: stat14 } = await import("node:fs/promises");
-  const { join: join103 } = await import("node:path");
+  const { join: join104 } = await import("node:path");
   const found = [];
   for (const entry of entries) {
     if (EXCLUDED_WORKSPACE_ENTRIES.has(entry)) continue;
-    const childDir = join103(dir, entry);
+    const childDir = join104(dir, entry);
     try {
-      const s3 = await stat14(join103(childDir, ".git"));
+      const s3 = await stat14(join104(childDir, ".git"));
       if (!s3.isDirectory() && !s3.isFile()) continue;
     } catch {
       continue;
@@ -30446,9 +30488,9 @@ async function detectWorkspaceRepos(dir, runner = runGitCommand, timeout = DEFAU
 }
 async function readConfiguredIntegrationBranch(projectPath) {
   try {
-    const { readFile: readFile54 } = await import("node:fs/promises");
-    const { join: join103 } = await import("node:path");
-    const raw = await readFile54(join103(projectPath, ".fusion", "config.json"), "utf-8");
+    const { readFile: readFile55 } = await import("node:fs/promises");
+    const { join: join104 } = await import("node:path");
+    const raw = await readFile55(join104(projectPath, ".fusion", "config.json"), "utf-8");
     const config3 = JSON.parse(raw);
     for (const value of [config3.settings?.integrationBranch, config3.settings?.baseBranch]) {
       if (typeof value !== "string") continue;
@@ -30461,9 +30503,9 @@ async function readConfiguredIntegrationBranch(projectPath) {
 }
 async function isWorkspaceModeExplicitlyDisabled(projectPath) {
   try {
-    const { readFile: readFile54 } = await import("node:fs/promises");
-    const { join: join103 } = await import("node:path");
-    const raw = await readFile54(join103(projectPath, ".fusion", "config.json"), "utf-8");
+    const { readFile: readFile55 } = await import("node:fs/promises");
+    const { join: join104 } = await import("node:path");
+    const raw = await readFile55(join104(projectPath, ".fusion", "config.json"), "utf-8");
     const config3 = JSON.parse(raw);
     return config3.settings?.workspaceMode === false;
   } catch {
@@ -30471,12 +30513,12 @@ async function isWorkspaceModeExplicitlyDisabled(projectPath) {
   }
 }
 async function setWorkspaceModeInConfig(projectPath, value) {
-  const { readFile: readFile54, writeFile: writeFile31, mkdir: mkdir32 } = await import("node:fs/promises");
-  const { join: join103 } = await import("node:path");
-  const configPath = join103(projectPath, ".fusion", "config.json");
+  const { readFile: readFile55, writeFile: writeFile31, mkdir: mkdir32 } = await import("node:fs/promises");
+  const { join: join104 } = await import("node:path");
+  const configPath = join104(projectPath, ".fusion", "config.json");
   let config3 = {};
   try {
-    config3 = JSON.parse(await readFile54(configPath, "utf-8"));
+    config3 = JSON.parse(await readFile55(configPath, "utf-8"));
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
@@ -30485,7 +30527,7 @@ async function setWorkspaceModeInConfig(projectPath, value) {
   }
   const settings = config3.settings;
   settings.workspaceMode = value;
-  await mkdir32(join103(projectPath, ".fusion"), { recursive: true });
+  await mkdir32(join104(projectPath, ".fusion"), { recursive: true });
   await writeFile31(configPath, JSON.stringify(config3, null, 2), "utf-8");
 }
 function isInRootRelativePath(entry, pathMod) {
@@ -30498,12 +30540,12 @@ function isInRootRelativePath(entry, pathMod) {
   return true;
 }
 async function loadWorkspaceConfig(rootDir) {
-  const { readFile: readFile54 } = await import("node:fs/promises");
+  const { readFile: readFile55 } = await import("node:fs/promises");
   const pathMod = await import("node:path");
-  const { join: join103 } = pathMod;
-  const configPath = join103(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME);
+  const { join: join104 } = pathMod;
+  const configPath = join104(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME);
   try {
-    const raw = await readFile54(configPath, "utf-8");
+    const raw = await readFile55(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object" && "repos" in parsed && Array.isArray(parsed.repos) && parsed.repos.every((r) => typeof r === "string")) {
       const rawRepos = parsed.repos;
@@ -30554,20 +30596,20 @@ async function addWorkspaceRepo(rootDir, repoRelPath, options = {}) {
 }
 async function saveWorkspaceConfig(rootDir, config3) {
   const { mkdir: mkdir32, writeFile: writeFile31 } = await import("node:fs/promises");
-  const { join: join103 } = await import("node:path");
-  const fusionDir = join103(rootDir, ".fusion");
+  const { join: join104 } = await import("node:path");
+  const fusionDir = join104(rootDir, ".fusion");
   await mkdir32(fusionDir, { recursive: true });
   await writeFile31(
-    join103(fusionDir, WORKSPACE_CONFIG_FILENAME),
+    join104(fusionDir, WORKSPACE_CONFIG_FILENAME),
     JSON.stringify(config3, null, 2),
     "utf-8"
   );
 }
 async function removeWorkspaceConfig(rootDir) {
   const { unlink: unlink13 } = await import("node:fs/promises");
-  const { join: join103 } = await import("node:path");
+  const { join: join104 } = await import("node:path");
   try {
-    await unlink13(join103(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME));
+    await unlink13(join104(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME));
     return true;
   } catch (error2) {
     if (error2?.code === "ENOENT") return false;
@@ -33642,6 +33684,9 @@ async function replaceActiveTaskWorkflowContinuation(layer, input) {
       eq(project_exports.workflowWorkItems.kind, "task"),
       inArray(project_exports.workflowWorkItems.state, ACTIVE_TASK_CONTINUATION_STATES)
     ));
+    if (input.onlyIfNoActiveTaskContinuation && activeRows.length > 0) {
+      throw new ActiveTaskContinuationError(input.taskId);
+    }
     for (const row of activeRows) {
       if (row.runId === input.runId && row.nodeId === input.nodeId && row.kind === input.kind) continue;
       await transitionWorkflowWorkItem(layer, row.id, "succeeded", { leaseOwner: null, leaseExpiresAt: null, lastError: null }, tx);
@@ -33667,6 +33712,24 @@ async function replaceActiveTaskWorkflowContinuation(layer, input) {
 }
 async function seedWorkspaceCodeReviewContinuationIfIdle(layer, input) {
   return layer.transactionImmediate(async (tx) => withTaskWorkflowSerialization(tx, layer.projectId, input.taskId, async () => {
+    if (input.expectedWorkflowSelection !== void 0) {
+      const rows = await tx.select({
+        workflowId: project_exports.taskWorkflowSelection.workflowId,
+        stepIds: project_exports.taskWorkflowSelection.stepIds
+      }).from(project_exports.taskWorkflowSelection).where(and(
+        projectScopeFor(project_exports.taskWorkflowSelection.projectId, layer.projectId),
+        eq(project_exports.taskWorkflowSelection.taskId, input.taskId)
+      )).limit(1);
+      const row = rows[0];
+      const current = row ? {
+        workflowId: row.workflowId,
+        stepIds: Array.isArray(row.stepIds) ? row.stepIds.filter((id) => typeof id === "string") : []
+      } : null;
+      const expected = input.expectedWorkflowSelection;
+      if (current?.workflowId !== expected?.workflowId || current?.stepIds.length !== expected?.stepIds.length || current?.stepIds.some((id, index2) => id !== expected?.stepIds[index2])) {
+        return { seeded: false, reason: "workflow-selection-changed" };
+      }
+    }
     const active2 = await tx.select({ id: project_exports.workflowWorkItems.id }).from(project_exports.workflowWorkItems).where(and(
       projectScopeFor(project_exports.workflowWorkItems.projectId, layer.projectId),
       eq(project_exports.workflowWorkItems.taskId, input.taskId),
@@ -33825,7 +33888,7 @@ async function getCompletionHandoffMarker(db, taskId) {
 async function clearCompletionHandoffMarker(db, taskId) {
   await db.delete(project_exports.completionHandoffMarkers).where(eq(project_exports.completionHandoffMarkers.taskId, taskId));
 }
-var TERMINAL_WORKFLOW_WORK_ITEM_STATES, ACTIVE_TASK_CONTINUATION_STATES;
+var TERMINAL_WORKFLOW_WORK_ITEM_STATES, ACTIVE_TASK_CONTINUATION_STATES, ActiveTaskContinuationError;
 var init_async_workflow_workitems = __esm({
   "../core/src/task-store/async/async-workflow-workitems.ts"() {
     "use strict";
@@ -33840,6 +33903,12 @@ var init_async_workflow_workitems = __esm({
       "cancelled"
     ]);
     ACTIVE_TASK_CONTINUATION_STATES = [...ACTIVE_WORKFLOW_WORK_ITEM_STATES];
+    ActiveTaskContinuationError = class extends Error {
+      constructor(taskId) {
+        super(`active task continuation exists for ${taskId}`);
+        this.name = "ActiveTaskContinuationError";
+      }
+    };
   }
 });
 
@@ -44684,10 +44753,10 @@ async function createConnectionSet(env = process.env, options = {}) {
       "External backend resolved but runtimeUrl is null. This is an internal error."
     );
   }
-  return createConnectionSetFromUrl(backend, options);
+  return createConnectionSetFromUrl(backend, { ...options, env });
 }
 async function createConnectionSetFromUrl(backend, options = {}) {
-  const poolMax = options.poolMax ?? DEFAULT_POOL_MAX;
+  const poolMax = resolvePoolMax(options);
   const connectTimeout = options.connectTimeoutSeconds ?? DEFAULT_CONNECT_TIMEOUT_SECONDS;
   const idleTimeout = options.idleTimeoutSeconds ?? DEFAULT_IDLE_TIMEOUT_SECONDS;
   const onWarning = options.onWarning ?? ((msg) => log3.warn(msg));
@@ -44722,6 +44791,16 @@ async function createConnectionSetFromUrl(backend, options = {}) {
     }
   });
   const runtimeDb = drizzle(runtimeSql);
+  const healthSql = src_default(runtimeUrl, {
+    max: 1,
+    connect_timeout: connectTimeout,
+    idle_timeout: idleTimeout,
+    prepare: runtimePrepare,
+    connection: runtimeConnectionParameters,
+    onnotice: () => {
+    }
+  });
+  const healthDb = drizzle(healthSql);
   const migrationUrl = backend.migrationUrl ?? runtimeUrl;
   const migrationSql = src_default(migrationUrl, {
     max: 1,
@@ -44733,23 +44812,40 @@ async function createConnectionSetFromUrl(backend, options = {}) {
     }
   });
   const migrationDb = drizzle(migrationSql);
+  let closePromise;
   const connections = {
     runtime: runtimeDb,
     migration: migrationDb,
+    health: healthDb,
     backend,
-    async close() {
-      const closePromises = [
-        migrationSql.end({ timeout: 5 }),
-        runtimeSql.end({ timeout: 5 })
-      ];
-      await Promise.allSettled(closePromises);
+    close() {
+      closePromise ??= (async () => {
+        await Promise.allSettled([
+          migrationSql.end({ timeout: 5 }),
+          healthSql.end({ timeout: 5 }),
+          runtimeSql.end({ timeout: 5 })
+        ]);
+      })();
+      return closePromise;
     },
     async ping() {
-      await runtimeSql`SELECT 1`;
+      await healthSql`SELECT 1`;
     }
   };
   return connections;
 }
+function resolvePoolMax(options = {}) {
+  if (options.poolMax !== void 0) return options.poolMax;
+  const raw = options.env?.[FUSION_PG_POOL_MAX_ENV] ?? process.env[FUSION_PG_POOL_MAX_ENV];
+  if (raw === void 0) return DEFAULT_POOL_MAX;
+  const trimmed = raw.trim();
+  const value = Number(trimmed);
+  if (trimmed !== "" && Number.isInteger(value) && value >= MIN_POOL_MAX && value <= MAX_POOL_MAX) return value;
+  (options.onWarning ?? ((msg) => log3.warn(msg)))(
+    `${FUSION_PG_POOL_MAX_ENV} must be an integer from ${MIN_POOL_MAX} through ${MAX_POOL_MAX}; using default ${DEFAULT_POOL_MAX}`
+  );
+  return DEFAULT_POOL_MAX;
+}
 async function verifyConnection(url2, timeoutSeconds = DEFAULT_CONNECT_TIMEOUT_SECONDS) {
   const sql2 = src_default(url2, {
     max: 1,
@@ -44768,7 +44864,7 @@ async function verifyConnection(url2, timeoutSeconds = DEFAULT_CONNECT_TIMEOUT_S
     });
   }
 }
-var log3, DEFAULT_POOL_MAX, DEFAULT_CONNECT_TIMEOUT_SECONDS, DEFAULT_IDLE_TIMEOUT_SECONDS, DatabaseConnectionError;
+var log3, DEFAULT_POOL_MAX, FUSION_PG_POOL_MAX_ENV, MIN_POOL_MAX, MAX_POOL_MAX, DEFAULT_CONNECT_TIMEOUT_SECONDS, DEFAULT_IDLE_TIMEOUT_SECONDS, DatabaseConnectionError;
 var init_connection2 = __esm({
   "../core/src/postgres/connection.ts"() {
     "use strict";
@@ -44779,6 +44875,9 @@ var init_connection2 = __esm({
     init_credential_redact();
     log3 = createLogger2("postgres-connection");
     DEFAULT_POOL_MAX = 3;
+    FUSION_PG_POOL_MAX_ENV = "FUSION_PG_POOL_MAX";
+    MIN_POOL_MAX = 1;
+    MAX_POOL_MAX = 500;
     DEFAULT_CONNECT_TIMEOUT_SECONDS = 10;
     DEFAULT_IDLE_TIMEOUT_SECONDS = 20;
     DatabaseConnectionError = class extends Error {
@@ -46000,7 +46099,7 @@ async function checkPostgresHealth(layer) {
     return errors;
   }
   try {
-    const db = layer.db;
+    const db = layer.healthDb;
     const rows = await db.execute(
       sql.raw(`
         SELECT datallowconn, now() - pg_postmaster_start_time() AS uptime
@@ -46254,15 +46353,17 @@ function buildReport(checkedAt, anomalies) {
     anomalies
   };
 }
-async function detectTaskIdIntegrityAnomaliesAsync(db) {
+async function detectTaskIdIntegrityAnomaliesAsync(db, options) {
   const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const projectId2 = options?.projectId?.trim() || void 0;
+  const projectFilter = projectId2 ? sql` WHERE project_id = ${projectId2}` : sql``;
   try {
     const anomalies = [];
     const activeRows = await db.execute(
-      sql.raw(`SELECT id FROM ${PROJECT_SCHEMA}.tasks`)
+      sql`SELECT id FROM ${sql.raw(`${PROJECT_SCHEMA}.tasks`)}${projectFilter}`
     );
     const archivedRows = await db.execute(
-      sql.raw(`SELECT id FROM ${PROJECT_SCHEMA}.archived_tasks`)
+      sql`SELECT id FROM ${sql.raw(`${PROJECT_SCHEMA}.archived_tasks`)}${projectFilter}`
     );
     const activeIds = activeRows.map((r) => String(r.id ?? ""));
     const archivedIds = archivedRows.map((r) => String(r.id ?? ""));
@@ -46313,7 +46414,7 @@ async function detectTaskIdIntegrityAnomaliesAsync(db) {
       }
     }
     const stateRows = await db.execute(
-      sql.raw(`SELECT prefix, next_sequence FROM ${PROJECT_SCHEMA}.distributed_task_id_state`)
+      sql`SELECT prefix, next_sequence FROM ${sql.raw(`${PROJECT_SCHEMA}.distributed_task_id_state`)}${projectFilter}`
     );
     for (const stateRow of stateRows) {
       const prefix = String(stateRow.prefix).trim().toUpperCase();
@@ -46685,6 +46786,11 @@ async function migrateSqliteToPostgresOnSession(migrationDb, sources, options) {
     emitMigrationProgress(options, { phase: "copy-started", tableCount });
     let tableIndex = 0;
     for (const { source, plan } of plannedSources) {
+      const sourceHasPreexistingTargetAhead = await hasPreexistingTargetAhead(
+        migrationDb,
+        source,
+        plan
+      );
       for (const tablePlan of plan) {
         tableIndex += 1;
         const progressBase = {
@@ -46699,6 +46805,7 @@ async function migrateSqliteToPostgresOnSession(migrationDb, sources, options) {
           source,
           tablePlan,
           dryRun,
+          sourceHasPreexistingTargetAhead,
           {
             onCopyProgress: (processedRows, sourceRows) => emitMigrationProgress(options, {
               phase: "table-progress",
@@ -46834,6 +46941,7 @@ async function buildMigrationPlan(db, source, projectId2) {
           pgTable: table,
           columns: [],
           unmappedSourceColumns: [],
+          ignoredRetiredSourceColumns: [],
           allowedSkipReason: "redirected to central plugin registry and project state"
         });
         continue;
@@ -46850,12 +46958,19 @@ async function buildMigrationPlan(db, source, projectId2) {
           columns: [],
           partitionProjectId: projectId2,
           unmappedSourceColumns: [],
+          ignoredRetiredSourceColumns: [],
           legacyPreservation: { sourceSchemaSql: readSqliteTableSchema(sqlite, table) }
         });
         continue;
       }
       const pgTable2 = toSnakeCase2(table);
-      const { columns: resolvedColumns, targetColumnNames, unmappedSourceColumns } = resolveColumnMapping(
+      const {
+        columns: resolvedColumns,
+        targetColumnNames,
+        unmappedSourceColumns,
+        ignoredRetiredSourceColumns
+      } = resolveColumnMapping(
+        source.pgSchema,
         pgTable2,
         table,
         sqlite,
@@ -46871,7 +46986,8 @@ async function buildMigrationPlan(db, source, projectId2) {
           columns: cols,
           partitionProjectId,
           unmappedSourceColumns,
-          allowedSkipReason: disposableSqliteTableReason(ftsVirtualTables, table)
+          ignoredRetiredSourceColumns,
+          allowedSkipReason: retiredSqliteTableSkipReason(source.pgSchema, table) ?? disposableSqliteTableReason(ftsVirtualTables, table)
         });
         continue;
       }
@@ -46881,7 +46997,8 @@ async function buildMigrationPlan(db, source, projectId2) {
         pgTable: pgTable2,
         columns: cols,
         partitionProjectId,
-        unmappedSourceColumns
+        unmappedSourceColumns,
+        ignoredRetiredSourceColumns
       });
     }
     return plans;
@@ -46889,6 +47006,79 @@ async function buildMigrationPlan(db, source, projectId2) {
     sqlite.close();
   }
 }
+async function hasPreexistingTargetAhead(db, source, plans) {
+  const sqlite = openSqlite(source.sqlitePath);
+  try {
+    for (const plan of plans) {
+      if (plan.columns.length === 0 || plan.unmappedSourceColumns.length > 0) continue;
+      const row = sqlite.prepare(`SELECT COUNT(*) AS n FROM ${quoteIdent(plan.table)}`).get();
+      const sourceRows = Number(row.n);
+      if (sourceRows === 0) continue;
+      const targetRows = await countTargetRows(db, plan.pgSchema, plan.pgTable, plan.partitionProjectId);
+      if (targetRows > sourceRows) return true;
+    }
+    return false;
+  } finally {
+    sqlite.close();
+  }
+}
+function staleDuplicateSkipReason(targetRows) {
+  return `stale SQLite duplicate; PostgreSQL already has ${targetRows} scoped rows`;
+}
+async function sourceRowsArePrimaryKeyConflictCovered(db, sqlite, plan, insertableCols) {
+  const primaryKeyRows = await db.execute(sql`
+    SELECT key_columns.column_name
+    FROM information_schema.table_constraints AS constraints
+    JOIN information_schema.key_column_usage AS key_columns
+      ON key_columns.constraint_catalog = constraints.constraint_catalog
+      AND key_columns.constraint_schema = constraints.constraint_schema
+      AND key_columns.constraint_name = constraints.constraint_name
+    WHERE constraints.constraint_type = 'PRIMARY KEY'
+      AND constraints.table_schema = ${plan.pgSchema}
+      AND constraints.table_name = ${plan.pgTable}
+    ORDER BY key_columns.ordinal_position
+  `);
+  if (primaryKeyRows.length === 0) return false;
+  const columnByPgName = new Map(insertableCols.map((column) => [column.pgName, column]));
+  const primaryKeyColumns = primaryKeyRows.map(({ column_name }) => {
+    if (column_name === "project_id" && plan.partitionProjectId !== void 0) {
+      return { pgName: column_name, valueFor: () => plan.partitionProjectId };
+    }
+    const column = columnByPgName.get(column_name);
+    if (!column) return void 0;
+    return {
+      pgName: column_name,
+      valueFor: (row) => convertValue(
+        row[column.sqliteName],
+        column.type,
+        column.nullJsonbFallback,
+        column.preserveEmptyJsonbString
+      )
+    };
+  });
+  if (primaryKeyColumns.some((column) => column === void 0)) return false;
+  const selectableCols = [...new Set(
+    primaryKeyColumns.flatMap((column) => {
+      if (!column || column.pgName === "project_id" && plan.partitionProjectId !== void 0) return [];
+      return [quoteIdent(columnByPgName.get(column.pgName).sqliteName)];
+    })
+  )].join(", ") || "1";
+  const rows = sqlite.prepare(`SELECT ${selectableCols} FROM ${quoteIdent(plan.table)}`).all();
+  for (const row of rows) {
+    const predicates = primaryKeyColumns.map((column) => {
+      const resolved = column;
+      return sql`${sql.raw(quoteIdent(resolved.pgName))} IS NOT DISTINCT FROM ${resolved.valueFor(row)}`;
+    });
+    const existing = await db.execute(sql`
+      SELECT 1
+      FROM ${sql.raw(quoteIdent(plan.pgSchema))}.${sql.raw(quoteIdent(plan.pgTable))}
+      WHERE ${sql.join(predicates, sql` AND `)}
+      LIMIT 1
+    `);
+    if (existing.length === 0) return false;
+  }
+  return true;
+}
 function readSqliteTableSchema(db, table) {
   const row = db.prepare(
     `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?`
@@ -47052,15 +47242,21 @@ async function loadTargetColumnMetadata(db, pgSchema2) {
   }
   return byTable;
 }
-function resolveColumnMapping(pgTable2, table, sqlite, targetColumnsByTable) {
+function resolveColumnMapping(sourceSchema, pgTable2, table, sqlite, targetColumnsByTable) {
   const pgCols = targetColumnsByTable.get(pgTable2) ?? [];
   if (pgCols.length === 0) {
-    return { columns: [], targetColumnNames: /* @__PURE__ */ new Set(), unmappedSourceColumns: [] };
+    return {
+      columns: [],
+      targetColumnNames: /* @__PURE__ */ new Set(),
+      unmappedSourceColumns: [],
+      ignoredRetiredSourceColumns: []
+    };
   }
   const pgByName = new Map(pgCols.map((c) => [c.column_name, c]));
   const sqliteCols = sqlite.prepare(`PRAGMA table_info(${quoteIdent(table)})`).all();
   const mapping = [];
   const unmappedSourceColumns = [];
+  const ignoredRetiredSourceColumns = [];
   for (const sc of sqliteCols) {
     let pgName = toSnakeCase2(sc.name);
     if (pgName === "project_id" && pgByName.has("owner_project_id")) {
@@ -47068,7 +47264,11 @@ function resolveColumnMapping(pgTable2, table, sqlite, targetColumnsByTable) {
     }
     const pgCol = pgByName.get(pgName);
     if (!pgCol) {
-      unmappedSourceColumns.push(sc.name);
+      if (retiredSqliteColumnReason(sourceSchema, table, sc.name)) {
+        ignoredRetiredSourceColumns.push(sc.name);
+      } else {
+        unmappedSourceColumns.push(sc.name);
+      }
       continue;
     }
     const type = classifyColumnType(pgCol);
@@ -47096,9 +47296,20 @@ function resolveColumnMapping(pgTable2, table, sqlite, targetColumnsByTable) {
   return {
     columns: mapping,
     targetColumnNames: new Set(pgByName.keys()),
-    unmappedSourceColumns
+    unmappedSourceColumns,
+    ignoredRetiredSourceColumns
   };
 }
+function retiredSqliteColumnReason(schema, table, column) {
+  return schema === PROJECT_SCHEMA && table === "tasks" && column === "breakIntoSubtasks" ? "retired task-splitting field" : void 0;
+}
+function retiredSqliteTableSkipReason(schema, table) {
+  return schema === CENTRAL_SCHEMA && table === "globalConcurrency" ? "retired global concurrency table; PostgreSQL target was removed" : void 0;
+}
+function retiredColumnSkipReason(plan) {
+  if (plan.ignoredRetiredSourceColumns.length === 0) return void 0;
+  return `ignored retired SQLite column(s): ${plan.ignoredRetiredSourceColumns.join(", ")}`;
+}
 function classifyColumnType(pgCol) {
   if (Number(pgCol.is_generated) === 1) {
     return "generated";
@@ -47278,7 +47489,7 @@ async function migrateLegacyPreservationTable(db, source, plan, dryRun, progress
     sqlite.close();
   }
 }
-async function migrateTable(db, source, plan, dryRun, progress = {}) {
+async function migrateTable(db, source, plan, dryRun, sourceHasPreexistingTargetAhead, progress = {}) {
   if (plan.legacyPreservation) {
     return migrateLegacyPreservationTable(db, source, plan, dryRun, progress);
   }
@@ -47342,15 +47553,17 @@ async function migrateTable(db, source, plan, dryRun, progress = {}) {
     const countRow = sqlite.prepare(`SELECT COUNT(*) AS n FROM ${quoteIdent(plan.table)}`).get();
     sourceRows = Number(countRow.n);
     if (dryRun || sourceRows === 0) {
+      const targetRows2 = await countTargetRows(db, plan.pgSchema, plan.pgTable, plan.partitionProjectId);
+      const staleDuplicate2 = dryRun && sourceRows > 0 && sourceHasPreexistingTargetAhead && targetRows2 >= sourceRows && await sourceRowsArePrimaryKeyConflictCovered(db, sqlite, plan, insertableCols);
       return {
         schema: plan.pgSchema,
         table: plan.pgTable,
         sourceRows,
         insertedRows: 0,
-        targetRows: dryRun ? 0 : await countTargetRows(db, plan.pgSchema, plan.pgTable, plan.partitionProjectId),
-        verified: dryRun ? false : true,
-        skipped: dryRun ? true : false,
-        skipReason: dryRun ? "dry-run" : "no source rows"
+        targetRows: targetRows2,
+        verified: staleDuplicate2 ? true : !dryRun,
+        skipped: staleDuplicate2 || dryRun,
+        skipReason: staleDuplicate2 ? staleDuplicateSkipReason(targetRows2) : retiredColumnSkipReason(plan) ?? (dryRun ? "dry-run" : "no source rows")
       };
     }
     const stmt = sqlite.prepare(`SELECT ${selectableCols} FROM ${quoteIdent(plan.table)}`);
@@ -47420,7 +47633,13 @@ async function migrateTable(db, source, plan, dryRun, progress = {}) {
         `Row-count mismatch for ${plan.pgSchema}.${plan.pgTable}: source=${sourceRows}, target=${targetRows}`
       );
     }
-    const verified = rowCountOk && contentOk;
+    const staleDuplicate = insertedRows === 0 && sourceHasPreexistingTargetAhead && targetRows >= sourceRows;
+    if (staleDuplicate) {
+      log4.log(
+        `Skipping stale SQLite duplicate for ${plan.pgSchema}.${plan.pgTable}: all ${sourceRows} source rows conflicted while PostgreSQL already has ${targetRows} scoped rows.`
+      );
+    }
+    const verified = staleDuplicate || rowCountOk && contentOk;
     return {
       schema: plan.pgSchema,
       table: plan.pgTable,
@@ -47428,7 +47647,8 @@ async function migrateTable(db, source, plan, dryRun, progress = {}) {
       insertedRows,
       targetRows,
       verified,
-      skipped: false
+      skipped: staleDuplicate,
+      skipReason: staleDuplicate ? staleDuplicateSkipReason(targetRows) : retiredColumnSkipReason(plan)
     };
   } finally {
     sqlite.close();
@@ -47813,11 +48033,11 @@ async function rekeyFallbackProjectPartition(db, fallbackProjectId, registeredPr
       const parentKey = `${fk.parentSchema}.${fk.parentTable}`;
       if (!targetKeys.has(parentKey)) continue;
       const childTarget = targetKeys.has(`${fk.childSchema}.${fk.childTable}`);
-      const join103 = fk.childColumns.map((column, index2) => `child.${quoteIdentifier(column)} IS NOT DISTINCT FROM parent.${quoteIdentifier(fk.parentColumns[index2])}`).join(" AND ");
+      const join104 = fk.childColumns.map((column, index2) => `child.${quoteIdentifier(column)} IS NOT DISTINCT FROM parent.${quoteIdentifier(fk.parentColumns[index2])}`).join(" AND ");
       const registeredChildScope = childTarget ? ` AND child.${quoteIdentifier("project_id")} = ${quoteLiteral(registeredProjectId)}` : "";
       const unreplaced = await tx.execute(sql.raw(`SELECT EXISTS (
         SELECT 1 FROM ${relationName({ schema: fk.childSchema, table: fk.childTable })} child
-        JOIN ${relationName({ schema: fk.parentSchema, table: fk.parentTable })} parent ON ${join103}
+        JOIN ${relationName({ schema: fk.parentSchema, table: fk.parentTable })} parent ON ${join104}
         JOIN fusion_rekey_conflict_candidates parent_candidate
           ON parent_candidate.schema_name = ${quoteLiteral(fk.parentSchema)}
          AND parent_candidate.table_name = ${quoteLiteral(fk.parentTable)}
@@ -58813,8 +59033,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static async parseFile(filePath) {
-        const { readFile: readFile54 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
-        const data = await readFile54(filePath, "utf8");
+        const { readFile: readFile55 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
+        const data = await readFile55(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -62244,6 +62464,7 @@ async function bootSchemaBackendOnce(options, bypassProjectIsolation = false) {
       bypassProjectIsolation
     }) : await createConnectionSetFromUrl(resolvedBackend, {
       poolMax: options.poolMax,
+      env,
       bypassProjectIsolation
     });
     await applySchemaBaseline(connections.migration);
@@ -62598,6 +62819,7 @@ async function createTaskStoreForBackend(options) {
     await connections.close();
     connections = await createConnectionSetFromUrl(resolvedBackend, {
       poolMax: options.poolMax,
+      env,
       projectId: resolvedProjectId,
       useRuntimeRole: runtimeRoleRows[0]?.usable === true
     });
@@ -62646,6 +62868,7 @@ async function createTaskStoreForBackend(options) {
       bypassProjectIsolation: true
     }) : await createConnectionSetFromUrl(resolvedBackend, {
       poolMax: 1,
+      env,
       bypassProjectIsolation: true
     });
     try {
@@ -71734,6 +71957,8 @@ function archiveEntryToTask(entry, slim = false) {
     attachments: slim ? void 0 : entry.attachments,
     comments: entry.comments,
     review: slim ? void 0 : entry.review,
+    // FNXC:ArchivedRecommendations 2026-09-20-17:23: archive reads retain actionable terminal recommendation state.
+    recommendations: entry.recommendations,
     log: slim ? [] : entry.log ?? [],
     timedExecutionMs: slim ? computeTimedExecutionMs(entry.log) : void 0,
     createdAt: entry.createdAt,
@@ -95698,9 +95923,9 @@ async function deleteArchivedTaskEntry(db, id, projectId2) {
 async function archiveParentTaskWithLineageGate(layer, taskId, entry, options = {}) {
   const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
   return layer.transactionImmediate(async (tx) => {
+    await acquireTaskAdvisoryXactLock(tx, layer.projectId, taskId);
+    const live = await readTaskRowInTransaction(tx, taskId, { includeDeleted: true }, layer.projectId);
     if (options.livenessWipLanes) {
-      await acquireTaskAdvisoryXactLock(tx, layer.projectId, taskId);
-      const live = await readTaskRowInTransaction(tx, taskId, void 0, layer.projectId);
       const verdict = decideArchiveLiveness({ column: String(live?.column ?? ""), status: live?.status, wipLanes: options.livenessWipLanes });
       if (verdict.live) return { archived: false, liveVerdict: verdict };
     }
@@ -95712,7 +95937,8 @@ async function archiveParentTaskWithLineageGate(layer, taskId, entry, options =
     if (options.removeLineageReferences && options.revalidateAgainst !== void 0) assertLineageCandidatesUnchanged(liveChildIds, options.revalidateAgainst);
     const lineageOutcome = options.removeLineageReferences ? await removeLineageReferences(tx, taskId, options.revalidateAgainst ?? liveChildIds, now, layer.projectId, options.promptByChildId, options.evidenceTargetVersionForTest) : { clearedChildIds: [], evidenceVersionByChild: /* @__PURE__ */ new Map(), evidenceUnavailableChildIds: [], evidenceInsertAttempts: 0 };
     await options.beforeArchive?.(tx);
-    await upsertArchivedTaskEntry(tx, entry, layer.projectId);
+    const lockedEntry = Array.isArray(live?.recommendations) ? { ...entry, recommendations: live.recommendations } : entry;
+    await upsertArchivedTaskEntry(tx, lockedEntry, layer.projectId);
     await softDeleteTaskRowInTransaction(tx, taskId, now, false, layer.projectId);
     return options.revalidateAgainst === void 0 ? { archived: true } : { archived: true, lineageOutcome };
   });
@@ -99376,10 +99602,11 @@ async function linkTaskRecommendationImpl(store, id, recommendationId, createdTa
       await acquireTaskAdvisoryXactLock(tx, layer.projectId, id);
       const row = await readTaskRowInTransaction(tx, id, { includeDeleted: true }, layer.projectId);
       if (!row) throw new TaskNotFoundError(id);
-      if (row.deletedAt) throw new TaskDeletedError(id, row.deletedAt);
-      const current = store.rowToTask(store.pgRowToTaskRow(row));
-      if (completeColumns && !completeColumns.has(current.column)) {
-        throw new Error("Recommendations are available only on completed tasks");
+      const archivedEntry = row.deletedAt ? await findArchivedTaskEntry(tx, id, layer.projectId) : void 0;
+      if (row.deletedAt && !archivedEntry) throw new TaskDeletedError(id, row.deletedAt);
+      const current = archivedEntry ? store.archiveEntryToTask(archivedEntry, false) : store.rowToTask(store.pgRowToTaskRow(row));
+      if (!archivedEntry && completeColumns && !completeColumns.has(current.column)) {
+        throw new Error("Recommendations are available only on completed or archived tasks");
       }
       const index2 = current.recommendations?.findIndex((item) => item.id === recommendationId) ?? -1;
       if (index2 < 0) throw new Error("Recommendation no longer exists");
@@ -99387,26 +99614,39 @@ async function linkTaskRecommendationImpl(store, id, recommendationId, createdTa
       if (recommendation.createdTaskId && recommendation.createdTaskId !== createdTaskId) {
         throw new Error("Recommendation is already linked to another task");
       }
-      if (recommendation.createdTaskId === createdTaskId) return current;
+      if (recommendation.createdTaskId === createdTaskId) return { task: current, archived: Boolean(archivedEntry) };
       const recommendations = current.recommendations.map(
         (item) => item.id === recommendationId ? { ...item, createdTaskId } : item
       );
       const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (archivedEntry) {
+        const updatedEntry = { ...archivedEntry, recommendations, updatedAt };
+        await upsertArchivedTaskEntry(tx, updatedEntry, layer.projectId);
+        await tx.update(project_exports.tasks).set({ recommendations, updatedAt }).where(and(
+          eq(project_exports.tasks.id, id),
+          taskProjectScope(layer),
+          isNotNull(project_exports.tasks.deletedAt)
+        ));
+        return { task: store.archiveEntryToTask(updatedEntry, false), archived: true };
+      }
       const [updatedRow] = await tx.update(project_exports.tasks).set({ recommendations, updatedAt }).where(and(
         eq(project_exports.tasks.id, id),
         taskProjectScope(layer),
+        isNull(project_exports.tasks.deletedAt),
         ...completeColumns ? [inArray(project_exports.tasks.column, [...completeColumns])] : []
       )).returning();
       if (!updatedRow) {
-        if (completeColumns) throw new Error("Recommendations are available only on completed tasks");
+        if (completeColumns) throw new Error("Recommendations are available only on completed or archived tasks");
         throw new TaskNotFoundError(id);
       }
-      return store.rowToTask(store.pgRowToTaskRow(updatedRow));
+      return { task: store.rowToTask(store.pgRowToTaskRow(updatedRow)), archived: false };
     });
-    await store.writeTaskJsonFile(store.taskDir(id), updated);
-    if (store.isWatching) store.taskCache.set(id, { ...updated });
-    store.emitTaskLifecycleEventSafely("task:updated", [updated]);
-    return updated;
+    if (!updated.archived) {
+      await store.writeTaskJsonFile(store.taskDir(id), updated.task);
+      if (store.isWatching) store.taskCache.set(id, { ...updated.task });
+    }
+    store.emitTaskLifecycleEventSafely("task:updated", [updated.task]);
+    return updated.task;
   });
 }
 async function normalizeWorkspaceTaskWorktreeMetadataImpl(store, id) {
@@ -102980,6 +103220,12 @@ async function taskToArchiveEntryImpl(store, task, archivedAt) {
     comments: task.comments,
     review: task.review,
     reviewState: task.reviewState,
+    /*
+    FNXC:ArchivedRecommendations 2026-09-20-17:23:
+    The cold archive is the authoritative terminal snapshot. Preserve recommendation records,
+    including createdTaskId, so archival cannot erase an accepted follow-up link.
+    */
+    recommendations: task.recommendations,
     prompt,
     ...agentLogFields,
     log: [{ timestamp: archivedAt, action: "Task archived" }],
@@ -108747,27 +108993,36 @@ async function listTaskRecommendationsImpl(store, options) {
   const limit = typeof rawLimit === "number" && Number.isFinite(rawLimit) ? Math.min(200, Math.max(1, Math.trunc(rawLimit))) : 50;
   const offset = typeof rawOffset === "number" && Number.isFinite(rawOffset) ? Math.max(0, Math.trunc(rawOffset)) : 0;
   const columns = [...completeColumns];
-  if (columns.length === 0) return { items: [], rowOffset: offset, rowLimit: limit, returnedRowCount: 0, totalRowCount: 0, hasMore: false };
-  const filter = and(
+  const liveFilter = columns.length === 0 ? void 0 : and(
     taskProjectScope(layer),
     isNull(project_exports.tasks.deletedAt),
     inArray(project_exports.tasks.column, columns),
     isNotNull(project_exports.tasks.recommendations),
     sql`jsonb_array_length(${project_exports.tasks.recommendations}) > 0`
   );
-  const [countRows, rows] = await Promise.all([
-    layer.db.select({ count: sql`count(*)` }).from(project_exports.tasks).where(filter),
-    layer.db.select({ id: project_exports.tasks.id, title: project_exports.tasks.title, column: project_exports.tasks.column, updatedAt: project_exports.tasks.updatedAt, recommendations: project_exports.tasks.recommendations }).from(project_exports.tasks).where(filter).orderBy(desc(project_exports.tasks.updatedAt), desc(project_exports.tasks.id)).limit(limit).offset(offset)
+  const [liveRows, archivedEntries] = await Promise.all([
+    liveFilter ? layer.db.select({ id: project_exports.tasks.id, title: project_exports.tasks.title, column: project_exports.tasks.column, updatedAt: project_exports.tasks.updatedAt, recommendations: project_exports.tasks.recommendations }).from(project_exports.tasks).where(liveFilter).orderBy(desc(project_exports.tasks.updatedAt), desc(project_exports.tasks.id)) : Promise.resolve([]),
+    listArchivedTasks(layer.db, layer.projectId)
   ]);
+  const rows = [
+    ...liveRows.map((row) => ({
+      id: row.id,
+      title: row.title ?? void 0,
+      column: row.column,
+      updatedAt: row.updatedAt,
+      recommendations: Array.isArray(row.recommendations) ? row.recommendations : []
+    })),
+    ...archivedEntries.filter((entry) => Array.isArray(entry.recommendations) && entry.recommendations.length > 0).map((entry) => ({ id: entry.id, title: entry.title, column: "archived", updatedAt: entry.updatedAt, recommendations: entry.recommendations }))
+  ].sort((a, b3) => b3.updatedAt.localeCompare(a.updatedAt) || b3.id.localeCompare(a.id));
+  const page = rows.slice(offset, offset + limit);
   const items = [];
-  for (const row of rows) {
-    if (!Array.isArray(row.recommendations) || row.recommendations.length === 0) continue;
+  for (const row of page) {
     for (const recommendation of row.recommendations) {
-      items.push({ taskId: row.id, taskTitle: row.title ?? void 0, taskColumn: row.column, updatedAt: row.updatedAt, recommendation });
+      items.push({ taskId: row.id, taskTitle: row.title, taskColumn: row.column, updatedAt: row.updatedAt, recommendation });
     }
   }
-  const totalRowCount = Number(countRows[0]?.count ?? 0);
-  const returnedRowCount = rows.length;
+  const totalRowCount = rows.length;
+  const returnedRowCount = page.length;
   return { items, rowOffset: offset, rowLimit: limit, returnedRowCount, totalRowCount, hasMore: offset + returnedRowCount < totalRowCount };
 }
 var LEGACY_REVIEW_LANES5, LEGACY_ARCHIVE_LANES2;
@@ -120354,6 +120609,7 @@ var init_bundled_plugin_install = __esm({
       "fusion-plugin-openclaw-runtime",
       "fusion-plugin-paperclip-runtime",
       "fusion-plugin-cursor-runtime",
+      "fusion-plugin-antigravity-runtime",
       "fusion-plugin-grok-runtime",
       "fusion-plugin-claude-runtime",
       // FNXC:OmpAcp 2026-07-11-23:35: Oh My Pi ACP runtime available as a staged/bundled install target.
@@ -143053,6 +143309,7 @@ __export(src_exports, {
   buildTaskDeleteNoticeIdempotencyKey: () => buildTaskDeleteNoticeIdempotencyKey,
   buildTaskExternalBlockClearPatch: () => buildTaskExternalBlockClearPatch,
   buildTaskExternalBlockPatch: () => buildTaskExternalBlockPatch,
+  buildTaskExternalBlockReport: () => buildTaskExternalBlockReport,
   buildTaskLineageTrailer: () => buildTaskLineageTrailer,
   buildTaskLogReadOnlyMessage: () => buildTaskLogReadOnlyMessage,
   buildTaskNotFoundMessage: () => buildTaskNotFoundMessage,
@@ -144595,8 +144852,8 @@ var init_src2 = __esm({
 });
 
 // ../engine/src/execution/lifecycle-move.ts
-async function moveTaskToContainedBackwardTarget(store, taskId, reason, options, liveColumn) {
-  const column = liveColumn ?? (await store.getTask(taskId)).column;
+async function moveTaskToContainedBackwardTarget(store, taskId, reason, options, _liveColumn) {
+  const column = (await store.getTask(taskId)).column;
   const revisionReasons = /* @__PURE__ */ new Set([
     "plan-review-revise-replan",
     "code-review-revise-remediation",
@@ -154573,8 +154830,8 @@ var require_graceful_fs = __commonJS({
       fs11.createReadStream = createReadStream;
       fs11.createWriteStream = createWriteStream;
       var fs$readFile = fs11.readFile;
-      fs11.readFile = readFile54;
-      function readFile54(path6, options, cb) {
+      fs11.readFile = readFile55;
+      function readFile55(path6, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path6, options, cb);
@@ -155736,6 +155993,27 @@ function createFusionCredentialStore(authStorage, resolvedCredentialInstance) {
     const normalizedProviderId = providerId === ANTHROPIC_PROVIDER_ID2 ? ANTHROPIC_PROVIDER_ID2 : providerId;
     return resolvedCredentialInstance?.providerId === normalizedProviderId ? resolvedCredentialInstance : void 0;
   };
+  const readCredential = (providerId) => {
+    const scopedRef = scopedRefFor(providerId);
+    return scopedRef ? authStorage.getInstance(scopedRef) : authStorage.get(providerId);
+  };
+  const modifyCredential = async (providerId, fn) => {
+    const scopedRef = scopedRefFor(providerId);
+    if (!scopedRef) {
+      return authStorage.modify(
+        providerId,
+        async (current) => fn(current)
+      );
+    }
+    const next = await fn(authStorage.getInstance(scopedRef));
+    if (next) await authStorage.setInstance(scopedRef, next);
+    return next;
+  };
+  const deleteCredential = async (providerId) => {
+    const scopedRef = scopedRefFor(providerId);
+    if (scopedRef) await authStorage.removeInstance(scopedRef);
+    else await authStorage.remove(providerId);
+  };
   return {
     /*
     FNXC:ProviderAuth 2026-07-17-06:30:
@@ -155747,23 +156025,36 @@ function createFusionCredentialStore(authStorage, resolvedCredentialInstance) {
         const token = await authStorage.getApiKey(ANTHROPIC_PROVIDER_ID2, scopedRef);
         return token ? { type: "api_key", key: token } : void 0;
       }
-      return scopedRef ? authStorage.getInstance(scopedRef) : authStorage.get(providerId);
+      if (providerId === META_PROVIDER_ID) {
+        const rawCredential = readCredential(META_PROVIDER_ID);
+        if (rawCredential?.type === "api_key") return rawCredential;
+        const subscriptionCredential = readCredential(META_SUBSCRIPTION_PROVIDER_ID);
+        return subscriptionCredential?.type === "oauth" ? subscriptionCredential : rawCredential;
+      }
+      return readCredential(providerId);
     },
     list: async () => authStorage.list().flatMap((providerId) => {
       const credential = scopedRefFor(providerId) ? authStorage.getInstance(scopedRefFor(providerId)) : authStorage.get(providerId);
       return credential?.type === "api_key" || credential?.type === "oauth" ? [{ providerId, type: credential.type }] : [];
     }),
     modify: async (providerId, fn) => {
-      const scopedRef = scopedRefFor(providerId);
-      if (!scopedRef) return authStorage.modify(providerId, async (current) => fn(current));
-      const next = await fn(authStorage.getInstance(scopedRef));
-      if (next) await authStorage.setInstance(scopedRef, next);
-      return next;
+      if (providerId === META_PROVIDER_ID) {
+        const rawCredential = readCredential(META_PROVIDER_ID);
+        if (rawCredential?.type !== "api_key" && readCredential(META_SUBSCRIPTION_PROVIDER_ID)?.type === "oauth") {
+          return modifyCredential(META_SUBSCRIPTION_PROVIDER_ID, fn);
+        }
+      }
+      return modifyCredential(providerId, fn);
     },
     delete: async (providerId) => {
-      const scopedRef = scopedRefFor(providerId);
-      if (scopedRef) await authStorage.removeInstance(scopedRef);
-      else await authStorage.remove(providerId);
+      if (providerId === META_PROVIDER_ID) {
+        const rawCredential = readCredential(META_PROVIDER_ID);
+        if (rawCredential?.type !== "api_key" && readCredential(META_SUBSCRIPTION_PROVIDER_ID)?.type === "oauth") {
+          await deleteCredential(META_SUBSCRIPTION_PROVIDER_ID);
+          return;
+        }
+      }
+      await deleteCredential(providerId);
     }
   };
 }
@@ -156369,7 +156660,7 @@ function createFusionAuthStorage() {
     }
   });
 }
-var import_proper_lockfile, AUTH_LOCK_OPTIONS, authWriteQueues, FusionFileAuthStorage, CredentialInstanceResolutionError, OAUTH_REFRESH_BUFFER_MS, ANTHROPIC_PROVIDER_ID2, OAUTH_REFRESH_FAILURE_COOLDOWN_MS;
+var import_proper_lockfile, AUTH_LOCK_OPTIONS, authWriteQueues, FusionFileAuthStorage, CredentialInstanceResolutionError, OAUTH_REFRESH_BUFFER_MS, ANTHROPIC_PROVIDER_ID2, META_PROVIDER_ID, META_SUBSCRIPTION_PROVIDER_ID, OAUTH_REFRESH_FAILURE_COOLDOWN_MS;
 var init_auth_storage = __esm({
   "../engine/src/auth/auth-storage.ts"() {
     "use strict";
@@ -156670,8 +156961,9 @@ var init_auth_storage = __esm({
           return { result: existing, changed: false };
         });
       }
+      // FNXC:ProviderAuth 2026-09-20-16:20: Pi 0.86.1 registers Meta's Muse OAuth login; preserve the raw runtime id for ModelRuntime.login.
       getOAuthProviders() {
-        return [{ id: "anthropic", name: "Anthropic" }, { id: "openai-codex", name: "OpenAI Codex" }, { id: "github-copilot", name: "GitHub Copilot" }];
+        return [{ id: "anthropic", name: "Anthropic" }, { id: "openai-codex", name: "OpenAI Codex" }, { id: "github-copilot", name: "GitHub Copilot" }, { id: "meta", name: "Meta (Muse)" }];
       }
       setModelRuntime(modelRuntime) {
         this.modelRuntime = modelRuntime;
@@ -156713,6 +157005,8 @@ var init_auth_storage = __esm({
     };
     OAUTH_REFRESH_BUFFER_MS = 5 * 6e4;
     ANTHROPIC_PROVIDER_ID2 = "anthropic";
+    META_PROVIDER_ID = "meta";
+    META_SUBSCRIPTION_PROVIDER_ID = "meta-subscription";
     OAUTH_REFRESH_FAILURE_COOLDOWN_MS = 3e4;
   }
 });
@@ -157540,7 +157834,7 @@ function derivePreviousText(partial2, contentIndex, delta, kind) {
   const content = partial2?.content;
   const block = Array.isArray(content) && Number.isInteger(contentIndex) && contentIndex >= 0 ? content[contentIndex] : void 0;
   const accumulated = getContentText(block, kind);
-  return accumulated && delta && accumulated.endsWith(delta) ? accumulated.slice(0, Math.max(0, accumulated.length - delta.length)) : accumulated;
+  return accumulated && delta && accumulated.endsWith(delta) ? accumulated.slice(0, Math.max(0, accumulated.length - delta.length)) : "";
 }
 function identityFor(partial2, contentIndex) {
   const objectPartial = partial2 !== null && typeof partial2 === "object" ? partial2 : void 0;
@@ -157591,17 +157885,10 @@ function indexOf(value) {
   if (value === void 0) return 0;
   return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
 }
-function blockText(partial2, index2, kind) {
-  const content = record(partial2)?.content;
-  if (!Array.isArray(content) || index2 === void 0) return "";
-  const block = record(content[index2]);
-  if (block?.type !== kind) return "";
-  const value = block[kind === "text" ? "text" : "thinking"];
-  return typeof value === "string" ? value : "";
-}
 function createAssistantStreamCapture(sinks) {
   const normalizer = createStreamingDeltaNormalizer();
   const emitted = { text: /* @__PURE__ */ new Map(), thinking: /* @__PURE__ */ new Map() };
+  const seen = { text: /* @__PURE__ */ new Map(), thinking: /* @__PURE__ */ new Map() };
   let lastPartial;
   let lastTextPartial;
   let lastTextIndex;
@@ -157609,6 +157896,8 @@ function createAssistantStreamCapture(sinks) {
   const reset2 = () => {
     emitted.text.clear();
     emitted.thinking.clear();
+    seen.text.clear();
+    seen.thinking.clear();
     normalizer.noteBoundary("text");
     normalizer.noteBoundary("thinking");
     lastPartial = void 0;
@@ -157664,12 +157953,17 @@ function createAssistantStreamCapture(sinks) {
         if (!kind) return;
         if (type === `${kind}_delta`) {
           if (typeof update.delta !== "string" || index2 === void 0) return;
-          const delta = normalizer.normalize(partial2, index2, update.delta, kind);
-          emit(kind, delta, partial2, index2);
-          const full = blockText(partial2, index2, kind);
-          emitted[kind].set(index2, full ? full.length : (emitted[kind].get(index2) ?? 0) + update.delta.length);
+          const seenBefore = seen[kind].get(index2) ?? 0;
+          const seenAfter = seenBefore + update.delta.length;
+          const emittedBefore = emitted[kind].get(index2) ?? 0;
+          const sourceSegment = update.delta.slice(Math.max(0, emittedBefore - seenBefore));
+          if (sourceSegment) {
+            const delta = normalizer.normalize(partial2, index2, sourceSegment, kind);
+            emit(kind, delta, partial2, index2);
+          }
+          seen[kind].set(index2, seenAfter);
+          emitted[kind].set(index2, Math.max(emittedBefore, seenAfter));
         } else if (type === `${kind}_start`) {
-          flush(kind, blockText(partial2, index2, kind), partial2, index2);
         } else if (type === `${kind}_end`) {
           flush(kind, typeof update.content === "string" ? update.content : "", partial2, index2);
         }
@@ -158218,6 +158512,9 @@ function buildMissingClaudeRuntimeError() {
 function buildMissingCursorRuntimeError() {
   return unavailable("Cursor CLI", "Install and enable the Cursor runtime plugin (fusion-plugin-cursor-runtime), install `cursor-agent`, and authenticate with `cursor-agent login`.");
 }
+function buildMissingAntigravityRuntimeError() {
+  return unavailable("Google Antigravity CLI", "Install and enable the Antigravity runtime plugin (fusion-plugin-antigravity-runtime), install `agy`, and complete its vendor login flow.");
+}
 function getCliProviderRouting(providerId) {
   return CLI_PROVIDER_ROUTING_CENSUS.find((entry) => entry.providerId === providerId);
 }
@@ -158302,7 +158599,9 @@ var init_cli_provider_routing = __esm({
       { providerId: "grok-cli", classification: "runtime-routed", runtimeId: "grok", autoDerive: "fail-fast", guardNotApplicable: "pinned-pi-fallback", onExplicitHint: "defer-to-resolve-runtime", fallbackPolicy: "defer-to-runtime", missingRuntimeError: buildMissingGrokRuntimeError, rationale: "Visible-key, fallback-only, and explicit-hint paths intentionally preserve the shipped direct xAI/pi fallback." },
       { providerId: "hermes", classification: "runtime-routed", runtimeId: "hermes", autoDerive: "fail-fast", guardNotApplicable: "pinned-pi-fallback", onExplicitHint: "assert-available", fallbackPolicy: "drop-with-warning", missingRuntimeError: buildMissingHermesRuntimeError, rationale: "Fallback-only Hermes cannot be resolved by a healthy primary pi runtime." },
       { providerId: "claude-cli", classification: "runtime-routed", runtimeId: "claude", autoDerive: "fail-fast", guardNotApplicable: "pinned-pi-fallback", onExplicitHint: "assert-available", fallbackPolicy: "drop-with-warning", missingRuntimeError: buildMissingClaudeRuntimeError, rationale: "Fallback-only Claude CLI cannot be resolved by a healthy primary pi runtime." },
-      { providerId: "cursor-cli", classification: "runtime-routed", runtimeId: "cursor", autoDerive: "fail-fast", guardNotApplicable: "pinned-pi-fallback", onExplicitHint: "assert-available", fallbackPolicy: "defer-cross-runtime", missingRuntimeError: buildMissingCursorRuntimeError, rationale: "Cursor fallback is withheld from a healthy foreign runtime and armed for a single prompt-time cross-runtime swap." }
+      { providerId: "cursor-cli", classification: "runtime-routed", runtimeId: "cursor", autoDerive: "fail-fast", guardNotApplicable: "pinned-pi-fallback", onExplicitHint: "assert-available", fallbackPolicy: "defer-cross-runtime", missingRuntimeError: buildMissingCursorRuntimeError, rationale: "Cursor fallback is withheld from a healthy foreign runtime and armed for a single prompt-time cross-runtime swap." },
+      // FNXC:AntigravityProvider 2026-09-20-18:32: Agy has no proven safe cross-runtime context transfer, so fallback-only selection must retain the healthy primary runtime.
+      { providerId: "antigravity-cli", classification: "runtime-routed", runtimeId: "antigravity", autoDerive: "fail-fast", guardNotApplicable: "pinned-pi-fallback", onExplicitHint: "assert-available", fallbackPolicy: "drop-with-warning", missingRuntimeError: buildMissingAntigravityRuntimeError, rationale: "Non-ACP agy fallback is dropped rather than silently replacing the active primary." }
     ];
   }
 });
@@ -187682,8 +187981,8 @@ async function runWorkflowMergeAttemptNode(deps, ctx, task) {
   };
 }
 function classifyMergePrimitiveResult(data, value, primitiveOutcome) {
-  if (value === MERGE_BOUNDARY_UNPROVEN_VALUE) {
-    return { outcome: "failure", value: MERGE_BOUNDARY_UNPROVEN_VALUE };
+  if (value === MERGE_BOUNDARY_RECOVERY_VALUE || value === MERGE_BOUNDARY_UNPROVEN_VALUE) {
+    return { outcome: "failure", value };
   }
   if (data?.status === "merged") {
     return { outcome: "success", value: data.noOp ? "already-landed" : "merged" };
@@ -187727,11 +188026,12 @@ function classifyMergeFailure(reason) {
   }
   return { outcome: "failure", value: "merge-failed" };
 }
-var MERGE_BOUNDARY_UNPROVEN_VALUE, PRESERVED_MERGE_FAILURE_REASONS;
+var MERGE_BOUNDARY_UNPROVEN_VALUE, MERGE_BOUNDARY_RECOVERY_VALUE, PRESERVED_MERGE_FAILURE_REASONS;
 var init_workflow_merge_nodes = __esm({
   "../engine/src/workflows/workflow-merge-nodes.ts"() {
     "use strict";
     MERGE_BOUNDARY_UNPROVEN_VALUE = "merge-boundary-unproven";
+    MERGE_BOUNDARY_RECOVERY_VALUE = "merge-boundary-evidence-recovery";
     PRESERVED_MERGE_FAILURE_REASONS = /* @__PURE__ */ new Set(["implementation-incomplete", "merge-unavailable", "workspace-review-required"]);
   }
 });
@@ -194881,9 +195181,9 @@ async function isRememberedWorkspaceWorktreeLive(repoRootDir, worktreePath) {
 async function acquireWorkspaceRepoWorktree(opts) {
   const { repoRelPath, workspaceRootDir, task, store, settings, logger: logger3, secretsStore, audit, runContext, runConfiguredCommand: runConfiguredCommand2, ensureDependencyReadiness, taskEnv, validateTaskBeforeCreate } = opts;
   const registry3 = opts.registry ?? activeSessionRegistry;
-  const { join: join103 } = await import("node:path");
+  const { join: join104 } = await import("node:path");
   assertInRootRepoRelPath(repoRelPath);
-  const repoAbsPath = join103(workspaceRootDir, repoRelPath);
+  const repoAbsPath = join104(workspaceRootDir, repoRelPath);
   let durableAcquireLease;
   let acquireLeaseLost = false;
   let acquireLeaseRenewalInFlight;
@@ -196589,6 +196889,15 @@ function shouldWithholdWedgeAlertForAutoRecovery(task, options) {
 }
 function describeTaskWedge(task) {
   if (isTaskProgressing(task)) return null;
+  if (task.status === "blocked" && task.paused === true && task.pausedReason === "external-block" && task.userPaused !== true && task.autoMerge !== false && task.externalBlock) {
+    const report2 = buildTaskExternalBlockReport(task.externalBlock, task.externalBlock.report);
+    return {
+      reasonKey: `external-block:${task.externalBlock.origin}:${task.externalBlock.code}`,
+      reason: report2.stopReason,
+      action: report2.unblockCondition,
+      externalBlockReport: report2
+    };
+  }
   const error2 = task.error ?? "";
   const hasPauseProof = task.paused === true || task.status === "paused";
   if (hasPauseProof && task.pausedReason === "completed-blocked") {
@@ -196713,7 +197022,56 @@ var init_task_wedge_notification = __esm({
   }
 });
 
+// ../engine/src/notification/mailbox-delivery.ts
+async function deliverMailboxMessageOnce(store, input, idempotencyKey, timeoutMs = MAILBOX_DELIVERY_TIMEOUT_MS) {
+  if (!store?.sendMessageOnce) return "unavailable";
+  let timer2;
+  try {
+    const delivery = Promise.resolve().then(() => store.sendMessageOnce(input, idempotencyKey));
+    void delivery.catch(() => void 0);
+    const timedOut = new Promise((resolve54) => {
+      timer2 = setTimeout(() => resolve54("timeout"), Math.max(1, timeoutMs));
+      timer2.unref?.();
+    });
+    const outcome = await Promise.race([delivery.then(() => "delivered", () => "unavailable"), timedOut]);
+    return outcome === "delivered" ? "delivered" : "unavailable";
+  } catch {
+    return "unavailable";
+  } finally {
+    if (timer2) clearTimeout(timer2);
+  }
+}
+var MAILBOX_DELIVERY_TIMEOUT_MS;
+var init_mailbox_delivery = __esm({
+  "../engine/src/notification/mailbox-delivery.ts"() {
+    "use strict";
+    MAILBOX_DELIVERY_TIMEOUT_MS = 5e3;
+  }
+});
+
 // ../engine/src/notification/notification-service.ts
+function formatWedgeMailboxContent(task, descriptor, link) {
+  if (descriptor.externalBlockReport) {
+    const report2 = descriptor.externalBlockReport;
+    return [
+      `**${formatTaskIdentifier(task)} is blocked and needs operator action**`,
+      "",
+      `**Verified:** ${report2.verifiedCondition}`,
+      `**Why work stopped:** ${report2.stopReason}`,
+      `**Not implemented:** ${report2.unimplementedWork}`,
+      `**Unblock:** ${report2.unblockCondition}`,
+      ...link ? ["", `[Open ${task.id}](${link})`] : []
+    ].join("\n");
+  }
+  return [
+    `**${formatTaskIdentifier(task)} needs operator action**`,
+    "",
+    descriptor.reason,
+    ...descriptor.gate ? [`Gate: \`${descriptor.gate}\`.`] : [],
+    `Recommended action: ${descriptor.action}`,
+    ...link ? ["", `[Open ${task.id}](${link})`] : []
+  ].join("\n");
+}
 var NotificationService;
 var init_notification_service = __esm({
   "../engine/src/notification/notification-service.ts"() {
@@ -196724,6 +197082,7 @@ var init_notification_service = __esm({
     init_ntfy_provider();
     init_webhook_provider();
     init_task_wedge_notification();
+    init_mailbox_delivery();
     NotificationService = class {
       constructor(store, options = {}) {
         this.store = store;
@@ -197171,14 +197530,7 @@ var init_notification_service = __esm({
           if (!episode) return "suppressed";
         }
         const link = buildNtfyClickUrl({ dashboardHost: this.dashboardHost, projectId: this.options.projectId, taskId: task.id });
-        const content = [
-          `**${formatTaskIdentifier(task)} needs operator action**`,
-          "",
-          descriptor.reason,
-          ...descriptor.gate ? [`Gate: \`${descriptor.gate}\`.`] : [],
-          `Recommended action: ${descriptor.action}`,
-          ...link ? ["", `[Open ${task.id}](${link})`] : []
-        ].join("\n");
+        const content = formatWedgeMailboxContent(task, descriptor, link);
         const payload = {
           taskId: task.id,
           taskTitle: task.title,
@@ -197188,19 +197540,15 @@ var init_notification_service = __esm({
           metadata: { wedgeReason: descriptor.reasonKey, reason: descriptor.reason, action: descriptor.action, ...descriptor.gate ? { gate: descriptor.gate } : {}, notificationDedupeKey: `task-wedge:${episode}` }
         };
         void this.dispatch("task-wedged", payload);
-        try {
-          await this.options.messageStore?.sendMessageOnce?.({
-            fromId: "system",
-            fromType: "system",
-            toId: DASHBOARD_USER_ID,
-            toType: "user",
-            type: "system",
-            content,
-            metadata: { taskId: task.id, kind: "task-wedge", wedgeReason: descriptor.reasonKey, ...descriptor.gate ? { gate: descriptor.gate } : {} }
-          }, `task-wedge:${episode}`);
-        } catch (error2) {
-          schedulerLog.log(`[notify] ${task.id} wedge mailbox message failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
-        }
+        await deliverMailboxMessageOnce(this.options.messageStore, {
+          fromId: "system",
+          fromType: "system",
+          toId: DASHBOARD_USER_ID,
+          toType: "user",
+          type: "system",
+          content,
+          metadata: { taskId: task.id, kind: "task-wedge", wedgeReason: descriptor.reasonKey, ...descriptor.gate ? { gate: descriptor.gate } : {} }
+        }, `task-wedge:${episode}`);
         if (isAutoRecoveryEscalationDispatch && classification.action === "notify") {
           try {
             await this.store.markTerminalFailureAutoRecoveryEscalationDelivered?.(task.id, {
@@ -197338,14 +197686,8 @@ var init_notification_service = __esm({
           }
           const payload = this.createTaskPayload(task, "task-wedged", { wedgeReason: descriptor.reasonKey, reason: descriptor.reason, action: descriptor.action, ...descriptor.gate ? { gate: descriptor.gate } : {}, notificationDedupeKey: `task-wedge:${claim.episodeId}` });
           void this.dispatch("task-wedged", payload);
-          const content = `**${formatTaskIdentifier(task)} needs operator action**
-
-${descriptor.reason}
-Recommended action: ${descriptor.action}`;
-          try {
-            await this.options.messageStore?.sendMessageOnce?.({ fromId: "system", fromType: "system", toId: DASHBOARD_USER_ID, toType: "user", type: "system", content, metadata: { taskId, kind: "task-wedge", wedgeReason: descriptor.reasonKey } }, `task-wedge:${claim.episodeId}`);
-          } catch {
-          }
+          const content = formatWedgeMailboxContent(task, descriptor, buildNtfyClickUrl({ dashboardHost: this.dashboardHost, projectId: this.options.projectId, taskId }));
+          await deliverMailboxMessageOnce(this.options.messageStore, { fromId: "system", fromType: "system", toId: DASHBOARD_USER_ID, toType: "user", type: "system", content, metadata: { taskId, kind: "task-wedge", wedgeReason: descriptor.reasonKey } }, `task-wedge:${claim.episodeId}`);
           return { outcome: "delivered", reasonKey: descriptor.reasonKey };
         } catch (error2) {
           schedulerLog.debug(`[notify] ${taskId} pending wedge completion failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
@@ -211450,7 +211792,7 @@ var agent_reflection_exports = {};
 __export(agent_reflection_exports, {
   AgentReflectionService: () => AgentReflectionService
 });
-import { readFile as readFile53 } from "node:fs/promises";
+import { readFile as readFile54 } from "node:fs/promises";
 import { isAbsolute as isAbsolute26, resolve as resolve52 } from "node:path";
 var reflectionLog, REFLECTION_SYSTEM_PROMPT, DEFAULT_OUTCOME_LIMIT, AgentReflectionService;
 var init_agent_reflection = __esm({
@@ -212038,7 +212380,7 @@ Rules:
         if (agent.instructionsPath?.trim()) {
           const resolvedPath = isAbsolute26(agent.instructionsPath) ? agent.instructionsPath : resolve52(this.rootDir, agent.instructionsPath);
           try {
-            const content = await readFile53(resolvedPath, "utf-8");
+            const content = await readFile54(resolvedPath, "utf-8");
             if (content.trim()) {
               pieces.push(content.trim());
             }
@@ -213025,16 +213367,16 @@ async function persistBranchState(persistence, state) {
     );
   }
 }
-function resolveJoinConfig(join103) {
-  const rawMode = join103.config?.mode;
+function resolveJoinConfig(join104) {
+  const rawMode = join104.config?.mode;
   let mode = "all";
   if (rawMode === "all" || rawMode === "any") mode = rawMode;
   else if (rawMode && typeof rawMode === "object" && "quorum" in rawMode) {
     const n = rawMode.quorum;
     if (typeof n === "number" && Number.isInteger(n) && n > 0) mode = { quorum: n };
-    else throw new WorkflowIrError(`join '${join103.id}' quorum must be a positive integer`);
+    else throw new WorkflowIrError(`join '${join104.id}' quorum must be a positive integer`);
   }
-  const rawFail = join103.config?.onBranchFailure;
+  const rawFail = join104.config?.onBranchFailure;
   const onBranchFailure = rawFail === "collect" ? "collect" : "fail-fast";
   return { mode, onBranchFailure };
 }
@@ -213050,9 +213392,9 @@ async function runSplitJoin(split, env) {
   if (branchEdges.length === 0) {
     throw new WorkflowIrError(`split '${split.id}' has no traversable branches`);
   }
-  const join103 = findMatchingJoin(branchEdges[0].to, env);
-  if (!join103) throw new WorkflowIrError(`split '${split.id}' has no reachable matching join`);
-  const joinConfig = resolveJoinConfig(env.nodeMap.get(join103));
+  const join104 = findMatchingJoin(branchEdges[0].to, env);
+  if (!join104) throw new WorkflowIrError(`split '${split.id}' has no reachable matching join`);
+  const joinConfig = resolveJoinConfig(env.nodeMap.get(join104));
   const controller = new AbortController();
   const branchCount = branchEdges.length;
   const required2 = requiredCompletions(joinConfig.mode, branchCount);
@@ -213088,7 +213430,7 @@ async function runSplitJoin(split, env) {
   };
   const branchPromises = branchEdges.map((edge) => {
     const branchId = edge.to;
-    return walkBranch(branchId, join103, env, controller.signal, visitedNodeIds).then((result) => {
+    return walkBranch(branchId, join104, env, controller.signal, visitedNodeIds).then((result) => {
       branchOutcomes.push({ branchId, outcome: result.outcome, nodeId: result.lastNodeId });
       if (result.outcome === "success") succeeded += 1;
       else failed += 1;
@@ -213106,7 +213448,7 @@ async function runSplitJoin(split, env) {
   });
   const outcome = await joinReached;
   await Promise.allSettled(branchPromises);
-  return { joinNodeId: join103, outcome, branchOutcomes, visitedNodeIds };
+  return { joinNodeId: join104, outcome, branchOutcomes, visitedNodeIds };
 }
 async function walkBranch(startNodeId, joinId, env, signal, visitedNodeIds) {
   let currentId = startNodeId;
@@ -222074,8 +222416,11 @@ async function rerouteSingularStaleContentToReview(store, task, options) {
 
 // ../engine/src/merge/pre-merge-gate-reseed.ts
 init_src2();
+function isRecoverableUnrunGatePark(task) {
+  return task.status === "failed" && !task.userPaused && !task.deletedAt && task.autoMerge !== false && (!task.paused || task.pausedReason === IN_REVIEW_STALL_DEADLOCK_PAUSE_REASON) && typeof task.error === "string" && (task.error.endsWith(PRE_MERGE_STEPS_NOT_RUN_BLOCKER) || !task.workflowIrPin && task.error.startsWith("Workflow drift park:") && task.error.includes("Stale IR pin cleared"));
+}
 async function rerouteUnrunPreMergeGateToReview(store, task, options) {
-  const { mergeContent, requiredPreMergeStepIds } = options;
+  const { mergeContent, requiredPreMergeStepIds, expectedWorkflowSelection } = options;
   if (mergeContent.kind !== "singular" || task.workspaceWorktrees !== void 0) return { rerouted: false, reason: "not-singular" };
   if (task.paused || task.userPaused || task.deletedAt || task.autoMerge === false) return { rerouted: false, reason: "operator-held" };
   if (requiredPreMergeStepIds.size === 0) return { rerouted: false, reason: "no-unrun-gate" };
@@ -222095,9 +222440,16 @@ async function rerouteUnrunPreMergeGateToReview(store, task, options) {
     continuationSequence: items.length,
     sourceColumn: task.column,
     targetColumn: node.column ?? task.column,
-    irHash: computeWorkflowIrPin(ir2, node.id).irHash
+    irHash: computeWorkflowIrPin(ir2, node.id).irHash,
+    expectedWorkflowSelection
   });
-  return result.seeded ? { rerouted: true, reason: "seeded", nodeId: node.id, workflowStepId: node.id } : { rerouted: false, reason: "active-continuation", nodeId: node.id, workflowStepId: node.id };
+  if (result.seeded) return { rerouted: true, reason: "seeded", nodeId: node.id, workflowStepId: node.id };
+  return {
+    rerouted: false,
+    reason: result.reason === "workflow-selection-changed" ? "workflow-selection-changed" : "active-continuation",
+    nodeId: node.id,
+    workflowStepId: node.id
+  };
 }
 
 // ../engine/src/healing/auto-recovery.ts
@@ -222571,6 +222923,469 @@ async function terminalizeEmptyReviewContent(deps, taskId, fence) {
   return true;
 }
 
+// ../engine/src/executor/evaluate-workflow-merge-boundary.ts
+init_src2();
+async function evaluateWorkflowMergeBoundary(deps, task, runId) {
+  const relevant = (task.workflowStepResults ?? []).filter(
+    (result) => result.source === "node" && (result.phase ?? "pre-merge") === "pre-merge"
+  );
+  const hasRelevantNodeResult = relevant.length > 0;
+  const nonTerminalResult = relevant.find((result) => result.status !== "passed" && result.status !== "skipped");
+  const allResultsTerminal = nonTerminalResult === void 0;
+  let ir2;
+  try {
+    ir2 = await resolveWorkflowIrForTask(deps.store, task.id);
+  } catch {
+  }
+  if (!ir2) return { resolved: false, hasRelevantNodeResult, allResultsTerminal, coverageComplete: true, hasLiveStepImplementationProof: false, hasForeachStepExecute: false, missingInstanceIds: [], nonTerminalResult, complete: false };
+  let persistedInstances = [];
+  try {
+    persistedInstances = await deps.loadMergeBoundaryInstances(task.id, runId);
+  } catch {
+  }
+  const coverage = evaluateForeachMergeProof({ ir: ir2, steps: task.steps, workflowStepResults: task.workflowStepResults, persistedInstances });
+  const coverageComplete = coverage.missingInstanceIds.length === 0;
+  const hasLiveStepImplementationProof = coverage.expectedInstanceIds.length > 0 && coverage.expectedInstanceIds.every((id) => coverage.liveStepSatisfiedInstanceIds.includes(id));
+  const complete = allResultsTerminal && coverageComplete && (hasRelevantNodeResult || hasLiveStepImplementationProof);
+  return { resolved: true, hasRelevantNodeResult, allResultsTerminal, coverageComplete, hasLiveStepImplementationProof, hasForeachStepExecute: coverage.hasForeachStepExecute, missingInstanceIds: coverage.missingInstanceIds, nonTerminalResult, complete };
+}
+async function getWorkflowMergeImplementationProofFailure(deps, task) {
+  const taint = evaluateSkipBypassTaint(task);
+  if (taint.blocked) return "implementation did not run: steps were skipped after a bulk-step-completion refusal without an accepted fn_task_done";
+  if (task.noCommitsExpected === true) return void 0;
+  let ir2;
+  try {
+    ir2 = await resolveWorkflowIrForTask(deps.store, task.id);
+  } catch {
+    ir2 = void 0;
+  }
+  if (!ir2) return void 0;
+  const usesParsedSteps = ir2.nodes.some((node) => node.kind === "parse-steps");
+  const usesExecuteSeam = ir2.nodes.some((node) => node.kind === "prompt" && node.config?.seam === "execute");
+  if (!usesParsedSteps && !usesExecuteSeam) return void 0;
+  const steps = Array.isArray(task.steps) ? task.steps : [];
+  const hasTerminalParsedSteps = steps.length > 0 && steps.every((step) => step.status === "done" || step.status === "skipped");
+  const hasModifiedFiles = (task.modifiedFiles?.length ?? 0) > 0;
+  const proof = await deps.evaluateWorkflowMergeBoundary(task);
+  const hasGraphNativeImplementationProof = proof.hasRelevantNodeResult && proof.allResultsTerminal && proof.coverageComplete;
+  if (usesParsedSteps) {
+    if (hasTerminalParsedSteps || hasGraphNativeImplementationProof) return void 0;
+    return proof.hasForeachStepExecute && !proof.coverageComplete ? `implementation did not run: foreach step instances are incomplete (missing ${proof.missingInstanceIds.join(", ")})` : "implementation did not run: parsed coding steps are missing or incomplete";
+  }
+  if (usesExecuteSeam) return hasTerminalParsedSteps || hasModifiedFiles || hasGraphNativeImplementationProof ? void 0 : "implementation did not run: execute seam has no completion proof";
+  return void 0;
+}
+
+// ../engine/src/executor/workflow-merge-boundary-helpers.ts
+init_src2();
+async function resolveMergeBoundaryColumn(deps, taskId, nodeId) {
+  try {
+    const ir2 = await resolveWorkflowIrForTask(deps.store, taskId);
+    const named = ir2.nodes.find((n) => n.id === nodeId);
+    if (named && MERGE_REGION_KINDS.has(named.kind) && named.column) return named.column;
+    const mergeNode = ir2.nodes.find((n) => MERGE_REGION_KINDS.has(n.kind) && n.column);
+    if (mergeNode?.column) return mergeNode.column;
+    return "in-review";
+  } catch {
+    return "in-review";
+  }
+}
+async function loadMergeBoundaryInstances(deps, taskId, runId) {
+  if (!runId) return [];
+  const store = deps.store;
+  try {
+    return await store.loadWorkflowRunStepInstancesAsync?.(taskId, runId) ?? store.loadWorkflowRunStepInstances?.(taskId, runId) ?? [];
+  } catch {
+    return [];
+  }
+}
+function shouldCompleteChecklistAtWorkflowMerge(task, proof) {
+  if (!Array.isArray(task.steps) || task.steps.length === 0) return false;
+  if (task.steps.every((step) => step.status === "done" || step.status === "skipped")) return false;
+  if (proof) return proof.complete;
+  const graphNodeResults = (task.workflowStepResults ?? []).filter((result) => result.source === "node" && (result.phase ?? "pre-merge") === "pre-merge");
+  return graphNodeResults.length > 0 && graphNodeResults.every((result) => result.status === "passed" || result.status === "skipped");
+}
+
+// ../engine/src/executor/route-graph-failure-to-execution-resume.ts
+init_src2();
+
+// ../engine/src/execution-block-classifier.ts
+init_usage_limit_detector();
+init_transient_error_detector();
+var HOST_EXTERNAL_CODES = ["ENOSPC", "EDQUOT", "EROFS", "ENOMEM", "EMFILE", "ENFILE"];
+var NETWORK_EXTERNAL_CODES = ["ECONNREFUSED", "ECONNRESET", "ETIMEDOUT", "EAI_AGAIN", "ENOTFOUND"];
+function classifyExternalObstacle(message) {
+  const normalized3 = message.trim();
+  if (!normalized3) return void 0;
+  if (/Forbidden lifecycle path|rejected by the task lifecycle projection|TransitionRejectionError/i.test(normalized3)) {
+    return void 0;
+  }
+  for (const code of HOST_EXTERNAL_CODES) {
+    if (new RegExp(`\\b${code}\\b`, "i").test(normalized3)) return { origin: "host-environment", code };
+  }
+  for (const code of NETWORK_EXTERNAL_CODES) {
+    if (new RegExp(`\\b${code}\\b`, "i").test(normalized3)) return { origin: "network", code };
+  }
+  if (/socket hang up/i.test(normalized3)) return { origin: "network", code: "SOCKET_HANG_UP" };
+  if (isTransientAuthCredentialError(normalized3)) return void 0;
+  if (isUsageLimitError(normalized3)) return { origin: "model-provider", code: "USAGE_LIMIT" };
+  if (isOperatorActionableAgentError(normalized3)) return { origin: "credentials", code: "CREDENTIALS" };
+  return void 0;
+}
+function detectRepairableObstacleHint(message) {
+  const normalized3 = message.trim();
+  if (!normalized3) return void 0;
+  const missingSignal = /\b(?:command not found|not installed|is not recognized as an internal or external command)\b|\bneither\b.{0,80}\binstalled\b/i;
+  const missingFileSignal = /(?:\b(?:spawn|exec(?:ute)?|binary|executable|interpreter|command)\b.{0,80}\b(?:ENOENT|no such file or directory)\b|\bENOENT\b.{0,80}\b(?:binary|executable|interpreter|command)\b)/i;
+  if (!missingSignal.test(normalized3) && !missingFileSignal.test(normalized3)) return void 0;
+  return /\b(?:service|daemon)\b/i.test(normalized3) ? "missing-service" : "missing-tooling";
+}
+var TASK_ID_RE = /^[A-Z][A-Z0-9]*-\d+$/i;
+var LEGACY_PR_REF_RE = /^(?:pr[:#-]|#|PR-)(\d+)$/i;
+function partitionBlockedByRefs(blockedBy) {
+  const taskIds = [];
+  for (const raw of blockedBy) {
+    const id = raw.trim();
+    if (!id) continue;
+    if (LEGACY_PR_REF_RE.test(id)) continue;
+    if (TASK_ID_RE.test(id)) {
+      const m2 = id.toUpperCase().match(/^([A-Z][A-Z0-9]*)-(\d+)$/);
+      taskIds.push(m2 ? `${m2[1]}-${m2[2]}` : id.toUpperCase());
+    }
+  }
+  return { taskIds: [...new Set(taskIds)] };
+}
+function classifyBlockedExit(_reason, blockedBy = []) {
+  const { taskIds } = partitionBlockedByRefs(blockedBy);
+  if (taskIds.length > 0) {
+    return {
+      class: "external",
+      thrashSignature: `tasks:${taskIds.slice().sort().join(",")}`
+    };
+  }
+  return {
+    class: "plan-defect",
+    thrashSignature: "plan-defect"
+  };
+}
+var BLOCKED_THRASH_LIMIT = 3;
+var BLOCKED_THRASH_WINDOW_MS = 60 * 60 * 1e3;
+function countBlockedThrashHits(log42, signature, nowMs = Date.now(), windowMs = BLOCKED_THRASH_WINDOW_MS) {
+  if (!log42?.length) return 0;
+  if (signature === "plan-defect") return 0;
+  const cutoff = nowMs - windowMs;
+  let count2 = 0;
+  for (const entry of log42) {
+    const ts4 = entry.timestamp ? Date.parse(entry.timestamp) : Number.NaN;
+    if (Number.isFinite(ts4) && ts4 < cutoff) continue;
+    const action = entry.action ?? "";
+    if (!action.startsWith("BLOCKED:") && !action.includes("DUPLICATE_REPLAN_EXHAUSTED") && !action.includes("BLOCKED_THRASH")) {
+      if (!action.includes("parked failed (honest blocked exit") && !action.includes("durable external block")) {
+        continue;
+      }
+    }
+    for (const part of signature.split("|")) {
+      if (part.startsWith("tasks:") && part.slice(6).split(",").some((id) => id && action.includes(id))) {
+        count2 += 1;
+        break;
+      }
+    }
+  }
+  return count2;
+}
+function isDurableBlockedTask(task) {
+  const meta2 = task.sourceMetadata;
+  if (!meta2 || typeof meta2 !== "object") return false;
+  if (meta2.blockedClass !== "external") return false;
+  return task.status === "failed" || task.status === "needs-replan";
+}
+function buildExternalBlockMetadataPatch(classification, thrashCount) {
+  return {
+    blockedClass: classification.class,
+    blockedThrashSignature: classification.thrashSignature,
+    blockedThrashCount: thrashCount,
+    externalBlockers: []
+  };
+}
+
+// ../engine/src/executor/route-graph-failure-to-execution-resume.ts
+init_logger();
+init_lifecycle_columns();
+
+// ../engine/src/executor/workflow-step-satisfaction.ts
+function hasNonTerminalWorkflowSteps(task) {
+  return task.steps.length > 0 && task.steps.some((step) => step.status !== "done" && step.status !== "skipped");
+}
+function workflowStepResultPassed(task, workflowStepId) {
+  const results = task?.workflowStepResults ?? [];
+  return results.some(
+    (result) => result.workflowStepId === workflowStepId && result.phase === "pre-merge" && result.status === "passed"
+  );
+}
+function areEnabledPreMergeWorkflowStepsSatisfied(task) {
+  const preMergeGateIds = /* @__PURE__ */ new Set(["plan-review", "browser-verification", "code-review"]);
+  const enabled = task?.enabledWorkflowSteps;
+  const enabledPreMerge = Array.isArray(enabled) && enabled.length > 0 ? enabled.filter((id) => preMergeGateIds.has(id)) : ["plan-review", "code-review"];
+  if (enabledPreMerge.length === 0) return false;
+  if (Array.isArray(enabled) && enabledPreMerge.length !== enabled.length) return false;
+  return enabledPreMerge.every((id) => workflowStepResultPassed(task, id));
+}
+function preservePreExecutionWorkflowStepResults(task) {
+  const preserved = (task.workflowStepResults ?? []).filter((result) => result.workflowStepId === "plan-review");
+  if (preserved.length > 0) return preserved;
+  let latest;
+  for (const entry of task.log ?? []) {
+    if (entry.action === "[pre-merge] Workflow step completed: Plan Review") {
+      latest = { timestamp: entry.timestamp, outcome: entry.outcome, status: "passed" };
+    } else if (entry.action === "[pre-merge] Workflow step failed: Plan Review") {
+      latest = { timestamp: entry.timestamp, outcome: entry.outcome, status: "failed" };
+    }
+  }
+  if (latest?.status !== "passed") return [];
+  return [
+    {
+      workflowStepId: "plan-review",
+      workflowStepName: "Plan Review",
+      phase: "pre-merge",
+      status: "passed",
+      verdict: "APPROVE",
+      ...latest.outcome ? { output: latest.outcome, notes: latest.outcome } : {},
+      ...latest.timestamp ? { startedAt: latest.timestamp, completedAt: latest.timestamp } : {}
+    }
+  ];
+}
+
+// ../engine/src/executor/route-graph-failure-to-execution-resume.ts
+init_workflow_merge_nodes();
+function isExecutableNode(node) {
+  const seam = node.config?.seam;
+  return node.kind === "foreach" || seam === "execute" || seam === "step-execute";
+}
+function isTerminalWorkItem(item) {
+  return item.state === "succeeded" || item.state === "failed" || item.state === "cancelled" || item.state === "exhausted" || item.state === "manual-required";
+}
+function findBoundaryRecoveryOwners(task, nodes2, evidence, workItems) {
+  if (!evidence || !["no-node-result", "non-terminal-node-result", "missing-foreach-instances"].includes(evidence.code)) return void 0;
+  if (evidence.code === "non-terminal-node-result") {
+    const id = evidence.nonTerminalNodeId;
+    const result = task.workflowStepResults?.find((entry) => entry.workflowStepId === id && entry.source === "node");
+    return id && result && result.status !== "passed" && result.status !== "failed" && result.status !== "skipped" && nodes2.some((node) => node.id === id && isExecutableNode(node)) ? [id] : void 0;
+  }
+  if (evidence.code === "missing-foreach-instances") {
+    const ids = evidence.missingInstanceIds;
+    if (ids.length === 0) return void 0;
+    const foreachOwners = nodes2.filter((node) => node.kind === "foreach");
+    const owners2 = ids.map(
+      (id) => (
+        // Prefer the longest prefix so nested/custom node names cannot misclassify an instance.
+        foreachOwners.filter((node) => id.startsWith(`${node.id}#`)).sort((left, right) => right.id.length - left.id.length)[0]?.id
+      )
+    );
+    if (owners2.some((owner) => owner === void 0)) return void 0;
+    return foreachOwners.filter((node) => owners2.includes(node.id)).map((node) => node.id);
+  }
+  if (!hasNonTerminalWorkflowSteps(task)) return void 0;
+  const terminalNodes = new Set(workItems.filter(isTerminalWorkItem).map((item) => item.nodeId));
+  const candidates = nodes2.filter((node) => isExecutableNode(node) && !terminalNodes.has(node.id));
+  return candidates.length === 1 && candidates[0] ? [candidates[0].id] : void 0;
+}
+var BOUNDARY_RECOVERY_CLAIM_STATUS = "merge-boundary-evidence-recovery";
+var BOUNDARY_RECOVERY_HELD_STATUS = "merge-boundary-evidence-recovery-held";
+var BOUNDARY_RECOVERY_CONCURRENT = /* @__PURE__ */ Symbol("merge-boundary-recovery-concurrent");
+var MAX_BOUNDARY_RECOVERY_ATTEMPTS = 4;
+var BOUNDARY_RECOVERY_BACKOFF_MS = [3e4, 6e4, 12e4, 3e5];
+function boundaryRecoverySignature(task, failedNode, evidence) {
+  return JSON.stringify({
+    failedNode,
+    evidence,
+    steps: task.steps.map((step, index2) => [index2, step.name, step.status]),
+    nodeResults: (task.workflowStepResults ?? []).filter((result) => result.source === "node").map((result) => [result.workflowStepId, result.status]).sort(([left], [right]) => String(left).localeCompare(String(right)))
+  });
+}
+async function recoverMergeBoundaryEvidenceGap(deps, live, failedNode, evidence, wipColumn, autoMergeSettings, liveSharedBranchMember = false) {
+  let claimed = false;
+  let deferred = false;
+  let held = false;
+  const now = Date.now();
+  const signature = boundaryRecoverySignature(live, failedNode, evidence);
+  await deps.store.updateTaskAtomic(live.id, (current) => {
+    if (!current || current.deletedAt || current.paused || current.userPaused || autoMergeSettings && !liveSharedBranchMember && (current.autoMerge === false || !allowsAutoMergeProcessing(current, autoMergeSettings)) || current.column !== live.column || current.status !== live.status || current.error !== live.error || live.columnMovedAt !== void 0 && current.columnMovedAt !== live.columnMovedAt) return null;
+    const prior = current.mergeDetails?.mergeBoundaryRecovery;
+    if (prior?.signature === signature) {
+      const nextCheckAt2 = Date.parse(prior.nextCheckAt ?? "");
+      if (Number.isFinite(nextCheckAt2) && nextCheckAt2 > now) {
+        deferred = true;
+        return null;
+      }
+      if (prior.attempt >= MAX_BOUNDARY_RECOVERY_ATTEMPTS) {
+        held = true;
+        return {
+          status: BOUNDARY_RECOVERY_HELD_STATUS,
+          error: "Workflow merge evidence recovery is held after unchanged proof gaps; waiting for durable implementation progress",
+          mergeDetails: {
+            ...current.mergeDetails,
+            mergeBoundaryRecovery: { ...prior, nextCheckAt: null, heldAt: new Date(now).toISOString() }
+          }
+        };
+      }
+    }
+    const attempt = prior?.signature === signature ? prior.attempt + 1 : 1;
+    const nextCheckAt = new Date(now + BOUNDARY_RECOVERY_BACKOFF_MS[attempt - 1]).toISOString();
+    claimed = true;
+    return {
+      status: BOUNDARY_RECOVERY_CLAIM_STATUS,
+      mergeDetails: {
+        ...current.mergeDetails,
+        mergeBoundaryRecovery: { signature, attempt, nextCheckAt }
+      }
+    };
+  }, deps.getRunContextFor(live.id));
+  if (deferred) {
+    await deps.store.logEntry(live.id, "Workflow merge evidence recovery is waiting for its bounded recheck window before retrying unchanged proof", void 0, deps.getRunContextFor(live.id));
+    return "deferred";
+  }
+  if (held) {
+    await deps.store.logEntry(live.id, "Workflow merge evidence recovery is held because the same proof gap exhausted its bounded retry budget", void 0, deps.getRunContextFor(live.id));
+    return "held";
+  }
+  if (!claimed) return "declined";
+  const claimedTask = typeof deps.store.getTask === "function" ? await deps.store.getTask(live.id) : live;
+  if (!claimedTask || claimedTask.column !== live.column || claimedTask !== live && claimedTask.status !== BOUNDARY_RECOVERY_CLAIM_STATUS || autoMergeSettings && !liveSharedBranchMember && (claimedTask.autoMerge === false || !allowsAutoMergeProcessing(claimedTask, autoMergeSettings))) {
+    await releaseBoundaryRecoveryClaim(deps.store, live, deps.getRunContextFor(live.id));
+    return "declined";
+  }
+  let owner;
+  try {
+    owner = await seedBoundaryRecoveryContinuation(deps.store, live, failedNode, evidence);
+  } catch (error2) {
+    await releaseBoundaryRecoveryClaim(deps.store, live, deps.getRunContextFor(live.id));
+    throw error2;
+  }
+  if (!owner) {
+    await releaseBoundaryRecoveryClaim(deps.store, live, deps.getRunContextFor(live.id));
+    return "declined";
+  }
+  if (owner === BOUNDARY_RECOVERY_CONCURRENT) {
+    await releaseBoundaryRecoveryClaim(deps.store, live, deps.getRunContextFor(live.id));
+    return "concurrent";
+  }
+  const remediation = `Workflow merge evidence recovery: '${owner}' is being resumed after missing proof at '${failedNode}'; returning to '${wipColumn}' before merge proof is rechecked`;
+  executorLog.warn(`${live.id}: ${remediation}`);
+  await deps.store.logEntry(live.id, remediation, void 0, deps.getRunContextFor(live.id));
+  const moveOptions = {
+    moveSource: "engine",
+    preserveProgress: true,
+    preserveWorktree: true,
+    workflowMoveSource: "workflow-graph",
+    workflowMoveMetadata: { reason: "merge-boundary-evidence-recovery", nodeId: failedNode }
+  };
+  const conditionalMoveStore = deps.store;
+  const moved = typeof conditionalMoveStore.moveTaskIf === "function" ? (await conditionalMoveStore.moveTaskIf(
+    live.id,
+    wipColumn,
+    (current) => !current.deletedAt && !current.paused && !current.userPaused && (!autoMergeSettings || liveSharedBranchMember || current.autoMerge !== false && allowsAutoMergeProcessing(current, autoMergeSettings)) && current.column === live.column && current.status === BOUNDARY_RECOVERY_CLAIM_STATUS,
+    moveOptions
+  )).moved : (await deps.store.moveTask(live.id, wipColumn, moveOptions), true);
+  if (!moved) {
+    await releaseBoundaryRecoveryClaim(deps.store, live, deps.getRunContextFor(live.id));
+    return "raced";
+  }
+  let completed = false;
+  await deps.store.updateTaskAtomic(live.id, (current) => {
+    if (!current || current.deletedAt || current.paused || current.userPaused || current.column !== wipColumn || current.status !== BOUNDARY_RECOVERY_CLAIM_STATUS) return null;
+    completed = true;
+    return { status: null, error: null };
+  }, deps.getRunContextFor(live.id));
+  return completed ? "recovered" : "declined";
+}
+async function releaseBoundaryRecoveryClaim(store, live, runContext) {
+  await store.updateTaskAtomic(live.id, (current) => {
+    if (!current || current.deletedAt || current.paused || current.userPaused || current.column !== live.column || current.status !== BOUNDARY_RECOVERY_CLAIM_STATUS) return null;
+    return { status: live.status };
+  }, runContext);
+}
+async function seedBoundaryRecoveryContinuation(store, task, failedNode, evidence) {
+  const ir2 = await resolveWorkflowIrForTask(store, task.id).catch(() => void 0);
+  const workItems = typeof store.listWorkflowWorkItemsForTask === "function" ? await store.listWorkflowWorkItemsForTask(task.id, { kinds: ["task"] }).catch(() => []) : [];
+  const owners2 = ir2 ? findBoundaryRecoveryOwners(task, ir2.nodes, evidence, workItems) : void 0;
+  const owner = owners2?.[0];
+  if (!owner || typeof store.replaceActiveTaskWorkflowContinuation !== "function") return void 0;
+  const seeded = await Promise.resolve(store.replaceActiveTaskWorkflowContinuation({
+    taskId: task.id,
+    runId: `${task.id}:merge-boundary-recovery:${owner}`,
+    nodeId: owner,
+    kind: "task",
+    state: "runnable",
+    blockedReason: `merge-boundary-evidence-recovery:${failedNode}`,
+    lastError: null,
+    leaseOwner: null,
+    leaseExpiresAt: null,
+    onlyIfNoActiveTaskContinuation: true
+  })).catch((error2) => {
+    if (error2 instanceof Error && error2.name === "ActiveTaskContinuationError") return null;
+    throw error2;
+  });
+  return seeded === null ? BOUNDARY_RECOVERY_CONCURRENT : owner;
+}
+async function routeGraphFailureToExecutionResume(deps, live, failedNode, failureValue, resumeLanesMemo, boundaryEvidence) {
+  if (live.deletedAt) return false;
+  if (isTaskExternallyBlocked(live)) {
+    executorLog.log(`${live.id}: graph failure resume skipped \u2014 external Blocked freeze honored`);
+    return false;
+  }
+  if (live.paused || live.userPaused === true) return false;
+  if ((await resolveTerminalColumnsFor(deps.store, live.id)).includes(live.column)) return false;
+  if (isDurableBlockedTask(live)) {
+    executorLog.log(
+      `${live.id}: graph failure resume skipped \u2014 durable BLOCKED park honored (task-dependency block)`
+    );
+    return false;
+  }
+  if (failedNode === COMPLETION_SUMMARY_NODE_ID) return false;
+  const incompleteSteps = hasNonTerminalWorkflowSteps(live);
+  if (!incompleteSteps && (failureValue === "remediation-not-scheduled" || failureValue === "missing-remediation-context") && await deps.isRemediationGraphNode(live.id, failedNode)) return false;
+  const implementationIncompleteMergeFailure = isMergeGraphFailure(failedNode) && failureValue === "implementation-incomplete";
+  const boundaryEvidenceRecovery = isMergeGraphFailure(failedNode) && failureValue === MERGE_BOUNDARY_RECOVERY_VALUE;
+  if (implementationIncompleteMergeFailure && !incompleteSteps) return false;
+  const resumeRouterLanes = await deps.resolveResumeLanes(live.id, resumeLanesMemo);
+  if (!resumeRouterLanes.wipDeclared) return false;
+  const mayResumeInPlace = live.column === resumeRouterLanes.wip && implementationIncompleteMergeFailure;
+  const mayRepairBoundary = boundaryEvidenceRecovery && live.column === resumeRouterLanes.review;
+  if (!mayResumeInPlace && !mayRepairBoundary) {
+    const message2 = `Workflow graph failed at node '${failedNode}'${failureValue ? ` (${failureValue})` : ""} \u2014 automatic recovery cannot move '${live.column}' backward; card remains in place`;
+    executorLog.warn(`${live.id}: ${message2}`);
+    await deps.store.logEntry(live.id, message2, void 0, deps.getRunContextFor(live.id));
+    return false;
+  }
+  if (mayRepairBoundary) {
+    const settings = await deps.store.getSettings?.().catch(() => void 0) ?? { autoMerge: true };
+    if (settings.globalPause === true || settings.enginePaused === true) return false;
+    const liveSharedBranchMember = await deps.isLiveSharedBranchGroupMember?.(live) ?? false;
+    if ((live.autoMerge === false || !allowsAutoMergeProcessing(live, settings)) && !liveSharedBranchMember) return false;
+    const outcome = await recoverMergeBoundaryEvidenceGap(
+      deps,
+      live,
+      failedNode,
+      boundaryEvidence,
+      resumeRouterLanes.wip,
+      settings,
+      liveSharedBranchMember
+    );
+    if (outcome === "declined") return false;
+    if (outcome === "concurrent" || outcome === "raced" || outcome === "deferred" || outcome === "held") return true;
+  }
+  const message = mayRepairBoundary ? `Workflow merge evidence recovery scheduled implementation resume in '${resumeRouterLanes.wip}'` : `Workflow graph failed at node '${failedNode}'${failureValue ? ` (${failureValue})` : ""} with incomplete work \u2014 resuming in place in '${live.column}'`;
+  executorLog.warn(`${live.id}: ${message}`);
+  await deps.store.logEntry(live.id, message, void 0, deps.getRunContextFor(live.id));
+  if (!mayRepairBoundary) {
+    await deps.store.updateTask(live.id, { status: null, error: null }, deps.getRunContextFor(live.id));
+  }
+  await deps.clearTerminalStepFailuresForRetry(live.id, "archive");
+  await deps.persistTokenUsage(live.id);
+  return true;
+}
+
 // ../engine/src/agent-browser-lifecycle.ts
 import { execFile as execFile19 } from "node:child_process";
 import { lstatSync as lstatSync3, mkdirSync as mkdirSync9, readdirSync as readdirSync10, readFileSync as readFileSync23, renameSync as renameSync4, rmSync as rmSync5, statSync as statSync13, writeFileSync as writeFileSync9 } from "node:fs";
@@ -224754,6 +225569,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       // stall-deadlock ride this sweep exists to prevent.
       { name: "reconcile-orphaned-pending-step-results", fn: () => this.reconcileOrphanedPendingStepResults().then(() => void 0) },
       { name: "reconcile-unproven-review-approvals", fn: () => this.reconcileUnprovenReviewApprovals().then(() => void 0) },
+      { name: "reconcile-merge-boundary-evidence-gaps", fn: () => this.reconcileMergeBoundaryEvidenceGaps().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
@@ -224776,6 +225592,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       { name: "completed-tasks", fn: () => this.recoverCompletedTasks().then(() => void 0) },
       { name: "recover-stranded-completed-todo", fn: () => this.recoverStrandedCompletedTodoTasks().then(() => void 0) },
       { name: "recover-advanced-triage", fn: () => this.recoverAdvancedTriageTasks().then(() => void 0) },
+      { name: "recover-mergeable-review", fn: () => this.recoverMergeableReviewTasks().then(() => void 0) },
       { name: "failed-pre-merge-steps", fn: () => this.recoverReviewTasksWithFailedPreMergeSteps().then(() => void 0) },
       { name: "missing-worktree-review-failures", fn: () => this.recoverMissingWorktreeReviewFailures().then(() => void 0) },
       /*
@@ -225649,6 +226466,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-merge-boundary-evidence-gaps", fn: () => this.reconcileMergeBoundaryEvidenceGaps() },
           { 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() },
@@ -230160,6 +230978,63 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
     would discard that valid result. Re-check lane, user pause, workspace ownership, and session liveness
     in the callback, then log and audit only a repair whose atomic mutation actually applied.
     */
+  /*
+  FNXC:WorkflowMergeRecovery 2026-09-20-19:38:
+  A historic merge-boundary-unproven park can outlive the executor process that
+  created it. Recover only durable failed evidence with unfinished checklist
+  work, then use the ordinary named merge-fix remediation transition; no sweep
+  may invent node proof, clear an external blocker, or disturb a live session.
+  */
+  async reconcileMergeBoundaryEvidenceGaps() {
+    const settings = await this.store.getSettings().catch(() => void 0);
+    if (!settings || settings.globalPause || settings.enginePaused) return 0;
+    const reviewColumns = await resolveProjectColumnsForRoles(this.store, REVIEW_ROLES);
+    const candidates = /* @__PURE__ */ new Map();
+    for (const column of reviewColumns) {
+      for (const task of await this.store.listTasks({ column, slim: true })) candidates.set(task.id, task);
+    }
+    const isSessionLive = (taskId) => activeSessionRegistry.pathsForTask(taskId).some((path6) => activeSessionRegistry.isPathActive(path6)) || executingTaskLock.has(taskId) || this.options.isTaskActive?.(taskId) === true;
+    let recovered = 0;
+    for (const candidate of candidates.values()) {
+      if (!candidate.error?.includes("merge-boundary-unproven")) continue;
+      const fresh = await this.store.getTask(candidate.id);
+      if (!fresh || fresh.deletedAt || fresh.userPaused || fresh.paused || fresh.workspaceWorktrees !== void 0 || isTaskExternallyBlocked(fresh) || isSessionLive(fresh.id) || !allowsAutoMergeProcessing(fresh, settings)) continue;
+      const ir2 = await resolveWorkflowIrForTask(this.store, fresh.id).catch(() => void 0);
+      const column = ir2?.columns.find((entry) => entry.id === fresh.column);
+      const wipColumn = ir2?.columns.find((entry) => resolveColumnFlags(entry).countsTowardWip === true)?.id;
+      if (!column || !wipColumn || !isReviewColumnRole(resolveColumnFlags(column), fresh.column)) continue;
+      const proof = await evaluateWorkflowMergeBoundary(
+        { store: this.store, loadMergeBoundaryInstances: (taskId, runId) => loadMergeBoundaryInstances({ store: this.store }, taskId, runId) },
+        fresh
+      ).catch(() => void 0);
+      if (!proof?.hasForeachStepExecute || proof.complete || fresh.noCommitsExpected === true && !hasNonTerminalSteps(fresh)) continue;
+      const evidence = !proof.hasRelevantNodeResult ? { code: "no-node-result", missingInstanceIds: [] } : !proof.allResultsTerminal ? { code: "non-terminal-node-result", nonTerminalNodeId: proof.nonTerminalResult?.workflowStepId, missingInstanceIds: [] } : { code: "missing-foreach-instances", missingInstanceIds: proof.missingInstanceIds };
+      const outcome = await recoverMergeBoundaryEvidenceGap(
+        { store: this.store, getRunContextFor: () => void 0 },
+        fresh,
+        "merge-boundary",
+        evidence,
+        wipColumn,
+        settings
+      );
+      if (outcome !== "recovered") continue;
+      recovered += 1;
+      await this.store.logEntry(
+        fresh.id,
+        "Workflow merge evidence recovery resumed the proven implementation owner; merge proof will be checked after durable progress"
+      ).catch(() => void 0);
+      await emitBoundedRunAudit2(this.store, {
+        taskId: fresh.id,
+        agentId: "self-healing",
+        runId: generateSyntheticRunId("reconcile-merge-boundary-evidence-gap", fresh.id),
+        domain: "database",
+        mutationType: "task:merge-boundary-evidence-recovered",
+        target: fresh.id,
+        metadata: { taskId: fresh.id, outcome: "resumed" }
+      }, { log: log34 });
+    }
+    return recovered;
+  }
   async reconcileUnprovenReviewApprovals() {
     try {
       const reviewColumns = await resolveProjectColumnsForRoles(this.store, REVIEW_ROLES);
@@ -230662,9 +231537,25 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       mergeRetriesReset
     };
   }
-  async routeUnrunPreMergeGateBackToReview(task, reviewColumns, mergeGate, mergeContent) {
+  async routeUnrunPreMergeGateBackToReview(task, reviewColumns, mergeGate, mergeContent, expectedWorkflowSelection, failedPark) {
     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 }));
+    const reroute = await rerouteUnrunPreMergeGateToReview(this.store, task, {
+      requiredPreMergeStepIds: mergeGate.requiredPreMergeStepIds,
+      mergeContent,
+      expectedWorkflowSelection
+    }).catch(() => ({ rerouted: false, reason: "no-unrun-gate", nodeId: void 0, workflowStepId: void 0 }));
+    if (reroute.reason === "workflow-selection-changed" && failedPark) {
+      await this.store.updateTaskAtomic(task.id, (live) => live.status === null && live.error === null ? {
+        status: failedPark.status,
+        error: failedPark.error,
+        paused: failedPark.paused,
+        pausedReason: failedPark.pausedReason,
+        mergeRetries: failedPark.mergeRetries,
+        workflowIrPin: failedPark.workflowIrPin,
+        workflowIrPinNodeId: failedPark.workflowIrPinNodeId,
+        workflowIrPinColumnId: failedPark.workflowIrPinColumnId
+      } : null);
+    }
     if (reroute.rerouted) {
       await this.store.logEntry(task.id, "[pre-merge] Self-healing re-seeded the workflow graph at an enabled pre-merge gate that never ran.");
       log34.warn(`Unrun pre-merge gate for ${task.id} re-seeded at ${reroute.nodeId ?? "unknown"}`);
@@ -230718,8 +231609,68 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
         await this.canRecoverMergeRequest(task, settings)
       ]));
       const mergeAdmissionByTaskId = new Map(mergeAdmission);
+      const recoveredUnrunGateIds = /* @__PURE__ */ new Set();
+      for (const task of tasks2) {
+        if (!isRecoverableUnrunGatePark(task) || !mergeAdmissionByTaskId.get(task.id) || executingIds.has(task.id)) continue;
+        try {
+          const reviewColumns = await ownReviewLanesFor(task);
+          if (!reviewColumns.has(task.column)) continue;
+          const gate = await resolvePreMergeGateForTask(this.store, task.id, task.enabledWorkflowSteps, task);
+          if (gate.provenance === "default" && !gate.selectionAbsent) continue;
+          const content = await captureMergeContentDescriptor(task, { workspaceRootDir: this.options.rootDir, settings });
+          if (content.kind !== "singular" || task.workspaceWorktrees !== void 0) continue;
+          const recoverable = { ...task, status: void 0, paused: false };
+          if (getTaskMergeBlocker(recoverable, { reviewColumns, requiredPreMergeStepIds: gate.requiredPreMergeStepIds, mergeContent: content }) !== PRE_MERGE_STEPS_NOT_RUN_BLOCKER) continue;
+          const items = await this.store.listWorkflowWorkItemsForTask(task.id);
+          if (items.some((item) => ACTIVE_WORKFLOW_WORK_ITEM_STATES.includes(item.state))) continue;
+          const snapshot = { updatedAt: task.updatedAt, error: task.error, column: task.column };
+          const failedPark = { ...task };
+          let released = false;
+          await this.store.updateTaskAtomic(task.id, (live2) => {
+            if (!isRecoverableUnrunGatePark(live2) || live2.updatedAt !== snapshot.updatedAt || live2.error !== snapshot.error || live2.column !== snapshot.column || !allowsAutoMergeProcessing(live2, settings)) return null;
+            released = true;
+            return {
+              status: null,
+              error: null,
+              paused: false,
+              pausedReason: null,
+              mergeRetries: 0,
+              workflowIrPin: null,
+              workflowIrPinNodeId: null,
+              workflowIrPinColumnId: null
+            };
+          });
+          if (!released) continue;
+          const live = await this.store.getTask(task.id);
+          if (!live) continue;
+          const selection = this.store.getTaskWorkflowSelectionAsync ? await this.store.getTaskWorkflowSelectionAsync(live.id) : this.store.getTaskWorkflowSelection(live.id);
+          const expectedWorkflowSelection = selection ? { workflowId: selection.workflowId, stepIds: [...selection.stepIds] } : null;
+          const currentGate = await resolvePreMergeGateForTask(this.store, live.id, live.enabledWorkflowSteps, live);
+          if (currentGate.provenance === "default" && !currentGate.selectionAbsent) continue;
+          const currentContent = await captureMergeContentDescriptor(live, { workspaceRootDir: this.options.rootDir, settings });
+          if (currentContent.kind !== "singular" || live.workspaceWorktrees !== void 0) continue;
+          const currentRecoverable = { ...live, status: void 0, paused: false };
+          if (getTaskMergeBlocker(currentRecoverable, {
+            reviewColumns: currentGate.reviewColumns,
+            requiredPreMergeStepIds: currentGate.requiredPreMergeStepIds,
+            mergeContent: currentContent
+          }) !== PRE_MERGE_STEPS_NOT_RUN_BLOCKER) continue;
+          if (await this.routeUnrunPreMergeGateBackToReview(
+            live,
+            currentGate.reviewColumns,
+            currentGate,
+            currentContent,
+            expectedWorkflowSelection,
+            failedPark
+          )) {
+            recoveredUnrunGateIds.add(task.id);
+          }
+        } catch (error2) {
+          log34.warn(`Unrun pre-merge gate recovery deferred for ${task.id}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        }
+      }
       const mergeable = tasks2.filter(
-        (t) => mergeAdmissionByTaskId.get(t.id) === true && !t.paused && !executingIds.has(t.id) && t.status !== "failed" && // Exclude transient merge statuses. Active merges should be left alone;
+        (t) => !recoveredUnrunGateIds.has(t.id) && mergeAdmissionByTaskId.get(t.id) === true && !t.paused && !executingIds.has(t.id) && t.status !== "failed" && // Exclude transient merge statuses. Active merges should be left alone;
         // stale ones are handled by recoverStaleMergingStatus().
         t.status !== "merging" && t.status !== "merging-pr" && // FNXC:Workspace 2026-06-22-09:30 (Phase D U1, KTD1 — admit workspace tasks):
         // A workspace task has task.worktree===null (its worktrees live per-repo in
@@ -236596,49 +237547,6 @@ function isGenericAbortProvenance(provenance) {
   return provenance === "hard-cancel" || provenance === "engine-abort";
 }
 
-// ../engine/src/executor/workflow-step-satisfaction.ts
-function hasNonTerminalWorkflowSteps(task) {
-  return task.steps.length > 0 && task.steps.some((step) => step.status !== "done" && step.status !== "skipped");
-}
-function workflowStepResultPassed(task, workflowStepId) {
-  const results = task?.workflowStepResults ?? [];
-  return results.some(
-    (result) => result.workflowStepId === workflowStepId && result.phase === "pre-merge" && result.status === "passed"
-  );
-}
-function areEnabledPreMergeWorkflowStepsSatisfied(task) {
-  const preMergeGateIds = /* @__PURE__ */ new Set(["plan-review", "browser-verification", "code-review"]);
-  const enabled = task?.enabledWorkflowSteps;
-  const enabledPreMerge = Array.isArray(enabled) && enabled.length > 0 ? enabled.filter((id) => preMergeGateIds.has(id)) : ["plan-review", "code-review"];
-  if (enabledPreMerge.length === 0) return false;
-  if (Array.isArray(enabled) && enabledPreMerge.length !== enabled.length) return false;
-  return enabledPreMerge.every((id) => workflowStepResultPassed(task, id));
-}
-function preservePreExecutionWorkflowStepResults(task) {
-  const preserved = (task.workflowStepResults ?? []).filter((result) => result.workflowStepId === "plan-review");
-  if (preserved.length > 0) return preserved;
-  let latest;
-  for (const entry of task.log ?? []) {
-    if (entry.action === "[pre-merge] Workflow step completed: Plan Review") {
-      latest = { timestamp: entry.timestamp, outcome: entry.outcome, status: "passed" };
-    } else if (entry.action === "[pre-merge] Workflow step failed: Plan Review") {
-      latest = { timestamp: entry.timestamp, outcome: entry.outcome, status: "failed" };
-    }
-  }
-  if (latest?.status !== "passed") return [];
-  return [
-    {
-      workflowStepId: "plan-review",
-      workflowStepName: "Plan Review",
-      phase: "pre-merge",
-      status: "passed",
-      verdict: "APPROVE",
-      ...latest.outcome ? { output: latest.outcome, notes: latest.outcome } : {},
-      ...latest.timestamp ? { startedAt: latest.timestamp, completedAt: latest.timestamp } : {}
-    }
-  ];
-}
-
 // ../engine/src/executor/graph-resume-predicates.ts
 function isTransientResumeAfterRestartGraphFailure(live, result) {
   if ((result.reason ?? "").trim().length > 0) return false;
@@ -238742,6 +239650,8 @@ init_session_skill_context();
 
 // ../engine/src/environment/environment-capabilities.ts
 import { exec as exec39 } from "node:child_process";
+import { readFile as readFile47 } from "node:fs/promises";
+import { join as join86 } from "node:path";
 import { promisify as promisify57 } from "node:util";
 var execAsync36 = promisify57(exec39);
 var BASELINE_ENVIRONMENT_CAPABILITY_COMMANDS = Object.freeze([
@@ -238764,17 +239674,23 @@ var BASELINE_ENVIRONMENT_CAPABILITY_COMMANDS = Object.freeze([
   "dotnet",
   "make",
   "docker",
-  "git"
+  "git",
+  "nix",
+  "direnv",
+  "devbox",
+  "nvm",
+  "fnm",
+  "asdf",
+  "mise"
 ]);
 var DEFAULT_PROBE_TIMEOUT_MS = 5e3;
+var PROBE_CACHE_TTL_MS = 6e4;
 var PROBE_MAX_BUFFER_BYTES = 64 * 1024;
 var SAFE_COMMAND_NAME = /^[A-Za-z0-9._+/-]+$/;
 var ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
 var probeCache = /* @__PURE__ */ new Map();
 function unquoteToken(token) {
-  if (token.length >= 2 && (token.startsWith('"') && token.endsWith('"') || token.startsWith("'") && token.endsWith("'"))) {
-    return token.slice(1, -1);
-  }
+  if (token.length >= 2 && (token.startsWith('"') && token.endsWith('"') || token.startsWith("'") && token.endsWith("'"))) return token.slice(1, -1);
   return token;
 }
 function extractCommandBinaries(command) {
@@ -238790,70 +239706,126 @@ function extractCommandBinaries(command) {
   }
   return [...new Set(binaries)];
 }
-function collectCandidates(extraCommands) {
+function commandTokens(command) {
+  if (/[;&|`$<>()[\]{}\\]/.test(command)) return null;
+  const tokens2 = command.trim().split(/\s+/).map(unquoteToken).filter(Boolean);
+  let index2 = tokens2[0] === "env" ? 1 : 0;
+  while (index2 < tokens2.length && ENV_ASSIGNMENT.test(tokens2[index2])) index2 += 1;
+  const result = tokens2.slice(index2);
+  return result.length > 0 && result.every((token) => SAFE_COMMAND_NAME.test(token)) ? result : null;
+}
+function parseRecognizedWrapper(command) {
+  if (!command) return null;
+  const tokens2 = commandTokens(command);
+  if (!tokens2) return null;
+  const wrapper = tokens2[0];
+  let prefix = null;
+  let inner;
+  if (wrapper === "nix" && tokens2[1] === "develop" && tokens2[2] === "--command") {
+    prefix = ["nix", "develop", "--command"];
+    inner = tokens2[3];
+  } else if (wrapper === "devbox" && tokens2[1] === "run") {
+    prefix = ["devbox", "run"];
+    inner = tokens2[2];
+  } else if ((wrapper === "nvm" || wrapper === "fnm") && tokens2[1] === "exec") {
+    prefix = tokens2.slice(0, 3);
+    inner = tokens2[3];
+  } else if ((wrapper === "asdf" || wrapper === "mise") && tokens2[1] === "exec") {
+    prefix = tokens2.slice(0, 2);
+    inner = tokens2[2];
+  } else if (wrapper === "direnv" && tokens2[1] === "exec" && tokens2[2]) {
+    prefix = tokens2.slice(0, 3);
+    inner = tokens2[3];
+  }
+  if (!prefix || !inner || !SAFE_COMMAND_NAME.test(inner)) return null;
+  return { prefix, display: prefix.join(" "), innerCandidates: [inner] };
+}
+function collectCandidates(extraCommands, wrappers) {
   return [.../* @__PURE__ */ new Set([
     ...BASELINE_ENVIRONMENT_CAPABILITY_COMMANDS,
-    ...extraCommands.map((name2) => name2.trim()).filter((name2) => SAFE_COMMAND_NAME.test(name2))
+    ...extraCommands.map((name2) => name2.trim()).filter((name2) => SAFE_COMMAND_NAME.test(name2)),
+    ...wrappers.flatMap((wrapper) => wrapper.innerCandidates)
   ])].sort((a, b3) => a.localeCompare(b3));
 }
 function quoteShellToken(token) {
   return `'${token.replaceAll("'", "'\\''")}'`;
 }
 function buildProbeCommand(candidates) {
-  const args = candidates.map(quoteShellToken).join(" ");
-  return `for name in ${args}; do if command -v "$name" >/dev/null 2>&1; then printf '%s=1\\n' "$name"; else printf '%s=0\\n' "$name"; fi; done`;
+  return `for name in ${candidates.map(quoteShellToken).join(" ")}; do if command -v "$name" >/dev/null 2>&1; then printf '%s=1\\n' "$name"; else printf '%s=0\\n' "$name"; fi; done`;
+}
+function buildWrapperProbeCommand(wrapper, candidates) {
+  return [...wrapper.prefix.map(quoteShellToken), quoteShellToken("/bin/bash"), quoteShellToken("-c"), quoteShellToken(buildProbeCommand(candidates))].join(" ");
 }
 function parseProbeOutput(stdout, candidates) {
   const parsed = /* @__PURE__ */ new Map();
   for (const line2 of stdout.split("\n").map((value) => value.trim()).filter(Boolean)) {
     const match = /^(.+)=(0|1)$/.exec(line2);
-    if (!match || !candidates.includes(match[1]) || parsed.has(match[1])) {
-      return { capabilities: [], degraded: true };
-    }
+    if (!match || !candidates.includes(match[1]) || parsed.has(match[1])) return { capabilities: [], degraded: true };
     parsed.set(match[1], match[2] === "1");
   }
   if (parsed.size !== candidates.length) return { capabilities: [], degraded: true };
-  return {
-    capabilities: candidates.map((name2) => ({ name: name2, available: parsed.get(name2) })),
-    degraded: false
-  };
+  return { capabilities: candidates.map((name2) => ({ name: name2, available: parsed.get(name2) })), degraded: false };
 }
-async function probeUncached(candidates, timeoutMs) {
+async function runProbe2(command, candidates, timeoutMs) {
   try {
-    const { stdout } = await execAsync36(buildProbeCommand(candidates), {
-      timeout: timeoutMs,
-      maxBuffer: PROBE_MAX_BUFFER_BYTES,
-      encoding: "utf-8",
-      shell: "/bin/bash"
-    });
+    const { stdout } = await execAsync36(command, { timeout: timeoutMs, maxBuffer: PROBE_MAX_BUFFER_BYTES, encoding: "utf-8", shell: "/bin/bash" });
     return parseProbeOutput(stdout ?? "", candidates);
   } catch {
     return { capabilities: [], degraded: true };
   }
 }
-function probeEnvironmentCapabilities(options = {}) {
-  const candidates = collectCandidates(options.extraCommands ?? []);
-  const cacheKey = candidates.join("\0");
-  let promise = probeCache.get(cacheKey);
-  if (!promise) {
-    promise = probeUncached(candidates, options.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS);
-    probeCache.set(cacheKey, promise);
-  }
+async function rootNixWrapper(rootDir) {
+  if (!rootDir) return { wrapper: null, fingerprint: "no-root" };
+  try {
+    const content = await readFile47(join86(rootDir, "flake.nix"), "utf8");
+    return { wrapper: { prefix: ["nix", "develop", "--command"], display: "nix develop --command", innerCandidates: [] }, fingerprint: `flake:${content.length}:${content.slice(0, 256)}` };
+  } catch {
+    return { wrapper: null, fingerprint: "no-flake" };
+  }
+}
+async function probeUncached(candidates, wrappers, timeoutMs) {
+  const host = await runProbe2(buildProbeCommand(candidates), candidates, timeoutMs);
+  if (host.degraded) return host;
+  const merged = new Map(host.capabilities.map((capability) => [capability.name, capability]));
+  for (const wrapper of wrappers) {
+    if (!merged.get(wrapper.prefix[0])?.available) continue;
+    const wrapped = await runProbe2(buildWrapperProbeCommand(wrapper, candidates), candidates, timeoutMs);
+    if (wrapped.degraded) continue;
+    for (const capability of wrapped.capabilities) {
+      if (capability.available && !merged.get(capability.name)?.available) merged.set(capability.name, { ...capability, via: wrapper.display });
+    }
+  }
+  return { capabilities: candidates.map((candidate) => merged.get(candidate)), degraded: false };
+}
+async function probeEnvironmentCapabilities(options = {}) {
+  const marker = await rootNixWrapper(options.rootDir);
+  const configured = [parseRecognizedWrapper(options.testCommand), parseRecognizedWrapper(options.buildCommand)].filter((value) => value !== null);
+  const wrappers = [...new Map([...configured, ...marker.wrapper ? [marker.wrapper] : []].map((wrapper) => [wrapper.display, wrapper])).values()];
+  const candidates = collectCandidates(options.extraCommands ?? [], wrappers);
+  const normalizedCommands = [options.testCommand?.trim() ?? "", options.buildCommand?.trim() ?? ""].join("\0");
+  const cacheKey = [options.projectId ?? options.rootDir ?? "host", normalizedCommands, marker.fingerprint, candidates.join("\0")].join("
");
+  const now = options.now?.() ?? Date.now();
+  const cached2 = probeCache.get(cacheKey);
+  if (cached2 && now - cached2.createdAt < PROBE_CACHE_TTL_MS) return cached2.promise;
+  const promise = probeUncached(candidates, wrappers, options.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS);
+  probeCache.set(cacheKey, { createdAt: now, promise });
   return promise;
 }
 function formatEnvironmentCapabilitiesSection(probe) {
   if (probe.degraded || probe.capabilities.length === 0) return "";
-  const available2 = probe.capabilities.filter((capability) => capability.available).map(({ name: name2 }) => name2);
+  const available2 = probe.capabilities.filter((capability) => capability.available && !capability.via).map(({ name: name2 }) => name2);
+  const wrapperAvailable = probe.capabilities.filter((capability) => capability.available && capability.via).map(({ name: name2, via }) => `${name2} via ${via}`);
   const unavailable2 = probe.capabilities.filter((capability) => !capability.available).map(({ name: name2 }) => name2);
   return [
     "## Environment Capabilities",
     "",
-    `Available commands: ${available2.length > 0 ? available2.join(", ") : "none"}`,
-    `Unavailable commands: ${unavailable2.length > 0 ? unavailable2.join(", ") : "none"}`,
+    `Host-available commands: ${available2.length > 0 ? available2.join(", ") : "none"}`,
+    `Available via confirmed project wrapper: ${wrapperAvailable.length > 0 ? wrapperAvailable.join(", ") : "none"}`,
+    `Confirmed-unavailable commands: ${unavailable2.length > 0 ? unavailable2.join(", ") : "none"}`,
     "",
-    "- Do not make an acceptance criterion or required verification depend on an unavailable runtime.",
-    "- When the ideal check needs an absent runtime, keep the objective, specify a runnable substitute, and record the ideal check under an `## Environment Constraints` section of PROMPT.md as explicitly non-blocking.",
-    "- This inventory describes the execution host; a repository script whose interpreter is unavailable cannot run here."
+    "- Only the commands listed here were probed. Any unlisted command is UNKNOWN, not absent.",
+    "- A documented or configured command using a confirmed wrapper remains runnable and binding even if its inner executable is absent from the host PATH.",
+    "- Only a confirmed-unavailable runtime without an applicable confirmed wrapper needs a runnable substitute; record an ideal impossible check under `## Environment Constraints` as explicitly non-blocking."
   ].join("\n");
 }
 
@@ -240454,16 +241426,16 @@ init_effective_settings();
 // ../engine/src/executor/workflow-step-failure-injection.ts
 init_src2();
 init_logger();
-import { join as join86 } from "node:path";
-import { readFile as readFile47, writeFile as writeFile27 } from "node:fs/promises";
+import { join as join87 } from "node:path";
+import { readFile as readFile48, writeFile as writeFile27 } from "node:fs/promises";
 var ADVISORY_SECTION_HEADER = "## Review Advisory Notes";
 async function injectReviewAdvisoryNotes(store, task, stepName, findings) {
   findings = findings.filter(isOpenWorkflowReviewFinding);
   if (findings.length === 0) return;
-  const promptPath = join86(store.getFusionDir(), "tasks", task.id, "PROMPT.md");
+  const promptPath = join87(store.getFusionDir(), "tasks", task.id, "PROMPT.md");
   let content;
   try {
-    content = await readFile47(promptPath, "utf-8");
+    content = await readFile48(promptPath, "utf-8");
   } catch {
     executorLog.warn(`${task.id}: PROMPT.md not found at ${promptPath}, skipping review advisory injection`);
     return;
@@ -240487,10 +241459,10 @@ ${section}`;
   }
 }
 async function injectWorkflowStepFailureInstructions(store, task, failureFeedback, stepName, retry, findings) {
-  const promptPath = join86(store.getFusionDir(), "tasks", task.id, "PROMPT.md");
+  const promptPath = join87(store.getFusionDir(), "tasks", task.id, "PROMPT.md");
   let content;
   try {
-    content = await readFile47(promptPath, "utf-8");
+    content = await readFile48(promptPath, "utf-8");
   } catch {
     executorLog.warn(`${task.id}: PROMPT.md not found at ${promptPath}, skipping workflow failure injection`);
     return;
@@ -240568,7 +241540,7 @@ ${scopeGuard}
 }
 
 // ../engine/src/executor/skill-path-helpers.ts
-import { basename as basename23, join as join87 } from "node:path";
+import { basename as basename23, join as join88 } from "node:path";
 import { existsSync as existsSync68 } from "node:fs";
 function mergeAdditionalSkillPaths2(...pathGroups) {
   const merged = Array.from(new Set(pathGroups.flatMap((paths2) => paths2 ?? [])));
@@ -240581,7 +241553,7 @@ function isWorkflowStepSkillDiscoverable(skillName, additionalSkillPaths, ceSkil
     return false;
   }
   return (additionalSkillPaths ?? []).some(
-    (skillPath) => basename23(skillPath) === bareSkillName && existsSync68(join87(skillPath, "SKILL.md")) || existsSync68(join87(skillPath, bareSkillName, "SKILL.md"))
+    (skillPath) => basename23(skillPath) === bareSkillName && existsSync68(join88(skillPath, "SKILL.md")) || existsSync68(join88(skillPath, bareSkillName, "SKILL.md"))
   );
 }
 
@@ -240860,7 +241832,11 @@ async function executeWorkflowStep(deps, task, workflowStep, worktreePath, setti
     extraCommands: [
       ...extractCommandBinaries(settings.testCommand),
       ...extractCommandBinaries(settings.buildCommand)
-    ]
+    ],
+    testCommand: settings.testCommand,
+    buildCommand: settings.buildCommand,
+    rootDir: deps.rootDir,
+    projectId: deps.store.getProjectId?.() ?? deps.rootDir
   }).catch(() => ({ capabilities: [], degraded: true })) : void 0;
   const planReviewEnvironmentCapabilitiesBlock = planReviewEnvironmentCapabilities ? formatEnvironmentCapabilitiesSection(planReviewEnvironmentCapabilities) : "";
   if (isReviewTypeWorkflowStep && !workflowReviewSpecText.trim()) {
@@ -241717,7 +242693,7 @@ If you have just finished a step's work, immediately call \`fn_task_update\` to
 
 The user is not watching this conversation in real-time. They will read the final result. Asking permission wastes a full retry cycle and may orphan committed work.
 
-**Cannot proceed \u2014 the honest blocked exit.** If the work genuinely cannot be finished because of a host-resource, network, model-provider, or credential failure, or because a prerequisite Fusion task is incomplete, call \`fn_task_done(outcome="blocked", reason="<concrete blocker + what would unblock it>", blockedBy=["FN-XXXX"])\`. Missing tooling, optional services, and unrunnable commands are not blocked exits: resolve them, substitute a runnable check, or complete achievable work and record the deferred verification. A classified external block freezes in place; task dependencies park durable failed WITHOUT auto-replan and requeue when those tasks complete. Blockers must be Fusion board tasks \u2014 do NOT treat open GitHub PRs touching the same files as blockers; other PRs are not claims on your file scope. Do NOT skip remaining steps to fake completion.
+**Cannot proceed \u2014 the honest blocked exit.** If the work genuinely cannot be finished because of a host-resource, network, model-provider, or credential failure, or because a prerequisite Fusion task is incomplete, call \`fn_task_done(outcome="blocked", reason="<concrete blocker + what would unblock it>", blockedBy=["FN-XXXX"])\`. Missing tooling, optional services, and unrunnable commands are not blocked exits: resolve them, substitute a runnable check, or complete achievable work and record the deferred verification. A classified external block freezes in place; task dependencies park durable failed WITHOUT auto-replan and requeue when those tasks complete. For an accepted external block, include \`blockedReport\` with concise verified condition, stop reason, unimplemented work, and precise unblock condition; never include prompts, tool logs, stack traces, or credentials. Blockers must be Fusion board tasks \u2014 do NOT treat open GitHub PRs touching the same files as blockers; other PRs are not claims on your file scope. Do NOT skip remaining steps to fake completion.
 This is THE correct action when you are stuck \u2014 do NOT instead mark the remaining steps \`skipped\` and call \`fn_task_done\` to make the task look finished. Skipping steps to escape a blocker launders a failure into \`done\` and is never the right move. (\`skipped\` remains valid only for the stale-premise path below, when the requested work is already present on HEAD.) Never write the blocker as plain prose.
 
 ## How to work
@@ -242147,7 +243123,7 @@ Use \`fn_task_create\` for truly separate follow-up work, including unrelated/pr
 Commit at step boundaries: \`git commit -m "feat(${task.id}): complete Step N \u2014 <short summary>"${sourceIssueRef ? ` -m "Ref: ${sourceIssueRef}"` : ""}${authorArg}\`
 The \`<short summary>\` is required \u2014 replace it with a concrete 5\u201310 word description of what the step changed.
 When all steps are complete: call \`fn_task_done()\`
-For \`fn_task_done(outcome="blocked")\`, reserve \`obstacle:"outside-worktree"\` for host-resource, network, model-provider, and credential failures. An unavailable command, interpreter, optional service, or unrunnable test is never a blocked exit: resolve it with project tooling or an available equivalent, substitute a runnable automated check, or\u2014when it does not prevent the task objective\u2014complete the achievable work and record the deferred verification. If PROMPT.md has an \`## Environment Constraints\` section, its substitute is the sanctioned verification path and must not be re-litigated as a blocker. Set \`obstacle:"inside-worktree"\` for code, tests, lint, types, plan, merge, or review failures so AI self-repair remains active.
+For \`fn_task_done(outcome="blocked")\`, reserve \`obstacle:"outside-worktree"\` for host-resource, network, model-provider, and credential failures. An unavailable command, interpreter, optional service, or unrunnable test is never a blocked exit: resolve it with project tooling or an available equivalent, substitute a runnable automated check, or\u2014when it does not prevent the task objective\u2014complete the achievable work and record the deferred verification. Treat an \`## Environment Constraints\` substitute as sanctioned only when the accompanying capability block confirms its absence premise. Re-evaluate a stale host-only downgrade when the documented command uses a detected or configured confirmed wrapper; that wrapper command remains binding. Set \`obstacle:"inside-worktree"\` for code, tests, lint, types, plan, merge, or review failures so AI self-repair remains active.
 
 If a build command is configured, run that exact command in this worktree before calling \`fn_task_done()\`.
 Treat a non-zero exit code as a blocking failure. Do not claim success without a real passing run.
@@ -243112,7 +244088,7 @@ import { existsSync as existsSync74 } from "node:fs";
 
 // ../engine/src/executor/session-worktree-paths.ts
 init_worktree_paths();
-import { readFile as readFile48 } from "node:fs/promises";
+import { readFile as readFile49 } from "node:fs/promises";
 import { realpathSync as realpathSync12 } from "node:fs";
 import { resolve as resolvePath6 } from "node:path";
 function canonicalizePath2(path6) {
@@ -243137,7 +244113,7 @@ function normalizeWorktreePath(pathValue) {
 }
 async function extractPersistedSessionWorktreePath(sessionFile, rootDir, settings) {
   try {
-    const content = await readFile48(sessionFile, "utf-8");
+    const content = await readFile49(sessionFile, "utf-8");
     const matches = content.match(buildSessionWorktreePathRegex(rootDir, settings)) ?? [];
     if (matches.length === 0) return null;
     const normalizedCounts = /* @__PURE__ */ new Map();
@@ -244644,9 +245620,6 @@ async function handleImplicitTaskDoneRefusal(deps, task, refusal) {
       ...taintUpdate,
       paused: false,
       pausedByAgentId: null,
-      worktree: null,
-      branch: null,
-      branchWriteOrigin: "engine",
       sessionFile: null
     });
     await deps.store.logEntry(
@@ -244664,9 +245637,6 @@ async function handleImplicitTaskDoneRefusal(deps, task, refusal) {
       ...taintUpdate,
       paused: false,
       pausedByAgentId: null,
-      worktree: null,
-      branch: null,
-      branchWriteOrigin: "engine",
       sessionFile: null
     });
     await deps.store.logEntry(task.id, `${refusal.message} \u2014 execution failed because implicit fn_task_done was refused`, void 0, deps.getRunContextFor(task.id));
@@ -245622,7 +246592,15 @@ async function ensureWorkflowMergeBoundaryTask(deps, task, metadata) {
     await deps.store.logEntry(live.id, `Workflow merge boundary blocked: ${blocked.reason}`, void 0, deps.getRunContextFor(live.id));
     return {
       task: live,
-      blocked: { ...blocked, missingInstanceCount: mergeProof.missingInstanceIds.length }
+      blocked: {
+        ...blocked,
+        missingInstanceCount: mergeProof.missingInstanceIds.length,
+        evidence: {
+          code: blocked.code,
+          nonTerminalNodeId: mergeProof.nonTerminalResult?.workflowStepId,
+          missingInstanceIds: mergeProof.missingInstanceIds
+        }
+      }
     };
   }
   if (deps.shouldCompleteChecklistAtWorkflowMerge(live, mergeProof)) {
@@ -245944,6 +246922,7 @@ async function performWorkflowRerunBounce(deps, taskId, worktreePath, preserveRe
 
 // ../engine/src/executor/unpause-resume.ts
 init_logger();
+init_scheduler();
 async function dispatchUnpauseResume(deps, task) {
   if (task.status === "failed") {
     return false;
@@ -245959,6 +246938,13 @@ async function dispatchUnpauseResume(deps, task) {
       executorLog.debug(`Skipping unpause resume for ${task.id} \u2014 ${pauseLabel} active`);
       return false;
     }
+    if (task.dependencies?.length) {
+      const tasks2 = await deps.store.listTasks({ includeArchived: false, slim: true });
+      const liveTask = tasks2.find((candidate) => candidate.id === task.id) ?? task;
+      if (getUnmetSchedulingDependencies(liveTask, tasks2).length > 0) {
+        return false;
+      }
+    }
     if (deps.executing.has(task.id) || deps.recoveringCompleted.has(task.id) || deps.activeSessions.has(task.id) || deps.activeStepExecutors.has(task.id) || deps.activeWorkflowStepSessions.has(task.id) || deps.graphRouting.has(task.id)) {
       return false;
     }
@@ -248338,8 +249324,8 @@ async function resolveSeamColumnAgent(deps, task, detail) {
 init_src2();
 init_logger();
 import { setImmediate as setImmediateCb3 } from "node:timers";
-import { readFile as readFile49, rm as rm13 } from "node:fs/promises";
-import { join as join88 } from "node:path";
+import { readFile as readFile50, rm as rm13 } from "node:fs/promises";
+import { join as join89 } from "node:path";
 
 // ../engine/src/executor/resume-orphan-delay.ts
 function getResumeOrphanDelayMs() {
@@ -248385,12 +249371,12 @@ async function resumeOrphaned(deps) {
   for (const task of inProgress) {
     if (yieldNext) await yieldEventLoop3();
     yieldNext = true;
-    const tasksDir = typeof deps.store.getTasksDir === "function" ? deps.store.getTasksDir() : deps.rootDir ? join88(deps.rootDir, ".fusion", "tasks") : void 0;
-    const intentPath = tasksDir ? join88(tasksDir, task.id, "deferred-terminal-park.json") : void 0;
+    const tasksDir = typeof deps.store.getTasksDir === "function" ? deps.store.getTasksDir() : deps.rootDir ? join89(deps.rootDir, ".fusion", "tasks") : void 0;
+    const intentPath = tasksDir ? join89(tasksDir, task.id, "deferred-terminal-park.json") : void 0;
     if (intentPath) {
       let raw;
       try {
-        raw = await readFile49(intentPath, "utf-8");
+        raw = await readFile50(intentPath, "utf-8");
       } catch (error2) {
         if (error2?.code !== "ENOENT") {
           executorLog.warn(`${task.id}: deferred terminal-park intent could not be read (${error2 instanceof Error ? error2.message : String(error2)}) \u2014 retaining intent and skipping orphan recovery`);
@@ -250398,11 +251384,11 @@ init_logger();
 // ../engine/src/cli-agent/task-session.ts
 import { mkdtemp as mkdtemp3, rm as rm15 } from "node:fs/promises";
 import { tmpdir as tmpdir10 } from "node:os";
-import { join as join90 } from "node:path";
+import { join as join91 } from "node:path";
 
 // ../engine/src/cli-agent/hook-scripts.ts
 import { mkdir as mkdir31, rm as rm14, writeFile as writeFile28 } from "node:fs/promises";
-import { join as join89 } from "node:path";
+import { join as join90 } from "node:path";
 var HOOK_SCRIPT_NAMES = {
   /** Main hook script: POSTs stdin payload (with the hook event name) to the route. */
   hook: "fusion-hook.sh",
@@ -250484,8 +251470,8 @@ exit 0
 async function writeSessionHookScripts(opts) {
   const { sessionId, token, endpointUrl, dir } = opts;
   await mkdir31(dir, { recursive: true, mode: 448 });
-  const hookScriptPath = join89(dir, HOOK_SCRIPT_NAMES.hook);
-  const notifyScriptPath = join89(dir, HOOK_SCRIPT_NAMES.notify);
+  const hookScriptPath = join90(dir, HOOK_SCRIPT_NAMES.hook);
+  const notifyScriptPath = join90(dir, HOOK_SCRIPT_NAMES.notify);
   await writeFile28(hookScriptPath, buildHookScriptContent({ sessionId, token, endpointUrl }), {
     mode: 448
   });
@@ -250661,9 +251647,9 @@ var CliTaskSession = class _CliTaskSession {
       isApproved: opts.isAutonomyApproved ?? (() => false)
     });
     const root = opts.hookDirRoot ?? tmpdir10();
-    const hookDir = await mkdtemp3(join90(root, "fusion-cli-hooks-"));
-    const hookScriptPath = join90(hookDir, HOOK_SCRIPT_NAMES.hook);
-    const settingsPath = join90(hookDir, "settings.json");
+    const hookDir = await mkdtemp3(join91(root, "fusion-cli-hooks-"));
+    const hookScriptPath = join91(hookDir, HOOK_SCRIPT_NAMES.hook);
+    const settingsPath = join91(hookDir, "settings.json");
     const cliAgentSettings = opts.config.cliAgentSettings ?? null;
     const operatorEnvAdditions = (cliAgentSettings?.envAdditions ?? []).filter(
       (k2) => !/^FUSION_/i.test(k2)
@@ -250917,7 +251903,7 @@ function killLiveTaskSessions(taskId, manager, store) {
 init_logger();
 import * as fs8 from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
-import { join as join91, dirname as dirname43 } from "node:path";
+import { join as join92, dirname as dirname43 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 var log35 = createLogger("terminal");
 var ptyModule = null;
@@ -250949,16 +251935,16 @@ function findInstalledNodePtyNativeDir() {
   try {
     const umbrellaEntry = require4.resolve("node-pty");
     const umbrellaRoot = dirname43(umbrellaEntry);
-    const releaseDir = join91(umbrellaRoot, "build", "Release");
-    if (fs8.existsSync(join91(releaseDir, "pty.node"))) return releaseDir;
+    const releaseDir = join92(umbrellaRoot, "build", "Release");
+    if (fs8.existsSync(join92(releaseDir, "pty.node"))) return releaseDir;
     const packageName = nodePtyPlatformPackageName();
     const nativeEntry = nodePtyRequiredNativeEntry();
     if (!packageName || !nativeEntry) return null;
     const platformRequire = createRequire7(umbrellaEntry);
     const platformEntry = platformRequire.resolve(packageName);
     const platformRoot = dirname43(dirname43(platformEntry));
-    const prebuildDir = join91(platformRoot, "prebuilds", getNativePrebuildName());
-    return fs8.existsSync(join91(prebuildDir, nativeEntry)) ? prebuildDir : null;
+    const prebuildDir = join92(platformRoot, "prebuilds", getNativePrebuildName());
+    return fs8.existsSync(join92(prebuildDir, nativeEntry)) ? prebuildDir : null;
   } catch {
     return null;
   }
@@ -250968,14 +251954,14 @@ function findStagedNativeDir(platform3 = process.platform, arch = process.arch)
   const nativeEntry = nodePtyRequiredNativeEntry(platform3);
   if (!nativeEntry) return null;
   if (process.env.FUSION_RUNTIME_DIR) {
-    const envPath = join91(process.env.FUSION_RUNTIME_DIR, prebuildName);
-    if (fs8.existsSync(join91(envPath, nativeEntry))) {
+    const envPath = join92(process.env.FUSION_RUNTIME_DIR, prebuildName);
+    if (fs8.existsSync(join92(envPath, nativeEntry))) {
       return envPath;
     }
   }
   const execDir = dirname43(process.execPath);
-  const nextToBinary = join91(execDir, "runtime", prebuildName);
-  if (fs8.existsSync(join91(nextToBinary, nativeEntry))) {
+  const nextToBinary = join92(execDir, "runtime", prebuildName);
+  if (fs8.existsSync(join92(nextToBinary, nativeEntry))) {
     return nextToBinary;
   }
   return null;
@@ -250998,8 +251984,8 @@ function ensureNodePtyNativePermissions() {
     candidateDirs.add(installedNativeDir);
   }
   for (const nativeDir of candidateDirs) {
-    const helperPath = join91(nativeDir, "spawn-helper");
-    const nativeModulePath = join91(nativeDir, "pty.node");
+    const helperPath = join92(nativeDir, "spawn-helper");
+    const nativeModulePath = join92(nativeDir, "pty.node");
     try {
       fs8.chmodSync(helperPath, 493);
     } catch {
@@ -251028,7 +252014,7 @@ async function loadPtyModule() {
       process.env.NODE_PTY_SPAWN_HELPER_DIR = nativeDir;
     }
     process.env.FUSION_NATIVE_ASSETS_PATH = nativeDir;
-    const stagedUmbrellaEntry = join91(nativeDir, "node-pty-umbrella", "index.js");
+    const stagedUmbrellaEntry = join92(nativeDir, "node-pty-umbrella", "index.js");
     if (fs8.existsSync(stagedUmbrellaEntry)) {
       try {
         const stagedImport = await import(pathToFileURL2(stagedUmbrellaEntry).href);
@@ -252557,7 +253543,7 @@ async function runGraphTaskStep(deps, task, stepIndex, instanceId, governingNode
 // ../engine/src/executor/get-authoritative-assigned-agent.ts
 init_src2();
 init_logger();
-import { join as join92 } from "node:path";
+import { join as join93 } from "node:path";
 async function getAuthoritativeAssignedAgent(deps, assignedAgentId) {
   const normalizedId = assignedAgentId?.trim();
   if (!normalizedId) return null;
@@ -252568,7 +253554,7 @@ async function getAuthoritativeAssignedAgent(deps, assignedAgentId) {
     let authoritativeStore = deps.getAuthoritativeAssignedAgentStore();
     if (!authoritativeStore || authoritativeAgentLayer && !authoritativeStore.backendMode) {
       authoritativeStore = new AgentStore({
-        rootDir: join92(deps.rootDir, ".fusion"),
+        rootDir: join93(deps.rootDir, ".fusion"),
         taskStore: deps.store,
         ...authoritativeAgentLayer ? { asyncLayer: authoritativeAgentLayer } : {}
       });
@@ -254057,107 +255043,6 @@ ${failureContext.output.slice(0, VERIFICATION_LOG_MAX_CHARS)}
 // ../engine/src/executor/create-task-done-tool.ts
 init_src2();
 import { Type as Type8 } from "@earendil-works/pi-ai";
-
-// ../engine/src/execution-block-classifier.ts
-init_usage_limit_detector();
-init_transient_error_detector();
-var HOST_EXTERNAL_CODES = ["ENOSPC", "EDQUOT", "EROFS", "ENOMEM", "EMFILE", "ENFILE"];
-var NETWORK_EXTERNAL_CODES = ["ECONNREFUSED", "ECONNRESET", "ETIMEDOUT", "EAI_AGAIN", "ENOTFOUND"];
-function classifyExternalObstacle(message) {
-  const normalized3 = message.trim();
-  if (!normalized3) return void 0;
-  if (/Forbidden lifecycle path|rejected by the task lifecycle projection|TransitionRejectionError/i.test(normalized3)) {
-    return void 0;
-  }
-  for (const code of HOST_EXTERNAL_CODES) {
-    if (new RegExp(`\\b${code}\\b`, "i").test(normalized3)) return { origin: "host-environment", code };
-  }
-  for (const code of NETWORK_EXTERNAL_CODES) {
-    if (new RegExp(`\\b${code}\\b`, "i").test(normalized3)) return { origin: "network", code };
-  }
-  if (/socket hang up/i.test(normalized3)) return { origin: "network", code: "SOCKET_HANG_UP" };
-  if (isTransientAuthCredentialError(normalized3)) return void 0;
-  if (isUsageLimitError(normalized3)) return { origin: "model-provider", code: "USAGE_LIMIT" };
-  if (isOperatorActionableAgentError(normalized3)) return { origin: "credentials", code: "CREDENTIALS" };
-  return void 0;
-}
-function detectRepairableObstacleHint(message) {
-  const normalized3 = message.trim();
-  if (!normalized3) return void 0;
-  const missingSignal = /\b(?:command not found|not installed|is not recognized as an internal or external command)\b|\bneither\b.{0,80}\binstalled\b/i;
-  const missingFileSignal = /(?:\b(?:spawn|exec(?:ute)?|binary|executable|interpreter|command)\b.{0,80}\b(?:ENOENT|no such file or directory)\b|\bENOENT\b.{0,80}\b(?:binary|executable|interpreter|command)\b)/i;
-  if (!missingSignal.test(normalized3) && !missingFileSignal.test(normalized3)) return void 0;
-  return /\b(?:service|daemon)\b/i.test(normalized3) ? "missing-service" : "missing-tooling";
-}
-var TASK_ID_RE = /^[A-Z][A-Z0-9]*-\d+$/i;
-var LEGACY_PR_REF_RE = /^(?:pr[:#-]|#|PR-)(\d+)$/i;
-function partitionBlockedByRefs(blockedBy) {
-  const taskIds = [];
-  for (const raw of blockedBy) {
-    const id = raw.trim();
-    if (!id) continue;
-    if (LEGACY_PR_REF_RE.test(id)) continue;
-    if (TASK_ID_RE.test(id)) {
-      const m2 = id.toUpperCase().match(/^([A-Z][A-Z0-9]*)-(\d+)$/);
-      taskIds.push(m2 ? `${m2[1]}-${m2[2]}` : id.toUpperCase());
-    }
-  }
-  return { taskIds: [...new Set(taskIds)] };
-}
-function classifyBlockedExit(_reason, blockedBy = []) {
-  const { taskIds } = partitionBlockedByRefs(blockedBy);
-  if (taskIds.length > 0) {
-    return {
-      class: "external",
-      thrashSignature: `tasks:${taskIds.slice().sort().join(",")}`
-    };
-  }
-  return {
-    class: "plan-defect",
-    thrashSignature: "plan-defect"
-  };
-}
-var BLOCKED_THRASH_LIMIT = 3;
-var BLOCKED_THRASH_WINDOW_MS = 60 * 60 * 1e3;
-function countBlockedThrashHits(log42, signature, nowMs = Date.now(), windowMs = BLOCKED_THRASH_WINDOW_MS) {
-  if (!log42?.length) return 0;
-  if (signature === "plan-defect") return 0;
-  const cutoff = nowMs - windowMs;
-  let count2 = 0;
-  for (const entry of log42) {
-    const ts4 = entry.timestamp ? Date.parse(entry.timestamp) : Number.NaN;
-    if (Number.isFinite(ts4) && ts4 < cutoff) continue;
-    const action = entry.action ?? "";
-    if (!action.startsWith("BLOCKED:") && !action.includes("DUPLICATE_REPLAN_EXHAUSTED") && !action.includes("BLOCKED_THRASH")) {
-      if (!action.includes("parked failed (honest blocked exit") && !action.includes("durable external block")) {
-        continue;
-      }
-    }
-    for (const part of signature.split("|")) {
-      if (part.startsWith("tasks:") && part.slice(6).split(",").some((id) => id && action.includes(id))) {
-        count2 += 1;
-        break;
-      }
-    }
-  }
-  return count2;
-}
-function isDurableBlockedTask(task) {
-  const meta2 = task.sourceMetadata;
-  if (!meta2 || typeof meta2 !== "object") return false;
-  if (meta2.blockedClass !== "external") return false;
-  return task.status === "failed" || task.status === "needs-replan";
-}
-function buildExternalBlockMetadataPatch(classification, thrashCount) {
-  return {
-    blockedClass: classification.class,
-    blockedThrashSignature: classification.thrashSignature,
-    blockedThrashCount: thrashCount,
-    externalBlockers: []
-  };
-}
-
-// ../engine/src/executor/create-task-done-tool.ts
 init_effective_settings();
 init_run_audit();
 init_logger();
@@ -254231,7 +255116,13 @@ function createTaskDoneTool(deps, taskId, worktreePath, promptContent, codeRevie
       )),
       reason: Type8.Optional(Type8.String({
         description: 'Required when outcome="blocked": concrete explanation of what is blocking the work and what is needed to unblock it.'
-      }))
+      })),
+      blockedReport: Type8.Optional(Type8.Object({
+        verifiedCondition: Type8.Optional(Type8.String()),
+        stopReason: Type8.Optional(Type8.String()),
+        unimplementedWork: Type8.Optional(Type8.String()),
+        unblockCondition: Type8.Optional(Type8.String())
+      }, { description: "Optional safe operator report for an accepted outside-worktree block. State what was verified, why work stopped, what remains undone, and the precise unblock condition. Never include prompts, logs, stack traces, or credentials." }))
     }),
     execute: async (_id, params) => {
       if (params.outcome === "blocked") {
@@ -254282,6 +255173,7 @@ function createTaskDoneTool(deps, taskId, worktreePath, promptContent, codeRevie
           const externalBlock = {
             ...classifiedObstacle,
             message: reason,
+            report: buildTaskExternalBlockReport(classifiedObstacle, params.blockedReport),
             source: "agent-declaration",
             blockedAt: (/* @__PURE__ */ new Date()).toISOString(),
             resume: {
@@ -254484,9 +255376,6 @@ function createTaskDoneTool(deps, taskId, worktreePath, promptContent, codeRevie
             ...taintUpdate,
             paused: false,
             pausedByAgentId: null,
-            worktree: null,
-            branch: null,
-            branchWriteOrigin: "engine",
             sessionFile: null
           });
           await store.logEntry(
@@ -254504,9 +255393,6 @@ function createTaskDoneTool(deps, taskId, worktreePath, promptContent, codeRevie
             ...taintUpdate,
             paused: false,
             pausedByAgentId: null,
-            worktree: null,
-            branch: null,
-            branchWriteOrigin: "engine",
             sessionFile: null
           });
           await store.logEntry(taskId, `${refusalMessage} \u2014 fn_task_done refusal retry budget exhausted`, void 0, deps.getRunContextFor(task.id));
@@ -254839,46 +255725,6 @@ async function isReentrantPausedAbortedInFlightNode(deps, live, result, abortPro
   return live.column === resumeLanes.hold || live.column === resumeLanes.review || live.column === resumeLanes.wip;
 }
 
-// ../engine/src/executor/route-graph-failure-to-execution-resume.ts
-init_src2();
-init_logger();
-init_lifecycle_columns();
-async function routeGraphFailureToExecutionResume(deps, live, failedNode, failureValue, resumeLanesMemo) {
-  if (live.deletedAt) return false;
-  if (isTaskExternallyBlocked(live)) {
-    executorLog.log(`${live.id}: graph failure resume skipped \u2014 external Blocked freeze honored`);
-    return false;
-  }
-  if (live.paused || live.userPaused === true) return false;
-  if ((await resolveTerminalColumnsFor(deps.store, live.id)).includes(live.column)) return false;
-  if (isDurableBlockedTask(live)) {
-    executorLog.log(
-      `${live.id}: graph failure resume skipped \u2014 durable BLOCKED park honored (task-dependency block)`
-    );
-    return false;
-  }
-  if (failedNode === COMPLETION_SUMMARY_NODE_ID) return false;
-  const incompleteSteps = hasNonTerminalWorkflowSteps(live);
-  if (!incompleteSteps && (failureValue === "remediation-not-scheduled" || failureValue === "missing-remediation-context") && await deps.isRemediationGraphNode(live.id, failedNode)) return false;
-  const implementationIncompleteMergeFailure = isMergeGraphFailure(failedNode) && failureValue === "implementation-incomplete";
-  if (implementationIncompleteMergeFailure && !incompleteSteps) return false;
-  const resumeRouterLanes = await deps.resolveResumeLanes(live.id, resumeLanesMemo);
-  if (!resumeRouterLanes.wipDeclared) return false;
-  if (live.column !== resumeRouterLanes.wip || !implementationIncompleteMergeFailure) {
-    const message2 = `Workflow graph failed at node '${failedNode}'${failureValue ? ` (${failureValue})` : ""} \u2014 automatic recovery cannot move '${live.column}' backward; card remains in place`;
-    executorLog.warn(`${live.id}: ${message2}`);
-    await deps.store.logEntry(live.id, message2, void 0, deps.getRunContextFor(live.id));
-    return false;
-  }
-  const message = `Workflow graph failed at node '${failedNode}'${failureValue ? ` (${failureValue})` : ""} with incomplete work \u2014 resuming in place in '${live.column}'`;
-  executorLog.warn(`${live.id}: ${message}`);
-  await deps.store.logEntry(live.id, message, void 0, deps.getRunContextFor(live.id));
-  await deps.store.updateTask(live.id, { status: null, error: null }, deps.getRunContextFor(live.id));
-  await deps.clearTerminalStepFailuresForRetry(live.id, "archive");
-  await deps.persistTokenUsage(live.id);
-  return true;
-}
-
 // ../engine/src/executor/reenter-paused-aborted-workflow-node.ts
 init_run_audit();
 init_logger();
@@ -255141,6 +255987,7 @@ async function handleStaleInReviewParsePauseAbortReplay(deps, live, result, abor
 }
 
 // ../engine/src/executor/route-graph-merge-failure-to-retry.ts
+init_src2();
 init_logger();
 init_workflow_merge_nodes();
 
@@ -255233,11 +256080,23 @@ async function routeGraphMergeFailureToRetry(deps, live, result, abortProvenance
       throw firstBoundaryError;
     }
     if (mergeBoundary.blocked) {
-      const { reason: reason2, code, missingInstanceCount } = mergeBoundary.blocked;
+      const { reason: reason2, code, missingInstanceCount, evidence } = mergeBoundary.blocked;
+      if (await deps.routeGraphFailureToExecutionResume?.(live, failedNode, MERGE_BOUNDARY_RECOVERY_VALUE, void 0, evidence)) {
+        await deps.store.logEntry(live.id, `Workflow merge boundary retry scheduled evidence recovery: ${reason2}`, void 0, deps.getRunContextFor(live.id));
+        await persistTokenUsageBestEffort(deps.persistTokenUsage, live.id);
+        return true;
+      }
+      const settings = typeof deps.store.getSettings === "function" ? await deps.store.getSettings().catch(() => void 0) : void 0;
+      const current = typeof deps.store.getTask === "function" ? await deps.store.getTask(live.id).catch(() => void 0) : live;
+      if (!current || current.deletedAt || current.paused || current.userPaused || current.autoMerge === false || settings && !allowsAutoMergeProcessing(current, settings)) {
+        await deps.store.logEntry(live.id, `Workflow merge boundary retry is held for human control: ${reason2}`, void 0, deps.getRunContextFor(live.id));
+        await persistTokenUsageBestEffort(deps.persistTokenUsage, live.id);
+        return true;
+      }
       await deps.store.logEntry(live.id, `Workflow merge boundary retry parked task: ${reason2}`, void 0, deps.getRunContextFor(live.id));
       let parked2 = false;
-      await deps.store.updateTaskAtomic(live.id, (current) => {
-        if (!current || current.deletedAt || current.status != null || current.paused || current.userPaused || typeof live.columnMovedAt === "string" && typeof current.columnMovedAt === "string" && current.columnMovedAt !== live.columnMovedAt) return null;
+      await deps.store.updateTaskAtomic(live.id, (current2) => {
+        if (!current2 || current2.deletedAt || current2.status != null || current2.paused || current2.userPaused || current2.autoMerge === false || settings && !allowsAutoMergeProcessing(current2, settings) || typeof live.columnMovedAt === "string" && typeof current2.columnMovedAt === "string" && current2.columnMovedAt !== live.columnMovedAt) return null;
         parked2 = true;
         return {
           status: "failed",
@@ -255298,6 +256157,10 @@ async function routeGraphMergeFailureToRetry(deps, live, result, abortProvenance
     return true;
   }
   const reason = mergeRequestRejection instanceof Error ? mergeRequestRejection.message : String(mergeRequestRejection);
+  if (reason.endsWith(PRE_MERGE_STEPS_NOT_RUN_BLOCKER)) {
+    await persistTokenUsageBestEffort(deps.persistTokenUsage, live.id);
+    return true;
+  }
   try {
     await deps.store.logEntry(
       live.id,
@@ -255321,7 +256184,8 @@ async function routeGraphMergeFailureToRetry(deps, live, result, abortProvenance
 // ../engine/src/executor/route-implementation-incomplete-merge-graph-failure.ts
 init_logger();
 init_lifecycle_columns();
-async function routeImplementationIncompleteMergeGraphFailure(deps, live, failedNode) {
+init_workflow_merge_nodes();
+async function routeImplementationIncompleteMergeGraphFailure(deps, live, failedNode, failureValue = "implementation-incomplete", boundaryEvidence) {
   deps.clearPausedAborted(live.id);
   let resumeLive = live;
   if (live.paused === true && live.userPaused !== true) {
@@ -255331,7 +256195,7 @@ async function routeImplementationIncompleteMergeGraphFailure(deps, live, failed
     }, deps.getRunContextFor(live.id));
     resumeLive = { ...live, paused: false, pausedReason: void 0 };
   }
-  if (hasNonTerminalWorkflowSteps(resumeLive) && await deps.routeGraphFailureToExecutionResume(resumeLive, failedNode, "implementation-incomplete")) {
+  if ((hasNonTerminalWorkflowSteps(resumeLive) || failureValue === MERGE_BOUNDARY_RECOVERY_VALUE) && await deps.routeGraphFailureToExecutionResume(resumeLive, failedNode, failureValue, void 0, boundaryEvidence)) {
     return true;
   }
   deps.activeWorktrees.delete(live.id);
@@ -255839,7 +256703,15 @@ function createAuthoritativeWorkflowPrimitivesFromExecutor(deps, settings, outpu
         runId: ctx.run.runId
       });
       if (mergeBoundary.blocked) {
-        return { outcome: "failure", value: MERGE_BOUNDARY_UNPROVEN_VALUE };
+        return {
+          outcome: "failure",
+          value: MERGE_BOUNDARY_RECOVERY_VALUE,
+          contextPatch: {
+            "workflow:merge-boundary-recovery-code": mergeBoundary.blocked.evidence.code,
+            "workflow:merge-boundary-non-terminal-node-id": mergeBoundary.blocked.evidence.nonTerminalNodeId,
+            "workflow:merge-boundary-missing-instance-ids": mergeBoundary.blocked.evidence.missingInstanceIds
+          }
+        };
       }
       const mergeTask = mergeBoundary.task;
       const missingImplementationProof = await deps.getWorkflowMergeImplementationProofFailure(mergeTask);
@@ -256397,7 +257269,7 @@ Repository scope (task-level; review this plan once): ${detail.repositoryScope?.
 init_src2();
 init_logger();
 import { existsSync as existsSync81 } from "node:fs";
-import { join as join93 } from "node:path";
+import { join as join94 } from "node:path";
 
 // ../engine/src/executor/workflow-step-recommendations.ts
 init_src2();
@@ -256485,7 +257357,7 @@ function resolveGraphNodeSessionBoundary(input) {
   if (!input.isWorkspace || input.legacyWorkspaceLayout) return void 0;
   const repoRoots = (input.confirmedRepositories ?? []).map((repoRelPath) => ({
     repoRelPath,
-    repoRootDir: join93(input.rootDir, repoRelPath)
+    repoRootDir: join94(input.rootDir, repoRelPath)
   }));
   if (repoRoots.length === 0) return void 0;
   return {
@@ -256928,7 +257800,7 @@ ${prompt}`;
       const legacyWorkspaceLayout = isLegacyWorkspaceWorktreeLayout(workspaceReviewTarget, workspaceTaskDir2);
       const scopedRepoRoots = workspaceReviewTarget.repositoryScope.repositories.map((repoRelPath) => ({
         repoRelPath,
-        repoRootDir: join93(deps.rootDir, repoRelPath)
+        repoRootDir: join94(deps.rootDir, repoRelPath)
       }));
       let aggregate = await reviewWorkspacePerRepo(workspaceReviewTarget, async (repoWorktreePath) => {
         const repoRelPath = workspaceConfig.repos.find(
@@ -256937,7 +257809,7 @@ ${prompt}`;
         const reviewBoundary = legacyWorkspaceLayout ? {
           kind: "task-worktree",
           writableRoot: repoWorktreePath,
-          projectRoot: repoRelPath ? join93(deps.rootDir, repoRelPath) : deps.rootDir
+          projectRoot: repoRelPath ? join94(deps.rootDir, repoRelPath) : deps.rootDir
         } : {
           kind: "workspace-task-dir",
           writableRoot: workspaceTaskDir2,
@@ -257117,8 +257989,8 @@ ${prompt}`;
 
 // ../engine/src/executor/handle-graph-failure.ts
 init_src2();
-import { join as join94 } from "node:path";
-import { readFile as readFile50, rm as rm16, writeFile as writeFile29 } from "node:fs/promises";
+import { join as join95 } from "node:path";
+import { readFile as readFile51, rm as rm16, writeFile as writeFile29 } from "node:fs/promises";
 init_spec_staleness();
 init_logger();
 init_run_audit();
@@ -257492,10 +258364,18 @@ async function handleGraphFailure(deps, task, result) {
     const failedNode = result.visitedNodeIds[result.visitedNodeIds.length - 1];
     const mergeGraphFailure = isMergeGraphFailure(failedNode);
     const failureValue = graphFailureValue(result);
+    const recoveryCode = result.context?.["workflow:merge-boundary-recovery-code"];
+    const recoveryMissingIds = result.context?.["workflow:merge-boundary-missing-instance-ids"];
+    const recoveryNonTerminalNodeId = result.context?.["workflow:merge-boundary-non-terminal-node-id"];
+    const boundaryEvidence = failureValue === MERGE_BOUNDARY_RECOVERY_VALUE && (recoveryCode === "no-node-result" || recoveryCode === "non-terminal-node-result" || recoveryCode === "missing-foreach-instances") && Array.isArray(recoveryMissingIds) && recoveryMissingIds.every((id) => typeof id === "string") ? {
+      code: recoveryCode,
+      missingInstanceIds: recoveryMissingIds,
+      nonTerminalNodeId: typeof recoveryNonTerminalNodeId === "string" ? recoveryNonTerminalNodeId : void 0
+    } : void 0;
     if (!live.paused && !live.userPaused && !live.deletedAt && typeof failedNode === "string" && (failedNode === "parse" || failedNode.endsWith(":parse") || failedNode.includes("parse-steps") || failureValue === "parse-error" || failureValue === "missing-implementation-steps")) {
       try {
-        const tasksDir = typeof deps.store.getTasksDir === "function" ? deps.store.getTasksDir() : join94(deps.rootDir, ".fusion", "tasks");
-        const promptContent = await readFile50(getPromptPath(tasksDir, live.id), "utf-8").catch(() => "");
+        const tasksDir = typeof deps.store.getTasksDir === "function" ? deps.store.getTasksDir() : join95(deps.rootDir, ".fusion", "tasks");
+        const promptContent = await readFile51(getPromptPath(tasksDir, live.id), "utf-8").catch(() => "");
         const redirectReason = nonExecutableDuplicateRedirectReason(promptContent, live.title);
         if (redirectReason) {
           const duplicateResolution = resolveExplicitDuplicateMarker(promptContent, live.title);
@@ -257599,8 +258479,8 @@ async function handleGraphFailure(deps, task, result) {
       await deps.persistTokenUsage(task.id);
       return;
     }
-    if (mergeGraphFailure && failureValue === "implementation-incomplete") {
-      if (await deps.routeImplementationIncompleteMergeGraphFailure(live, failedNode ?? "unknown")) {
+    if (mergeGraphFailure && (failureValue === "implementation-incomplete" || failureValue === MERGE_BOUNDARY_RECOVERY_VALUE)) {
+      if (await deps.routeImplementationIncompleteMergeGraphFailure(live, failedNode ?? "unknown", failureValue, boundaryEvidence)) {
         return;
       }
     }
@@ -257862,8 +258742,8 @@ async function handleGraphFailure(deps, task, result) {
       if (!parked) {
         const capturedRunId = deps.getRunContextFor(task.id)?.runId;
         const capturedColumnMovedAt = live.columnMovedAt;
-        const tasksDir = typeof deps.store.getTasksDir === "function" ? deps.store.getTasksDir() : join94(deps.rootDir, ".fusion", "tasks");
-        const deferredParkIntentPath = join94(tasksDir, task.id, "deferred-terminal-park.json");
+        const tasksDir = typeof deps.store.getTasksDir === "function" ? deps.store.getTasksDir() : join95(deps.rootDir, ".fusion", "tasks");
+        const deferredParkIntentPath = join95(tasksDir, task.id, "deferred-terminal-park.json");
         const intentWrite = writeFile29(deferredParkIntentPath, JSON.stringify({ message, writtenAt: (/* @__PURE__ */ new Date()).toISOString(), columnMovedAt: capturedColumnMovedAt }), "utf-8").catch((intentError) => {
           executorLog.warn(`${task.id}: failed to persist deferred terminal-park intent: ${intentError instanceof Error ? intentError.message : String(intentError)}`);
         });
@@ -258129,7 +259009,7 @@ init_src2();
 import { exec as exec56 } from "node:child_process";
 import { promisify as promisify78 } from "node:util";
 import { existsSync as existsSync83 } from "node:fs";
-import { join as join96 } from "node:path";
+import { join as join97 } from "node:path";
 import { SessionManager as SessionManager2 } from "@earendil-works/pi-coding-agent";
 init_agent_tools();
 init_agent_instructions();
@@ -258175,7 +259055,7 @@ init_src2();
 init_logger();
 init_verification_concurrency();
 import { existsSync as existsSync82, readdirSync as readdirSync13, readFileSync as readFileSync28 } from "node:fs";
-import { isAbsolute as isAbsolute24, join as join95, relative as relative22 } from "node:path";
+import { isAbsolute as isAbsolute24, join as join96, relative as relative22 } from "node:path";
 import { Type as Type10 } from "@earendil-works/pi-ai";
 var MAX_OUTPUT_BYTES = 200 * 1024;
 var VERIFICATION_FAILURE_SUMMARY_MAX_CHARS = 8e3;
@@ -258303,7 +259183,7 @@ function findWorkspacePackageDir(rootDir, packageName) {
   for (const candidate of candidates) {
     if (!candidate) continue;
     try {
-      const pkg = JSON.parse(readFileSync28(join95(rootDir, candidate, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync28(join96(rootDir, candidate, "package.json"), "utf8"));
       if (pkg.name === packageName) {
         packageDirCache.set(cacheKey, candidate);
         return candidate;
@@ -258318,7 +259198,7 @@ function findWorkspacePackageDir(rootDir, packageName) {
   while (queue.length > 0) {
     const current = queue.shift();
     if (!current) break;
-    const abs = join95(rootDir, current.dir);
+    const abs = join96(rootDir, current.dir);
     let entries;
     try {
       entries = readdirSync13(abs, { withFileTypes: true });
@@ -258328,9 +259208,9 @@ function findWorkspacePackageDir(rootDir, packageName) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name === "node_modules" || entry.name === "dist") continue;
-      const child = join95(current.dir, entry.name);
+      const child = join96(current.dir, entry.name);
       try {
-        const pkg = JSON.parse(readFileSync28(join95(rootDir, child, "package.json"), "utf8"));
+        const pkg = JSON.parse(readFileSync28(join96(rootDir, child, "package.json"), "utf8"));
         if (pkg.name === packageName) {
           packageDirCache.set(cacheKey, child);
           return child;
@@ -258350,7 +259230,7 @@ function toPackageRelativeFilter(token, rootDir, packageDir) {
     return normalized3.slice(normalizedPackageDir.length + 1);
   }
   if (isAbsolute24(token)) {
-    const rel = relative22(join95(rootDir, packageDir), token).replace(/\\/g, "/");
+    const rel = relative22(join96(rootDir, packageDir), token).replace(/\\/g, "/");
     if (!rel.startsWith("../") && rel !== "..") return rel;
   }
   return token;
@@ -258804,7 +259684,7 @@ function createRunVerificationTool(opts) {
       if (params.cwd && isAbsolute24(params.cwd)) {
         resolvedCwd = params.cwd;
       } else if (params.cwd) {
-        resolvedCwd = join95(selectedRepo?.worktreePath ?? worktreePath, params.cwd);
+        resolvedCwd = join96(selectedRepo?.worktreePath ?? worktreePath, params.cwd);
       } else {
         resolvedCwd = selectedRepo?.worktreePath ?? worktreePath;
       }
@@ -258838,7 +259718,7 @@ function createRunVerificationTool(opts) {
         warnings.push(...normalized3.warnings);
       }
       if (effectiveCommand.trimStart().startsWith("pnpm --filter")) {
-        const modulesYaml = join95(verificationRootDir, "node_modules", ".modules.yaml");
+        const modulesYaml = join96(verificationRootDir, "node_modules", ".modules.yaml");
         if (!existsSync82(modulesYaml)) {
           const installCmd = "pnpm install --prefer-offline";
           const msg = `node_modules/.modules.yaml not found in workspace root \u2014 auto-prepending \`${installCmd}\` before running the command.`;
@@ -259160,6 +260040,7 @@ async function parkExternalSessionObstacle(deps, taskId, errorMessage3) {
   const externalBlock = {
     ...obstacle,
     message: errorMessage3,
+    report: buildTaskExternalBlockReport(obstacle),
     source: "session-failure",
     blockedAt: (/* @__PURE__ */ new Date()).toISOString(),
     resume: {
@@ -259287,7 +260168,7 @@ async function runImplementation(deps, task, graphCompletion, reportImplementati
   const activeMergeStatuses = /* @__PURE__ */ new Set(["merging", "merging-pr", "merging-fix"]);
   const isActiveTask = activeColumns.has(task.column) || activeMergeStatuses.has(task.status ?? "");
   if (!isActiveTask) {
-    const tasksDir = join96(deps.store.getFusionDir(), "tasks");
+    const tasksDir = join97(deps.store.getFusionDir(), "tasks");
     const promptPath = getPromptPath(tasksDir, task.id);
     const staleness = await evaluateSpecStaleness({
       settings,
@@ -259479,14 +260360,14 @@ async function runImplementation(deps, task, graphCompletion, reportImplementati
         return {
           kind: "task-worktree",
           writableRoot: worktreePath,
-          projectRoot: repoRelPath ? join96(deps.rootDir, repoRelPath) : deps.rootDir
+          projectRoot: repoRelPath ? join97(deps.rootDir, repoRelPath) : deps.rootDir
         };
       }
       return {
         kind: "workspace-task-dir",
         writableRoot: worktreePath,
         projectRoot: deps.rootDir,
-        repoRoots: task.repositoryScope?.state === "confirmed" ? task.repositoryScope.repositories.map((repoRelPath) => ({ repoRelPath, repoRootDir: join96(deps.rootDir, repoRelPath) })) : []
+        repoRoots: task.repositoryScope?.state === "confirmed" ? task.repositoryScope.repositories.map((repoRelPath) => ({ repoRelPath, repoRootDir: join97(deps.rootDir, repoRelPath) })) : []
       };
     })() : {
       kind: "task-worktree",
@@ -262133,59 +263014,6 @@ async function terminateChildAgent(deps, childId) {
   deps.setTotalSpawnedCount(Math.max(0, deps.totalSpawnedCount - 1));
 }
 
-// ../engine/src/executor/evaluate-workflow-merge-boundary.ts
-init_src2();
-async function evaluateWorkflowMergeBoundary(deps, task, runId) {
-  const relevant = (task.workflowStepResults ?? []).filter(
-    (result) => result.source === "node" && (result.phase ?? "pre-merge") === "pre-merge"
-  );
-  const hasRelevantNodeResult = relevant.length > 0;
-  const nonTerminalResult = relevant.find((result) => result.status !== "passed" && result.status !== "skipped");
-  const allResultsTerminal = nonTerminalResult === void 0;
-  let ir2;
-  try {
-    ir2 = await resolveWorkflowIrForTask(deps.store, task.id);
-  } catch {
-  }
-  if (!ir2) return { resolved: false, hasRelevantNodeResult, allResultsTerminal, coverageComplete: true, hasLiveStepImplementationProof: false, hasForeachStepExecute: false, missingInstanceIds: [], nonTerminalResult, complete: false };
-  let persistedInstances = [];
-  try {
-    persistedInstances = await deps.loadMergeBoundaryInstances(task.id, runId);
-  } catch {
-  }
-  const coverage = evaluateForeachMergeProof({ ir: ir2, steps: task.steps, workflowStepResults: task.workflowStepResults, persistedInstances });
-  const coverageComplete = coverage.missingInstanceIds.length === 0;
-  const hasLiveStepImplementationProof = coverage.expectedInstanceIds.length > 0 && coverage.expectedInstanceIds.every((id) => coverage.liveStepSatisfiedInstanceIds.includes(id));
-  const complete = allResultsTerminal && coverageComplete && (hasRelevantNodeResult || hasLiveStepImplementationProof);
-  return { resolved: true, hasRelevantNodeResult, allResultsTerminal, coverageComplete, hasLiveStepImplementationProof, hasForeachStepExecute: coverage.hasForeachStepExecute, missingInstanceIds: coverage.missingInstanceIds, nonTerminalResult, complete };
-}
-async function getWorkflowMergeImplementationProofFailure(deps, task) {
-  const taint = evaluateSkipBypassTaint(task);
-  if (taint.blocked) return "implementation did not run: steps were skipped after a bulk-step-completion refusal without an accepted fn_task_done";
-  if (task.noCommitsExpected === true) return void 0;
-  let ir2;
-  try {
-    ir2 = await resolveWorkflowIrForTask(deps.store, task.id);
-  } catch {
-    ir2 = void 0;
-  }
-  if (!ir2) return void 0;
-  const usesParsedSteps = ir2.nodes.some((node) => node.kind === "parse-steps");
-  const usesExecuteSeam = ir2.nodes.some((node) => node.kind === "prompt" && node.config?.seam === "execute");
-  if (!usesParsedSteps && !usesExecuteSeam) return void 0;
-  const steps = Array.isArray(task.steps) ? task.steps : [];
-  const hasTerminalParsedSteps = steps.length > 0 && steps.every((step) => step.status === "done" || step.status === "skipped");
-  const hasModifiedFiles = (task.modifiedFiles?.length ?? 0) > 0;
-  const proof = await deps.evaluateWorkflowMergeBoundary(task);
-  const hasGraphNativeImplementationProof = proof.hasRelevantNodeResult && proof.allResultsTerminal && proof.coverageComplete;
-  if (usesParsedSteps) {
-    if (hasTerminalParsedSteps || hasGraphNativeImplementationProof) return void 0;
-    return proof.hasForeachStepExecute && !proof.coverageComplete ? `implementation did not run: foreach step instances are incomplete (missing ${proof.missingInstanceIds.join(", ")})` : "implementation did not run: parsed coding steps are missing or incomplete";
-  }
-  if (usesExecuteSeam) return hasTerminalParsedSteps || hasModifiedFiles || hasGraphNativeImplementationProof ? void 0 : "implementation did not run: execute seam has no completion proof";
-  return void 0;
-}
-
 // ../engine/src/executor/renew-task-lease.ts
 async function renewTaskLease(deps, taskId, agentId, leaseEpoch, nodeId, runId) {
   const renewedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -262242,37 +263070,6 @@ async function getExecutionPauseLabel(deps) {
   return null;
 }
 
-// ../engine/src/executor/workflow-merge-boundary-helpers.ts
-init_src2();
-async function resolveMergeBoundaryColumn(deps, taskId, nodeId) {
-  try {
-    const ir2 = await resolveWorkflowIrForTask(deps.store, taskId);
-    const named = ir2.nodes.find((n) => n.id === nodeId);
-    if (named && MERGE_REGION_KINDS.has(named.kind) && named.column) return named.column;
-    const mergeNode = ir2.nodes.find((n) => MERGE_REGION_KINDS.has(n.kind) && n.column);
-    if (mergeNode?.column) return mergeNode.column;
-    return "in-review";
-  } catch {
-    return "in-review";
-  }
-}
-async function loadMergeBoundaryInstances(deps, taskId, runId) {
-  if (!runId) return [];
-  const store = deps.store;
-  try {
-    return await store.loadWorkflowRunStepInstancesAsync?.(taskId, runId) ?? store.loadWorkflowRunStepInstances?.(taskId, runId) ?? [];
-  } catch {
-    return [];
-  }
-}
-function shouldCompleteChecklistAtWorkflowMerge(task, proof) {
-  if (!Array.isArray(task.steps) || task.steps.length === 0) return false;
-  if (task.steps.every((step) => step.status === "done" || step.status === "skipped")) return false;
-  if (proof) return proof.complete;
-  const graphNodeResults = (task.workflowStepResults ?? []).filter((result) => result.source === "node" && (result.phase ?? "pre-merge") === "pre-merge");
-  return graphNodeResults.length > 0 && graphNodeResults.every((result) => result.status === "passed" || result.status === "skipped");
-}
-
 // ../engine/src/executor/mark-paused-aborted.ts
 function markPausedAborted(deps, taskId, provenance = "hard-cancel", source = "unspecified", options = {}) {
   const previousProvenance = deps.pausedAbortProvenance.get(taskId);
@@ -263397,6 +264194,7 @@ function buildRouteGraphFailureToExecutionResumeDeps(host) {
     ...facadeMethods(host, [
       "getRunContextFor",
       "resolveResumeLanes",
+      "isLiveSharedBranchGroupMember",
       "clearTerminalStepFailuresForRetry",
       "persistTokenUsage",
       // FNXC:WorkflowRemediation 2026-08-09-21:41: FN-8910 completed-review park for refused remediation.
@@ -263533,7 +264331,7 @@ function buildRouteGraphMergeFailureToRetryDeps(host) {
   return {
     ...buildStoreRunContextDeps(host),
     mergeRequester: host.mergeRequester,
-    ...facadeMethods(host, ["ensureWorkflowMergeBoundaryTask", "persistTokenUsage"])
+    ...facadeMethods(host, ["ensureWorkflowMergeBoundaryTask", "persistTokenUsage", "routeGraphFailureToExecutionResume"])
   };
 }
 function buildRouteImplementationIncompleteMergeGraphFailureDeps(host) {
@@ -264251,10 +265049,10 @@ init_logger();
 
 // ../engine/src/review-artifacts/feature-video.ts
 init_src2();
-import { access as access10, mkdtemp as mkdtemp4, readFile as readFile51, rm as rm17 } from "node:fs/promises";
+import { access as access10, mkdtemp as mkdtemp4, readFile as readFile52, rm as rm17 } from "node:fs/promises";
 import { constants as constants2 } from "node:fs";
 import { tmpdir as tmpdir11 } from "node:os";
-import { join as join97 } from "node:path";
+import { join as join98 } from "node:path";
 var SCENARIO_DOCUMENT_KEY = "review-artifact-scenario";
 var MAX_DURATION_MS = 15e3;
 var DEFAULT_DURATION_MS = 3e3;
@@ -264285,7 +265083,7 @@ async function generateFeatureVideo(options) {
   let browser;
   let context;
   try {
-    recordingDir = await mkdtemp4(join97(tmpdir11(), "fusion-feature-video-"));
+    recordingDir = await mkdtemp4(join98(tmpdir11(), "fusion-feature-video-"));
     try {
       browser = await client.launch({ executablePath, headless: true });
     } catch {
@@ -264303,7 +265101,7 @@ async function generateFeatureVideo(options) {
     await (options.sleep ?? defaultSleep)(Math.min(Math.max(options.durationMs ?? DEFAULT_DURATION_MS, 0), MAX_DURATION_MS));
     await context.close();
     context = void 0;
-    const data = await readFile51(await video.path());
+    const data = await readFile52(await video.path());
     if (data.byteLength > (options.maxBytes ?? DEFAULT_MAX_BYTES2)) {
       return { status: "failed", reason: "size-cap-exceeded" };
     }
@@ -274535,7 +275333,7 @@ init_effective_settings();
 // ../engine/src/spec-validation/task-document-references.ts
 init_src2();
 import { access as access11 } from "node:fs/promises";
-import { join as join98 } from "node:path";
+import { join as join99 } from "node:path";
 var TASK_PATH_REGEX = /\.fusion\/tasks\/[A-Z0-9]+(?:-[A-Z0-9]+)*\/[^\s`'"\]]+/g;
 function normalizePathToken(token) {
   return token.replace(/^[`([{"']+/, "").replace(/[`),.;:!?\]}'"]+$/, "");
@@ -274623,7 +275421,7 @@ async function detectDanglingTaskDocReferences(promptContent, opts) {
   }
   const dangling = [];
   for (const [path6, sections2] of references.entries()) {
-    const absPath = join98(opts.rootDir, path6);
+    const absPath = join99(opts.rootDir, path6);
     if (await existsImpl(absPath)) continue;
     dangling.push({ path: path6, sections: Array.from(sections2).sort() });
   }
@@ -274721,8 +275519,8 @@ init_recovery_policy();
 init_agent_tools();
 import { execFile as execFile36 } from "node:child_process";
 import { existsSync as existsSync87 } from "node:fs";
-import { readFile as readFile52, writeFile as writeFile30, rm as rm18 } from "node:fs/promises";
-import { join as join99 } from "node:path";
+import { readFile as readFile53, writeFile as writeFile30, rm as rm18 } from "node:fs/promises";
+import { join as join100 } from "node:path";
 import { promisify as promisify83 } from "node:util";
 
 // ../engine/src/triage-domain/triage-preflight.ts
@@ -275734,8 +276532,8 @@ var TriageProcessor = class _TriageProcessor {
     }
     const settings = await mergeEffectiveSettings(this.store, task, await this.store.getSettings());
     const approvalRequired = resolvePlanApprovalRequired(settings);
-    const promptPath = join99(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
-    const written = await readFile52(promptPath, "utf-8").catch((err) => {
+    const promptPath = join100(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+    const written = await readFile53(promptPath, "utf-8").catch((err) => {
       const msg = err instanceof Error ? err.message : String(err);
       planLog.warn(`${task.id}: failed to read PROMPT.md during planning recovery (${promptPath}): ${msg}`);
       return "";
@@ -275773,8 +276571,8 @@ var TriageProcessor = class _TriageProcessor {
     return report2.outcome !== "withheld";
   }
   async readNonEmptyPromptDraft(taskId, context) {
-    const promptPath = join99(this.rootDir, ".fusion", "tasks", taskId, "PROMPT.md");
-    const written = await readFile52(promptPath, "utf-8").catch((err) => {
+    const promptPath = join100(this.rootDir, ".fusion", "tasks", taskId, "PROMPT.md");
+    const written = await readFile53(promptPath, "utf-8").catch((err) => {
       const msg = err instanceof Error ? err.message : String(err);
       const code = err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
       if (code === "ENOENT") {
@@ -276012,8 +276810,8 @@ var TriageProcessor = class _TriageProcessor {
         continue;
       }
       try {
-        const promptPath = join99(this.rootDir, ".fusion", "tasks", todoTask.id, "PROMPT.md");
-        const content = await readFile52(promptPath, "utf-8");
+        const promptPath = join100(this.rootDir, ".fusion", "tasks", todoTask.id, "PROMPT.md");
+        const content = await readFile53(promptPath, "utf-8");
         if (isTaskAwaitingPlanning(todoTask, content)) {
           eligibleTodoTasks.push(todoTask);
         }
@@ -276396,8 +277194,8 @@ var TriageProcessor = class _TriageProcessor {
     try {
       const liveTask = await this.store.getTask(task.id).catch(() => null);
       if (!liveTask || liveTask.paused === true || liveTask.userPaused === true) return false;
-      const promptPath = join99(this.rootDir, ".fusion", "tasks", liveTask.id, "PROMPT.md");
-      const written = await readFile52(promptPath, "utf-8").catch(() => "");
+      const promptPath = join100(this.rootDir, ".fusion", "tasks", liveTask.id, "PROMPT.md");
+      const written = await readFile53(promptPath, "utf-8").catch(() => "");
       const duplicateResolution = resolveExplicitDuplicateMarker(written, liveTask.title);
       if (!duplicateResolution.marker && !duplicateResolution.conflict) return false;
       const settings = await mergeEffectiveSettings(this.store, liveTask, await this.store.getSettings());
@@ -276799,8 +277597,8 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
           pluginContributions: triagePluginContributions
         });
         const triageSystemPromptFinal = collapsePromptLayers(triageLayers);
-        const authoritativePromptPath = join99(this.rootDir, promptPath);
-        const planningAttemptBaseline = existsSync87(authoritativePromptPath) ? await readFile52(authoritativePromptPath, "utf-8").catch(() => void 0) : void 0;
+        const authoritativePromptPath = join100(this.rootDir, promptPath);
+        const planningAttemptBaseline = existsSync87(authoritativePromptPath) ? await readFile53(authoritativePromptPath, "utf-8").catch(() => void 0) : void 0;
         const planningAttempt = {
           id: `${task.id}:${++this.planningAttemptSequence}`,
           baseline: planningAttemptBaseline,
@@ -276929,7 +277727,11 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
             extraCommands: [
               ...extractCommandBinaries(settings?.testCommand),
               ...extractCommandBinaries(settings?.buildCommand)
-            ]
+            ],
+            testCommand: settings?.testCommand,
+            buildCommand: settings?.buildCommand,
+            rootDir: this.rootDir,
+            projectId: this.store.getProjectId?.() ?? this.rootDir
           }).catch(() => ({ capabilities: [], degraded: true }));
           const agentPrompt = buildSpecificationPrompt(
             detail,
@@ -277040,8 +277842,8 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
               "Recovered the plan written inside the task worktree into the project .fusion folder"
             ).catch(() => void 0);
           }
-          let written = await readFile52(
-            join99(this.rootDir, promptPath),
+          let written = await readFile53(
+            join100(this.rootDir, promptPath),
             "utf-8"
           ).catch((err) => {
             const msg = err instanceof Error ? err.message : String(err);
@@ -277921,7 +278723,7 @@ ${lines.join("\n")}` }],
   async clearDuplicateMarkerForReplan(task, canonicalId, feedback, options) {
     if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
       if (options?.source !== "title") {
-        await rm18(join99(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+        await rm18(join100(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
       }
       if (resolveExplicitDuplicateMarker(null, task.title).marker?.canonicalId === canonicalId) {
         await this.store.updateTask(task.id, { title: `Duplicate redirect cleared: ${canonicalId}` });
@@ -278089,7 +278891,7 @@ ${lines.join("\n")}` }],
       let nextPrompt = applyOriginalDescription(written, originalDescription);
       nextPrompt = applyFrontendUxCriteria(nextPrompt, parsedFileScope);
       if (nextPrompt !== written) {
-        const promptPath = join99(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+        const promptPath = join100(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
         try {
           if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
             await writeFile30(promptPath, nextPrompt, "utf-8");
@@ -278424,10 +279226,10 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
   if (!attachments || attachments.length === 0) {
     return { attachmentContents, imageContents };
   }
-  const { readFile: readFile54 } = await import("node:fs/promises");
-  const { join: join103 } = await import("node:path");
+  const { readFile: readFile55 } = await import("node:fs/promises");
+  const { join: join104 } = await import("node:path");
   for (const att of attachments) {
-    const filePath = join103(
+    const filePath = join104(
       rootDir,
       ".fusion",
       "tasks",
@@ -278437,7 +279239,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
     );
     try {
       if (IMAGE_MIME_TYPES.has(att.mimeType)) {
-        const data = await readFile54(filePath);
+        const data = await readFile55(filePath);
         const detectedMimeType = detectImageMimeFromBytes(data);
         const imageMimeType = detectedMimeType ?? att.mimeType;
         if (detectedMimeType && detectedMimeType !== att.mimeType) {
@@ -278454,7 +279256,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
           text: null
         });
       } else {
-        const data = await readFile54(filePath, "utf-8");
+        const data = await readFile55(filePath, "utf-8");
         const text2 = data.length > TEXT_INLINE_LIMIT ? data.slice(0, TEXT_INLINE_LIMIT) + "\n... (truncated at 50KB)" : data;
         attachmentContents.push({
           originalName: att.originalName,
@@ -282249,7 +283051,7 @@ function extractAdvisorAssistantText(session) {
 // ../engine/src/overseer/overseer-watchdog.ts
 init_logger();
 import { existsSync as existsSync88, readFileSync as readFileSync29 } from "node:fs";
-import { dirname as dirname44, join as join100, relative as relative23, resolve as resolve53, sep as sep15 } from "node:path";
+import { dirname as dirname44, join as join101, relative as relative23, resolve as resolve53, sep as sep15 } from "node:path";
 import { homedir as homedir13 } from "node:os";
 var log39 = createLogger("overseer-watchdog");
 var WATCHDOG_FILENAMES = ["OVERSEER.md", "WATCHDOG.md"];
@@ -282280,7 +283082,7 @@ function discoverOverseerWatchdogFiles(options) {
     };
     if (agentDir) {
       for (const name2 of WATCHDOG_FILENAMES) {
-        tryAdd(join100(agentDir, name2), "user", 999);
+        tryAdd(join101(agentDir, name2), "user", 999);
       }
     }
     let current = cwd;
@@ -282288,9 +283090,9 @@ function discoverOverseerWatchdogFiles(options) {
     for (let hop = 0; hop < 64; hop++) {
       const depth = relative23(cwd, current) === "" ? 0 : relative23(cwd, current).split(sep15).filter(Boolean).length;
       for (const name2 of WATCHDOG_FILENAMES) {
-        tryAdd(join100(current, name2), "project", depth);
-        tryAdd(join100(current, ".fusion", name2), "project", depth);
-        tryAdd(join100(current, ".omp", name2), "project", depth);
+        tryAdd(join101(current, name2), "project", depth);
+        tryAdd(join101(current, ".fusion", name2), "project", depth);
+        tryAdd(join101(current, ".omp", name2), "project", depth);
       }
       if (current === stopAt) break;
       const parent = dirname44(current);
@@ -283728,7 +284530,7 @@ import { promisify as promisify88 } from "node:util";
 import { realpathSync as realpathSync15, readdirSync as readdirSync15 } from "node:fs";
 import { mkdtemp as mkdtemp5 } from "node:fs/promises";
 import { tmpdir as tmpdir13 } from "node:os";
-import { join as join102 } from "node:path";
+import { join as join103 } from "node:path";
 init_workspace_base_branch();
 init_merger_ref_update_advance();
 
@@ -284199,7 +285001,7 @@ import { execFile as execFile40 } from "node:child_process";
 import { appendFileSync as appendFileSync2, existsSync as existsSync90, mkdirSync as mkdirSync13, readdirSync as readdirSync14, readFileSync as readFileSync31, realpathSync as realpathSync14, rmSync as rmSync9, statSync as statSync18 } from "node:fs";
 import { rm as rm19 } from "node:fs/promises";
 import { tmpdir as tmpdir12 } from "node:os";
-import { isAbsolute as isAbsolute27, join as join101, relative as relative24 } from "node:path";
+import { isAbsolute as isAbsolute27, join as join102, relative as relative24 } from "node:path";
 import { promisify as promisify87 } from "node:util";
 init_worktree_paths();
 init_worktree_removal_retry();
@@ -284230,7 +285032,7 @@ function isBenignAbsentWorktreeError(err) {
   return isBenignAbsentRemovalError(err);
 }
 function ensureAiMergeRootIgnored(projectRootDir, settings) {
-  const excludePath = join101(projectRootDir, ".git", "info", "exclude");
+  const excludePath = join102(projectRootDir, ".git", "info", "exclude");
   if (!existsSync90(excludePath)) return;
   try {
     const current = readFileSync31(excludePath, "utf-8");
@@ -284255,7 +285057,7 @@ function getAiMergeTempSearchRoots(projectRootDir, settings) {
   if (testWorkerRoot) {
     try {
       for (const entry of readdirSync14(testWorkerRoot)) {
-        if (entry.startsWith("redir-")) roots.push(join101(testWorkerRoot, entry));
+        if (entry.startsWith("redir-")) roots.push(join102(testWorkerRoot, entry));
       }
     } catch {
     }
@@ -284278,7 +285080,7 @@ async function pruneExistingAiMergeWorktrees(taskId, projectRootDir, audit, log4
       continue;
     }
     for (const entry of entries) {
-      const candidatePath = join101(tempRoot, entry);
+      const candidatePath = join102(tempRoot, entry);
       let canonicalPath = candidatePath;
       try {
         canonicalPath = realpathSync14(candidatePath);
@@ -284815,7 +285617,7 @@ function listAiMergeWorktreeCandidates(taskId, projectRootDir, settings) {
   if (testWorkerRoot) {
     try {
       for (const entry of readdirSync15(testWorkerRoot)) {
-        if (entry.startsWith("redir-")) roots.push(join102(testWorkerRoot, entry));
+        if (entry.startsWith("redir-")) roots.push(join103(testWorkerRoot, entry));
       }
     } catch {
     }
@@ -284828,7 +285630,7 @@ function listAiMergeWorktreeCandidates(taskId, projectRootDir, settings) {
     } catch {
       continue;
     }
-    for (const entry of entries) candidates.push(join102(root, entry));
+    for (const entry of entries) candidates.push(join103(root, entry));
   }
   return candidates;
 }
@@ -285265,7 +286067,7 @@ async function landOneRepo(repoRootDir, branch, integrationBranch, ctx) {
       registeredMergePaths.add(pathToRegister);
     };
     try {
-      mergeRoot = await mkdtemp5(join102(resolveAiMergeRoot(repoRootDir, settings), `fusion-ai-merge-${taskId.toLowerCase()}-`));
+      mergeRoot = await mkdtemp5(join103(resolveAiMergeRoot(repoRootDir, settings), `fusion-ai-merge-${taskId.toLowerCase()}-`));
       registerMergeRoot(mergeRoot);
       await git9(["worktree", "add", "--detach", mergeRoot, tipSha], repoRootDir);
       worktreeAdded = true;
@@ -286227,7 +287029,7 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
   for (const repoRel of repoKeys) {
     const entry = workspaceWorktrees[repoRel];
     if (!entry) throw new WorkspaceMergeTechnicalError("workspace-entry", `Workspace repository entry is missing for ${repoRel}`);
-    const repoRootDir = join102(workspaceRootDir, repoRel);
+    const repoRootDir = join103(workspaceRootDir, repoRel);
     try {
       const baseResolution = await resolveWorkspaceRepoBaseBranch({
         mode: "recorded",
@@ -286285,7 +287087,7 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
             handle: options.workspaceDispatchFence,
             claimOutcome: "reentrant",
             remote: target.remote,
-            cwd: join102(workspaceRootDir, repoRel),
+            cwd: join103(workspaceRootDir, repoRel),
             fenceRefName: mergeDispatchFenceRef(taskId)
           });
           options.workspaceDispatchFence = ensuredDispatchFence;
@@ -286316,7 +287118,7 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
     for (const repoRel of repoKeys) {
       throwIfAborted3(options.signal, taskId);
       const entry = workspaceWorktrees[repoRel];
-      const repoRootDir = join102(workspaceRootDir, repoRel);
+      const repoRootDir = join103(workspaceRootDir, repoRel);
       const workspaceTarget = workspaceTargets.get(repoRel);
       if (!workspaceTarget) throw new WorkspaceMergeTechnicalError("integration-target", `Workspace integration plan is missing for ${repoRel}`);
       const integrationBranch = workspaceTarget.integrationBranch;
@@ -286976,7 +287778,7 @@ async function pushAfterMergeToRemote(input) {
   let worktreeAdded = false;
   const registeredPaths = /* @__PURE__ */ new Set();
   try {
-    pushRoot = await mkdtemp5(join102(resolveAiMergeRoot(projectRootDir, settings), `fusion-ai-merge-push-${taskId.toLowerCase()}-`));
+    pushRoot = await mkdtemp5(join103(resolveAiMergeRoot(projectRootDir, settings), `fusion-ai-merge-push-${taskId.toLowerCase()}-`));
     for (const p2 of [pushRoot]) {
       activeSessionRegistry.registerPath(p2, { taskId, kind: "ai-merge", ownerKey: `ai-merge-push:${taskId}` });
       registeredPaths.add(p2);
@@ -290338,10 +291140,20 @@ ${detail}`);
           return false;
         }
         this.plannerLiveRetrySkipLogDedup.delete(`${task.id}::${decision.watchedStage ?? "executor"}`);
-        await moveTaskToContainedBackwardTarget(store, task.id, "self-healing-stranded-recovery", {
+        const recovery = await moveTaskToContainedBackwardTarget(store, task.id, "self-healing-stranded-recovery", {
           preserveProgress: true,
           moveSource: "engine"
         }, task.column);
+        if (!recovery.moved) {
+          if (!("reason" in recovery) || recovery.reason !== "in-place-recovery" || task.status !== "failed" || (await this.resolveTaskColumnFlags(store, task, /* @__PURE__ */ new Map()))?.countsTowardWip !== true) return false;
+          let resumed = false;
+          await store.updateTaskAtomic(task.id, (current) => {
+            if (current.column !== task.column || current.status !== "failed" || current.error !== task.error || current.updatedAt !== task.updatedAt || current.paused || current.userPaused || current.deletedAt || executor?.isTaskLiveForOverseerRetry?.(task.id) === true) return null;
+            resumed = true;
+            return { status: "queued", error: null, sessionFile: null };
+          });
+          if (!resumed) return false;
+        }
         await this.emitOverseerInterventionSafe(
           () => emitOverseerRetry({
             store,