@runfusion/fusion 0.74.0-beta.7 → 0.74.0-beta.9

package/dist/child-process-worker.js

@@ -865,6 +865,11 @@ var init_execution_and_ui = __esm({
       "dawn",
       // FNXC:DashboardTheming 2026-07-31-21:28: Sage must stay order-synchronized across core, selector metadata, and both first-paint validators so saved preferences survive pre-hydration validation.
       "sage",
+      /*
+      FNXC:MidnightTheme 2026-08-03-02:05:
+      Midnight is a persisted selectable dashboard theme. Keep its id and order synchronized with selector metadata and both web/Electron first-paint validators so saved choices survive before hydration, while shadcn-ember remains the unset default.
+      */
+      "midnight",
       // FNXC:DashboardTheming 2026-07-31-20:39: Factory Dark must stay order-synchronized across core, selector metadata, and both first-paint validators so saved preferences survive pre-hydration validation.
       "factory-dark",
       // FNXC:DashboardTheming 2026-07-31-23:51: Factory Light must stay order-synchronized across core, selector metadata, and both first-paint validators so saved preferences survive pre-hydration validation.
@@ -96696,15 +96701,20 @@ async function updateTaskUnlockedImpl(store, id, updates, runContext) {
       task.workspaceWorktrees = updates.workspaceWorktrees;
     }
     let movedToTriage = false;
+    let respecifyFromColumn;
+    let respecifyMoveLanes;
     if (updates.dependencies !== void 0) {
       const oldDeps = new Set((task.dependencies ?? []).map((dependency) => dependency.trim()).filter(Boolean));
       const normalizedDependencies = updates.dependencies.map((dependency) => dependency.trim()).filter(Boolean);
       const hasNewDeps = normalizedDependencies.some((d) => !oldDeps.has(d));
       task.dependencies = normalizedDependencies;
-      const depLanes = hasNewDeps ? await resolveTaskLifecycleColumns(store, id).catch(() => void 0) : void 0;
+      const respecifyIr = hasNewDeps ? await resolveWorkflowIrForTask(store, id).catch(() => void 0) : void 0;
+      respecifyMoveLanes = toTaskMoveLanes(respecifyIr);
+      const depLanes = respecifyIr ? resolveLifecycleColumns(respecifyIr) : void 0;
       const holdLane = depLanes === void 0 ? "todo" : depLanes.hold;
       if (hasNewDeps && holdLane !== void 0 && task.column === holdLane) {
         const intakeLane = depLanes?.intake;
+        respecifyFromColumn = task.column;
         const relocating = intakeLane !== void 0 && intakeLane !== task.column;
         if (relocating) {
           task.column = intakeLane;
@@ -97382,10 +97392,15 @@ async function updateTaskUnlockedImpl(store, id, updates, runContext) {
         storeLog.warn(`[task-detail] failed to sync PROMPT.md heading for ${task.id}: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
-    if (movedToTriage) {
-      const lanes = toTaskMoveLanes(await resolveWorkflowIrForTask(store, id).catch(() => void 0));
-      store.laneCache.set(task.id, lanes);
-      store.emit("task:moved", { task, from: "todo", to: "triage", source: "engine", lanes });
+    if (movedToTriage && respecifyFromColumn !== void 0 && respecifyFromColumn !== task.column && respecifyMoveLanes) {
+      store.laneCache.set(task.id, respecifyMoveLanes);
+      store.emit("task:moved", {
+        task,
+        from: respecifyFromColumn,
+        to: task.column,
+        source: "engine",
+        lanes: respecifyMoveLanes
+      });
     }
     store.emitTaskLifecycleEventSafely("task:updated", [task]);
     return task;
@@ -97397,7 +97412,6 @@ var init_task_update = __esm({
     init_store();
     init_workflow_lifecycle_traits();
     init_workflow_ir_resolver();
-    init_workflow_lifecycle_traits();
     init_errors3();
     init_task_fields();
     init_builtin_traits();
@@ -159300,7 +159314,11 @@ async function createFnAgent2(options) {
     }
   });
   attachSessionIdentity(promptableSession);
-  return { session: promptableSession, sessionFile: promptableSession.sessionFile };
+  return {
+    session: promptableSession,
+    sessionFile: promptableSession.sessionFile,
+    settleFallbackDispatch: async () => void 0
+  };
 }
 var execAsync10, RTK_ACCEPTED_REWRITE_EXIT_CODES, RTK_EXPECTED_PASSTHROUGH_EXIT_CODES, RTK_EXPECTED_FAIL_OPEN_ERROR_CODES, RTK_REWRITE_MAX_BUFFER_BYTES, hostExtensionPaths, FN_MEMORY_APPEND_TOOL_NAME, FUSION_SHUTDOWN_WRAP_FLAG, promptWithFallbackInFlight, COMPACTION_FALLBACK_INSTRUCTIONS, MAX_COMPACTED_PROMPT_MEMORY_CHARS, MAX_COMPACTED_SUBTASK_GUIDANCE_CHARS, MAX_COMPACTED_ATTACHMENTS_CHARS, MAX_COMPACTED_EXISTING_SPEC_CHARS, MAX_COMPACTED_TASK_PROMPT_CHARS, MAX_COMPACTED_USER_COMMENTS_CHARS, ModelFallbackExhaustedError, GATE_BYPASS_TOOL_NAMES, TOOL_OUTPUT_BUDGET_OVERRIDES;
 var init_pi = __esm({
@@ -159424,7 +159442,8 @@ function wrapPluginRuntime(instance, runtimeId, runtimeName) {
         const result = await adapter.createSession(options);
         return {
           session: result.session ?? result,
-          sessionFile: result.sessionFile
+          sessionFile: result.sessionFile,
+          settleFallbackDispatch: result.settleFallbackDispatch
         };
       }
       throw new Error(`Plugin runtime "${runtimeId}" does not implement createSession`);
@@ -159533,11 +159552,15 @@ var init_runtime_resolution = __esm({
       name = "Default PI Runtime";
       async createSession(options) {
         const { toolOutputMaxChars, mcpServers, ...agentOptions } = options;
-        return createFnAgent2({
+        const result = await createFnAgent2({
           ...agentOptions,
           toolOutputMaxChars,
           mcpServers: normalizeAgentRuntimeMcpServers(mcpServers)
         });
+        return {
+          ...result,
+          settleFallbackDispatch: result.settleFallbackDispatch ?? (async () => void 0)
+        };
       }
       async promptWithFallback(session, prompt, options) {
         return promptWithFallback(session, prompt, options);
@@ -160404,6 +160427,7 @@ async function createResolvedAgentSession(options) {
   return {
     session: result.session,
     sessionFile: result.sessionFile,
+    settleFallbackDispatch: result.settleFallbackDispatch,
     runtimeId: resolved.runtimeId,
     wasConfigured: resolved.wasConfigured
   };
@@ -190840,6 +190864,25 @@ var Scheduler = class {
           });
         }
       }
+      if (from === parked.wip && to2 === parked.hold) {
+        if (source === "engine") {
+          this.recentEngineTodoRequeues.set(task.id, task.columnMovedAt ?? (/* @__PURE__ */ new Date()).toISOString());
+        } else {
+          this.recentEngineTodoRequeues.delete(task.id);
+        }
+      } else if (to2 === parked.review || parked.terminal.has(to2)) {
+        this.recentEngineTodoRequeues.delete(task.id);
+        if (task.dispatchStormCount != null || task.lastDispatchAt != null || task.executeRequeueLoopCount != null || task.executeRequeueLoopSignature != null) {
+          void this.store.updateTask(task.id, {
+            dispatchStormCount: null,
+            lastDispatchAt: null,
+            executeRequeueLoopCount: null,
+            executeRequeueLoopSignature: null
+          }).catch((error2) => {
+            schedulerLog.warn(`Failed to reset dispatch oscillation state for ${task.id} on move to ${to2}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+          });
+        }
+      }
       const resolvedParked = mergeParkedColumns(await resolveTaskParkedColumns(this.store, task.id), lanes);
       if (resolvedParked.terminal.has(to2)) {
         try {
@@ -190900,25 +190943,6 @@ var Scheduler = class {
           schedulerLog.error(`Failed event-driven blocker reconciliation for ${task.id}`, error2);
         }
       }
-      if (from === resolvedParked.wip && to2 === resolvedParked.hold) {
-        if (source === "engine") {
-          this.recentEngineTodoRequeues.set(task.id, task.columnMovedAt ?? (/* @__PURE__ */ new Date()).toISOString());
-        } else {
-          this.recentEngineTodoRequeues.delete(task.id);
-        }
-      } else if (to2 === resolvedParked.review || resolvedParked.terminal.has(to2)) {
-        this.recentEngineTodoRequeues.delete(task.id);
-        if (task.dispatchStormCount != null || task.lastDispatchAt != null || task.executeRequeueLoopCount != null || task.executeRequeueLoopSignature != null) {
-          void this.store.updateTask(task.id, {
-            dispatchStormCount: null,
-            lastDispatchAt: null,
-            executeRequeueLoopCount: null,
-            executeRequeueLoopSignature: null
-          }).catch((error2) => {
-            schedulerLog.warn(`Failed to reset dispatch oscillation state for ${task.id} on move to ${to2}: ${error2 instanceof Error ? error2.message : String(error2)}`);
-          });
-        }
-      }
       if (resolvedParked.terminal.has(to2) || to2 === resolvedParked.hold) {
         schedulerLog.log(`Task moved to ${to2} \u2014 triggering scheduling`);
         this.schedule();
@@ -192692,110 +192716,40 @@ init_src2();
 
 // ../engine/src/execution-block-classifier.ts
 var TASK_ID_RE = /^[A-Z][A-Z0-9]*-\d+$/i;
-var PR_REF_RE = /^(?:pr[:#-]|#|PR-)(\d+)$/i;
-var PR_IN_TEXT_RE = /\bPR\s*#?\s*(\d+)\b/gi;
-var CLAIM_REASON_RE = /check-file-claimed|actively claimed|file[- ]claim|claimed by (?:open )?pr|open pr\s*#?\s*\d+|collision policy|claimed paths?|file claims?/i;
+var LEGACY_PR_REF_RE = /^(?:pr[:#-]|#|PR-)(\d+)$/i;
 function partitionBlockedByRefs(blockedBy) {
   const taskIds = [];
-  const prNumbers = [];
   for (const raw of blockedBy) {
     const id = raw.trim();
     if (!id) continue;
-    const prMatch = id.match(PR_REF_RE);
-    if (prMatch) {
-      prNumbers.push(Number(prMatch[1]));
-      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());
-      continue;
     }
   }
-  return {
-    taskIds: [...new Set(taskIds)],
-    prNumbers: [...new Set(prNumbers.filter((n) => Number.isFinite(n) && n > 0))]
-  };
+  return { taskIds: [...new Set(taskIds)] };
 }
-function extractPrNumbersFromText(text2) {
-  const found = [];
-  for (const match of text2.matchAll(PR_IN_TEXT_RE)) {
-    const n = Number(match[1]);
-    if (Number.isFinite(n) && n > 0) found.push(n);
-  }
-  return [...new Set(found)];
-}
-function isFileClaimBlockedReason(reason) {
-  return CLAIM_REASON_RE.test(reason);
-}
-function classifyBlockedExit(reason, blockedBy = []) {
-  const trimmed = reason.trim();
-  const partitioned = partitionBlockedByRefs(blockedBy);
-  const prFromText = extractPrNumbersFromText(trimmed);
-  const prNumbers = [.../* @__PURE__ */ new Set([...partitioned.prNumbers, ...prFromText])];
-  const isClaim = isFileClaimBlockedReason(trimmed) || prNumbers.length > 0 && /claim/i.test(trimmed);
-  if (isClaim || prNumbers.length > 0 && isFileClaimBlockedReason(trimmed)) {
-    const externalBlockers = [
-      ...prNumbers.map((number4) => ({ kind: "github-pr", number: number4 }))
-    ];
-    if (externalBlockers.length === 0 && isClaim) {
-      externalBlockers.push({
-        kind: "file-claim",
-        prNumber: prNumbers[0]
-      });
-    } else if (isClaim) {
-      for (const n of prNumbers) {
-        if (!externalBlockers.some((b3) => b3.kind === "github-pr" && b3.number === n)) {
-          externalBlockers.push({ kind: "github-pr", number: n });
-        }
-      }
-      if (prNumbers.length === 0) {
-        externalBlockers.push({ kind: "file-claim" });
-      }
-    }
-    const thrashSignature = [
-      "file-claim",
-      ...prNumbers.map((n) => `pr:${n}`).sort(),
-      ...partitioned.taskIds.slice().sort()
-    ].join("|");
-    return {
-      allowAutoReplan: false,
-      class: "file-claim",
-      externalBlockers,
-      thrashSignature: thrashSignature || "file-claim",
-      prNumbers
-    };
-  }
-  if (partitioned.taskIds.length > 0) {
-    return {
-      allowAutoReplan: false,
-      class: "external",
-      externalBlockers: [],
-      thrashSignature: `tasks:${partitioned.taskIds.slice().sort().join(",")}`,
-      prNumbers
-    };
-  }
-  if (prNumbers.length > 0) {
+function classifyBlockedExit(_reason, blockedBy = []) {
+  const { taskIds } = partitionBlockedByRefs(blockedBy);
+  if (taskIds.length > 0) {
     return {
       allowAutoReplan: false,
       class: "external",
-      externalBlockers: prNumbers.map((number4) => ({ kind: "github-pr", number: number4 })),
-      thrashSignature: prNumbers.map((n) => `pr:${n}`).sort().join("|"),
-      prNumbers
+      thrashSignature: `tasks:${taskIds.slice().sort().join(",")}`
     };
   }
   return {
     allowAutoReplan: true,
     class: "plan-defect",
-    externalBlockers: [],
-    thrashSignature: "plan-defect",
-    prNumbers: []
+    thrashSignature: "plan-defect"
   };
 }
 var BLOCKED_THRASH_LIMIT = 3;
 var BLOCKED_THRASH_WINDOW_MS = 60 * 60 * 1e3;
 function countBlockedThrashHits(log41, signature, nowMs = Date.now(), windowMs = BLOCKED_THRASH_WINDOW_MS) {
   if (!log41?.length) return 0;
+  if (signature === "plan-defect") return 0;
   const cutoff = nowMs - windowMs;
   let count2 = 0;
   for (const entry of log41) {
@@ -192807,18 +192761,7 @@ function countBlockedThrashHits(log41, signature, nowMs = Date.now(), windowMs =
         continue;
       }
     }
-    if (signature === "plan-defect") continue;
-    if (signature.includes("file-claim") || signature.startsWith("pr:") || signature.includes("|pr:")) {
-      if (isFileClaimBlockedReason(action) || /PR\s*#?\s*\d+/i.test(action) || action.includes("durable external block")) {
-        count2 += 1;
-        continue;
-      }
-    }
     for (const part of signature.split("|")) {
-      if (part.startsWith("pr:") && action.includes(`PR #${part.slice(3)}`)) {
-        count2 += 1;
-        break;
-      }
       if (part.startsWith("tasks:") && part.slice(6).split(",").some((id) => id && action.includes(id))) {
         count2 += 1;
         break;
@@ -192827,28 +192770,18 @@ function countBlockedThrashHits(log41, signature, nowMs = Date.now(), windowMs =
   }
   return count2;
 }
-function isDurableBlockedError(error2) {
-  if (!error2?.startsWith("BLOCKED:")) return false;
-  const reason = error2.slice("BLOCKED:".length).trim();
-  const classification = classifyBlockedExit(reason, []);
-  return !classification.allowAutoReplan;
-}
 function isDurableBlockedTask(task) {
-  if (task.status === "failed" && isDurableBlockedError(task.error)) return true;
   const meta2 = task.sourceMetadata;
   if (!meta2 || typeof meta2 !== "object") return false;
-  if (meta2.blockedClass === "file-claim" || meta2.blockedClass === "external") {
-    if (task.status === "failed" || task.status === "needs-replan") return true;
-  }
-  const blockers = meta2.externalBlockers;
-  return Array.isArray(blockers) && blockers.length > 0 && task.status === "failed";
+  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: classification.externalBlockers
+    externalBlockers: []
   };
 }
 
@@ -208426,7 +208359,6 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
           { name: "reconcile-done-task-integrity", fn: () => this.reconcileDoneTaskIntegrity() },
           { name: "reconcile-stale-merger-status", fn: () => this.reconcileStaleMergerStatus() },
           { name: "reconcile-stale-duplicate-decision", fn: () => this.reconcileStaleDuplicateDecisionPause() },
-          { name: "reconcile-external-pr-blockers", fn: () => this.reconcileExternalPrBlockers() },
           // FNXC:OrphanedPendingSteps 2026-07-22-16:35 (FN-8492 review follow-up): also
           // steady-state — a step session can die without an engine restart, and startup-only
           // cadence left that case riding the 3×30-min stall escalator to a deadlock park.
@@ -209930,6 +209862,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
   }
   async reclaimStaleActiveBranches() {
     const reclaimArchivedColumns = await resolveProjectColumnsForRoles(this.store, ["archived"]);
+    const reclaimCompleteColumns = await resolveProjectColumnsForRoles(this.store, ["complete"]);
     try {
       const settings = await this.store.getSettings();
       if (settings.globalPause || settings.enginePaused) return 0;
@@ -210027,10 +209960,12 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
         if (task.worktree && await isUsableTaskWorktree(this.options.rootDir, task.worktree)) continue;
         const inspection = await this.inspectOrphanedBranch(branch);
         if (!inspection) continue;
-        if (inspection.uniqueCommitCount > 0) {
+        const isCompleteColumn2 = reclaimCompleteColumns.has(task.column);
+        if (inspection.uniqueCommitCount > 0 && !isCompleteColumn2) {
           log34.warn(`[recovery] stale-active-branch-rescue-needed ${task.id} branch=${branch} unique=${inspection.uniqueCommitCount} tip=${inspection.tipSha.slice(0, 12)}`);
           continue;
         }
+        const reclaimReason = inspection.uniqueCommitCount > 0 ? "complete-column-unique-commits-force" : "zero-unique-commits-no-worktree";
         await execAsync33(`git branch -D ${JSON.stringify(branch)}`, {
           cwd: this.options.rootDir,
           timeout: 12e4,
@@ -210048,7 +209983,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
         });
         await this.store.logEntry(
           task.id,
-          `[recovery] stale-active-branch-reclaim ${task.id} branch=${branch} reason=zero-unique-commits-no-worktree`
+          `[recovery] stale-active-branch-reclaim ${task.id} branch=${branch} reason=${reclaimReason}`
         );
         try {
           const auditor = createRunAuditor(this.store, {
@@ -210066,7 +210001,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
               branch,
               tipSha: inspection.tipSha,
               uniqueCommitCount: inspection.uniqueCommitCount,
-              reason: "zero-unique-commits-no-worktree"
+              reason: reclaimReason
             }
           });
         } catch (auditErr) {
@@ -210113,10 +210048,9 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
     const baseBranch = task.baseBranch || await resolveIntegrationBranch(this.options.rootDir, void 0);
     const comparison = await listUniqueBranchCommits(this.options.rootDir, baseBranch, branchName);
     if (comparison.commits.length > 0) {
-      log34.warn(
-        `[self-healing] reconcileCompletedTask ${task.id}: branch ${branchName} has ${comparison.commits.length} unique commit(s) vs ${comparison.mainRef}; skip deletion`
+      log34.log(
+        `[self-healing] reconcileCompletedTask ${task.id}: branch ${branchName} has ${comparison.commits.length} unique commit(s) vs ${comparison.mainRef}; force-deleting post-completion (squash-safe)`
       );
-      return false;
     }
     try {
       await execAsync33(`git branch -D ${shellQuote2(branchName)}`, {
@@ -217323,71 +217257,12 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
     }
   }
   /*
-  FNXC:HonestBlockedExit 2026-08-02-01:30:
-  Durable parks store github-pr externalBlockers (FN-8700 file-claim). When every blocking
-  PR is MERGED or CLOSED, clear the failed park so the scheduler can re-dispatch. Fail-soft
-  when gh is unavailable — leave the park for the operator.
+  FNXC:HonestBlockedExit 2026-08-02-23:59 (operator decision — FN-8728 vs PR #2398):
+  The FN-8700 `reconcile-external-pr-blockers` sweep (gh-backed clearing of PR-claim parks)
+  is REMOVED with the whole PR/file-claim blocking mechanism. Open PRs are never blockers;
+  file-scope conflicts are arbitrated only by Fusion's own board. Legacy PR-claim parks are
+  no longer honored by isDurableBlockedTask, so normal recovery paths reclaim them.
   */
-  async reconcileExternalPrBlockers() {
-    try {
-      if (!await isGhAvailable()) {
-        log34.debug("reconcile-external-pr-blockers skipped \u2014 gh unavailable");
-        return 0;
-      }
-      const tasks2 = await this.store.listTasks({ slim: true, includeArchived: false, limit: 500 });
-      let cleared = 0;
-      for (const task of tasks2.slice(0, 80)) {
-        if (task.status !== "failed" || !task.error?.startsWith("BLOCKED:")) continue;
-        const meta2 = task.sourceMetadata;
-        const blockers = meta2?.externalBlockers;
-        if (!Array.isArray(blockers) || blockers.length === 0) continue;
-        const prNumbers = blockers.map((b3) => b3 && typeof b3 === "object" && b3.kind === "github-pr" ? Number(b3.number) : NaN).filter((n) => Number.isFinite(n) && n > 0);
-        if (prNumbers.length === 0) continue;
-        let allResolved = true;
-        for (const n of prNumbers) {
-          try {
-            const pr2 = await runGhJsonAsync(
-              ["pr", "view", String(n), "--json", "state,mergedAt"],
-              { timeoutMs: 15e3 }
-            );
-            const state = String(pr2?.state ?? "").toUpperCase();
-            const merged = Boolean(pr2?.mergedAt) || state === "MERGED";
-            const closed = state === "CLOSED" || state === "MERGED";
-            if (!merged && !closed) {
-              allResolved = false;
-              break;
-            }
-          } catch {
-            allResolved = false;
-            break;
-          }
-        }
-        if (!allResolved) continue;
-        await this.store.updateTask(task.id, {
-          status: null,
-          error: null,
-          sourceMetadataPatch: {
-            externalBlockers: [],
-            blockedClass: null,
-            blockedThrashSignature: null,
-            blockedThrashCount: null,
-            externalPrBlockersClearedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            externalPrBlockersCleared: prNumbers
-          }
-        });
-        await this.store.logEntry(
-          task.id,
-          `Auto-recovered: external PR blocker(s) ${prNumbers.map((n) => `#${n}`).join(", ")} merged/closed \u2014 cleared durable BLOCKED park for re-dispatch`
-        );
-        log34.log(`Cleared durable PR block for ${task.id} (prs=${prNumbers.join(",")})`);
-        cleared += 1;
-      }
-      return cleared;
-    } catch (error2) {
-      log34.warn(`reconcile-external-pr-blockers failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
-      return 0;
-    }
-  }
   async resolveExplicitDuplicateMarkerTasks() {
     try {
       const settings = await this.store.getSettings();
@@ -219772,7 +219647,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 (an upstream API break, a missing prerequisite task, an unresolvable external error, or a **file claim / open PR collision**), call \`fn_task_done(outcome="blocked", reason="<concrete blocker + what would unblock it>", blockedBy=["FN-XXXX"] or ["pr:2398"])\`. File-claim reasons must name the PR (e.g. "actively claimed by PR #2398" + \`blockedBy:["pr:2398"]\`). That parks durable failed WITHOUT auto-replan so the engine does not thrash; task IDs requeue when those tasks complete; PR refs clear when the PR merges/closes. Do NOT skip remaining steps to fake completion.
+**Cannot proceed \u2014 the honest blocked exit.** If the work genuinely cannot be finished (an upstream API break, a missing prerequisite task, or an unresolvable external error), call \`fn_task_done(outcome="blocked", reason="<concrete blocker + what would unblock it>", blockedBy=["FN-XXXX"])\`. That parks durable failed WITHOUT auto-replan so the engine does not thrash; task IDs 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.
 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
@@ -227231,75 +227106,16 @@ Graph value: ${failureValue}` : ""}`, budget.key),
       );
     }
   }
-  /*
-  FNXC:HonestBlockedExit 2026-08-02-01:30:
-  Agents often log `BLOCKED: … actively claimed by PR #N` without calling fn_task_done.
-  Without promotion, incomplete-step graph resume requeues the card and thrash restarts
-  (FN-8700). Promote claim/external blocks to a durable failed park here.
-  */
-  async parkDurableBlockedFromRecentLog(live) {
-    const recent = [...live.log ?? []].reverse().find((entry) => {
-      const action = entry.action ?? "";
-      return action.startsWith("BLOCKED:") || action.includes("durable external block");
-    });
-    if (!recent?.action) return false;
-    const reason = recent.action.startsWith("BLOCKED:") ? recent.action.slice("BLOCKED:".length).trim() : recent.action;
-    const classification = classifyBlockedExit(reason, []);
-    if (classification.allowAutoReplan) return false;
-    const thrashCount = countBlockedThrashHits(live.log, classification.thrashSignature) + 1;
-    const thrashExhausted = thrashCount >= BLOCKED_THRASH_LIMIT;
-    const parkError = thrashExhausted ? `BLOCKED: ${reason} [thrash-exhausted after ${thrashCount} identical durable blocks]` : `BLOCKED: ${reason}`;
-    const metaPatch = buildExternalBlockMetadataPatch(classification, thrashCount);
-    await this.store.updateTask(live.id, {
-      status: "failed",
-      error: parkError,
-      paused: false,
-      pausedByAgentId: null,
-      sourceMetadataPatch: metaPatch
-    }, this.getRunContextFor(live.id));
-    await this.store.logEntry(
-      live.id,
-      thrashExhausted ? `${parkError} \u2014 promoted from session log; thrash-exhausted, no auto-requeue` : `${parkError} \u2014 promoted from session log to durable external block park (class=${classification.class})`,
-      void 0,
-      this.getRunContextFor(live.id)
-    );
-    await this.store.recordRunAuditEvent?.({
-      taskId: live.id,
-      agentId: "executor",
-      runId: generateSyntheticRunId("execution-blocked-log-promote", live.id),
-      domain: "database",
-      mutationType: "task:execution-blocked-parked",
-      target: live.id,
-      metadata: {
-        taskId: live.id,
-        blockedBy: [],
-        hasReason: true,
-        parkedAs: "failed",
-        blockedClass: classification.class,
-        thrashCount,
-        thrashExhausted,
-        prNumbers: classification.prNumbers,
-        source: "session-log-promote"
-      }
-    });
-    executorLog.warn(
-      `${live.id}: promoted durable BLOCKED from session log (class=${classification.class}; thrash=${thrashCount})`
-    );
-    return true;
-  }
   async routeGraphFailureToExecutionResume(live, failedNode, failureValue, resumeLanesMemo) {
     if (live.deletedAt) return false;
     if (live.paused || live.userPaused === true) return false;
     if ((await resolveTerminalColumnsFor(this.store, live.id)).includes(live.column)) return false;
-    if (isDurableBlockedTask(live) || isDurableBlockedError(live.error)) {
+    if (isDurableBlockedTask(live)) {
       executorLog.log(
-        `${live.id}: graph failure resume skipped \u2014 durable BLOCKED park honored (class from error/metadata)`
+        `${live.id}: graph failure resume skipped \u2014 durable BLOCKED park honored (task-dependency block)`
       );
       return false;
     }
-    if (await this.parkDurableBlockedFromRecentLog(live)) {
-      return false;
-    }
     if (failedNode === COMPLETION_SUMMARY_NODE_ID) return false;
     const incompleteSteps = hasNonTerminalWorkflowSteps(live);
     const implementationIncompleteMergeFailure = this.isMergeGraphFailure(failedNode) && failureValue === "implementation-incomplete";
@@ -231046,10 +230862,10 @@ ${summary}`,
           { description: '"completed" (default) finishes the task; "blocked" honestly parks it as failed because the work cannot proceed. Use "blocked" instead of skipping steps + completing when you are stuck.' }
         )),
         blockedBy: Type6.Optional(Type6.Array(Type6.String(), {
-          description: 'When outcome="blocked": task IDs (e.g. ["FN-8145"]) and/or PR refs (e.g. ["pr:2398"]) that must clear before this task can proceed. Task IDs become real dependency edges; PR refs are stored as external blockers (durable park until the PR merges/closes).'
+          description: 'When outcome="blocked": Fusion task IDs (e.g. ["FN-8145"]) that must complete before this task can proceed. Task IDs become real dependency edges. Open GitHub PRs are not valid blockers.'
         })),
         reason: Type6.Optional(Type6.String({
-          description: 'Required when outcome="blocked": concrete explanation of what is blocking the work and what is needed to unblock it. File-claim / open-PR collisions should name the PR (e.g. "actively claimed by PR #2398").'
+          description: 'Required when outcome="blocked": concrete explanation of what is blocking the work and what is needed to unblock it.'
         }))
       }),
       execute: async (_id, params) => {
@@ -231108,7 +230924,7 @@ ${summary}`,
             }, this.getRunContextFor(taskId));
             await store.logEntry(
               taskId,
-              thrashExhausted ? `${parkError} \u2014 durable external block thrash-exhausted (signature=${classification.thrashSignature}); parked failed, no auto-requeue` : classification.externalBlockers.length > 0 ? `${parkError} \u2014 durable external block (${classification.class}; pr=${classification.prNumbers.join(",") || "none"}; tasks=${blockedByIds.join(",") || "none"}) \u2014 parked failed (honest blocked exit; steps preserved)` : `${parkError} \u2014 recorded dependencies: ${blockedByIds.join(", ")} \u2014 parked failed (honest blocked exit; steps preserved)`,
+              thrashExhausted ? `${parkError} \u2014 durable external block thrash-exhausted (signature=${classification.thrashSignature}); parked failed, no auto-requeue` : `${parkError} \u2014 recorded dependencies: ${blockedByIds.join(", ")} \u2014 parked failed (honest blocked exit; steps preserved)`,
               void 0,
               this.getRunContextFor(taskId)
             );
@@ -231127,18 +230943,17 @@ ${summary}`,
               parkedAs: autoReplanPark ? "auto-replan" : "failed",
               blockedClass: classification.class,
               thrashCount,
-              thrashExhausted,
-              prNumbers: classification.prNumbers
+              thrashExhausted
             }
           });
           await this.persistTokenUsage(taskId);
           executorLog.log(
-            `\u26D4 ${taskId} ${autoReplanPark ? "parked for automatic replan via blocked exit (plan defect, no dependencies)" : thrashExhausted ? `parked failed via blocked thrash-exhaustion (class=${classification.class})` : `parked failed via durable blocked exit (class=${classification.class}; blockedBy tasks: ${blockedByIds.join(", ") || "none"}; pr: ${classification.prNumbers.join(",") || "none"})`}`
+            `\u26D4 ${taskId} ${autoReplanPark ? "parked for automatic replan via blocked exit (plan defect, no dependencies)" : thrashExhausted ? `parked failed via blocked thrash-exhaustion (class=${classification.class})` : `parked failed via durable blocked exit (class=${classification.class}; blockedBy tasks: ${blockedByIds.join(", ") || "none"})`}`
           );
           return {
             content: [{
               type: "text",
-              text: autoReplanPark ? "Task parked as blocked with no external/file-claim blocker \u2014 queued for automatic replan so the plan can resolve the conflict. Steps left in their true statuses; no completion recorded." : thrashExhausted ? "Task parked as blocked (failed) after repeated identical durable blocks \u2014 no further automatic retries. Resolve the external claim/PR or replan manually." : blockedByIds.length > 0 ? `Task parked as blocked (failed). Recorded ${blockedByIds.length} blocking task dependency(ies); it will requeue once they complete. Steps left in their true statuses; no completion recorded.` : classification.prNumbers.length > 0 ? `Task parked as blocked (failed) on open PR #${classification.prNumbers.join(", #")}. It will not auto-replan or re-execute until that claim clears or an operator retries. Steps preserved.` : "Task parked as blocked (failed) on a durable external/file-claim blocker. No automatic replan. Steps preserved."
+              text: autoReplanPark ? "Task parked as blocked with no blocking task dependencies \u2014 queued for automatic replan so the plan can resolve the conflict. Steps left in their true statuses; no completion recorded." : thrashExhausted ? "Task parked as blocked (failed) after repeated identical durable blocks \u2014 no further automatic retries. Resolve the blocking tasks or replan manually." : `Task parked as blocked (failed). Recorded ${blockedByIds.length} blocking task dependency(ies); it will requeue once they complete. Steps left in their true statuses; no completion recorded.`
             }],
             details: {}
           };
@@ -243299,6 +243114,7 @@ init_transient_error_detector();
 init_rate_limit_retry();
 init_agent_tools();
 import { exec as exec42 } from "node:child_process";
+import { existsSync as existsSync67 } from "node:fs";
 import { readFile as readFile40, writeFile as writeFile29, rm as rm12 } from "node:fs/promises";
 import { join as join78 } from "node:path";
 import { promisify as promisify57 } from "node:util";
@@ -243600,6 +243416,8 @@ var TriageProcessor = class _TriageProcessor {
   unregisterAdmissionProvider = null;
   /** Timestamps when tasks entered the `processing` set, for staleness detection. */
   processingSince = /* @__PURE__ */ new Map();
+  /** Monotonic provenance token for attempt-local planner fallback observation. */
+  planningAttemptSequence = 0;
   wasGlobalPaused = false;
   wasEnginePaused = false;
   idleSemaphoreLeakCandidateSince = null;
@@ -244895,7 +244713,28 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
           }
           await this.store.logEntry(task.id, `Planning session running in task worktree ${planningCwd}`).catch(() => void 0);
         }
-        const { session } = await createResolvedAgentSession({
+        const authoritativePromptPath = join78(this.rootDir, promptPath);
+        const planningAttemptBaseline = existsSync67(authoritativePromptPath) ? await readFile40(authoritativePromptPath, "utf-8").catch(() => void 0) : void 0;
+        const planningAttempt = {
+          id: `${task.id}:${++this.planningAttemptSequence}`,
+          baseline: planningAttemptBaseline,
+          fallbackEngaged: false,
+          fallbackSettlements: []
+        };
+        const fallbackObserver = createFallbackModelObserver({
+          agent: "triage",
+          label: "triage",
+          store: this.store,
+          taskId: task.id,
+          taskTitle: task.title
+        });
+        const onFallbackModelUsed = (payload) => {
+          planningAttempt.fallbackEngaged = true;
+          const settlement = Promise.resolve(fallbackObserver(payload));
+          planningAttempt.fallbackSettlements.push(settlement);
+          return settlement;
+        };
+        const { session, settleFallbackDispatch, runtimeId } = await createResolvedAgentSession({
           sessionPurpose: "triage",
           runtimeHint: triageRuntimeHint,
           pluginRunner: this.options.pluginRunner,
@@ -244934,13 +244773,7 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
           taskTitle: task.title,
           actionGateContext: this.buildActionGateContext(task.id, triageRunContext.runId, assignedAgent, settings.defaultAgentPermissionPolicy),
           permanentAgentGating: this.buildPermanentAgentGatingContext(task.id, triageRunContext.runId, assignedAgent, settings.defaultAgentPermissionPolicy),
-          onFallbackModelUsed: createFallbackModelObserver({
-            agent: "triage",
-            label: "triage",
-            store: this.store,
-            taskId: task.id,
-            taskTitle: task.title
-          })
+          onFallbackModelUsed
         });
         const modelDesc = formatModelMarkerDetails(describeModel(session), resolvePlanningThinkingLevel(settings, task.planningThinkingLevel ?? task.thinkingLevel));
         planLog.debug(`${task.id}: using model ${modelDesc}`);
@@ -245010,6 +244843,10 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
             agentPrompt,
             imageContents.length > 0 ? { images: imageContents } : void 0
           );
+          const fallbackDispatchBoundaryMissing = typeof settleFallbackDispatch !== "function";
+          if (!fallbackDispatchBoundaryMissing) {
+            await settleFallbackDispatch();
+          }
           checkSessionError(session);
           if (this.pauseAborted.has(task.id)) {
             this.pauseAborted.delete(task.id);
@@ -245102,12 +244939,42 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
               }
             }
           }
-          const duplicateReport = { outcome: "parked" };
-          if (await this.tryFinalizeExplicitDuplicateMarker(task, written, settings, {
-            isReplan,
-            feedback
-          }, duplicateReport)) {
-            this.options.onSpecifyComplete?.(task, duplicateReport);
+          let settledFallbackCount = 0;
+          while (settledFallbackCount < planningAttempt.fallbackSettlements.length) {
+            const pendingSettlements = planningAttempt.fallbackSettlements.slice(settledFallbackCount);
+            settledFallbackCount = planningAttempt.fallbackSettlements.length;
+            await Promise.all(pendingSettlements);
+          }
+          const artifactChangedByAttempt = planningAttempt.baseline !== written;
+          if (fallbackDispatchBoundaryMissing || planningAttempt.fallbackEngaged || !artifactChangedByAttempt) {
+            const failure = fallbackDispatchBoundaryMissing ? `Planner runtime ${runtimeId} did not provide a fallback-dispatch settlement boundary for attempt ${planningAttempt.id}` : planningAttempt.fallbackEngaged ? `Planner fallback engaged during attempt ${planningAttempt.id}` : `Planner did not update the authoritative PROMPT.md during attempt ${planningAttempt.id}`;
+            const decision = computeRecoveryDecision({
+              recoveryRetryCount: task.recoveryRetryCount,
+              nextRecoveryAt: task.nextRecoveryAt
+            });
+            if (decision.shouldRetry) {
+              const retryMessage = `${failure} \u2014 retry ${decision.nextState.recoveryRetryCount}/${MAX_RECOVERY_RETRIES} in ${formatDelay(decision.delayMs)}.`;
+              planLog.warn(`${task.id} ${retryMessage}`);
+              await this.store.logEntry(task.id, retryMessage);
+              await this.updatePlanningStateIfStillCurrent(task, {
+                status: this.restoreStatusAfterInterruptedTriageWork(task),
+                error: null,
+                recoveryRetryCount: decision.nextState.recoveryRetryCount,
+                nextRecoveryAt: decision.nextState.nextRecoveryAt
+              });
+              return;
+            }
+            const failureMessage = `${failure} after ${MAX_RECOVERY_RETRIES} retries. Retry after adjusting the task prompt or model.`;
+            planLog.error(`${task.id} clean planning attempt retry budget exhausted`);
+            await this.store.logEntry(task.id, failureMessage);
+            if (await this.updatePlanningStateIfStillCurrent(task, {
+              status: "failed",
+              error: failureMessage,
+              recoveryRetryCount: null,
+              nextRecoveryAt: null
+            })) {
+              await this.backfillBlankTitleAfterTerminalTriageFailure(task);
+            }
             return;
           }
           const deterministicSpecFailure = await this.validateGeneratedPrompt(task.id, written);
@@ -245149,6 +245016,21 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
             }
             return;
           }
+          const duplicateReport = { outcome: "parked" };
+          if (await this.tryFinalizeExplicitDuplicateMarker(task, written, settings, {
+            isReplan,
+            feedback
+          }, duplicateReport)) {
+            this.options.onSpecifyComplete?.(task, duplicateReport);
+            return;
+          }
+          if (task.recoveryRetryCount != null || task.nextRecoveryAt != null) {
+            await this.updatePlanningStateIfStillCurrent(task, {
+              error: null,
+              recoveryRetryCount: null,
+              nextRecoveryAt: null
+            });
+          }
           const finalizeReport = await this.finalizeApprovedTask(task, written, settings, {
             isReplan,
             feedback
@@ -249882,14 +249764,14 @@ function extractAdvisorAssistantText(session) {
 
 // ../engine/src/overseer-watchdog.ts
 init_logger();
-import { existsSync as existsSync67, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync68, readFileSync as readFileSync24 } from "node:fs";
 import { dirname as dirname34, join as join79, relative as relative17, resolve as resolve40, sep as sep11 } from "node:path";
 import { homedir as homedir12 } from "node:os";
 var log38 = createLogger("overseer-watchdog");
 var WATCHDOG_FILENAMES = ["OVERSEER.md", "WATCHDOG.md"];
 function defaultReadText(path5) {
   try {
-    if (!existsSync67(path5)) return null;
+    if (!existsSync68(path5)) return null;
     return readFileSync24(path5, "utf8");
   } catch {
     return null;
@@ -251033,7 +250915,7 @@ init_worktree_paths();
 // ../engine/src/merger-ai-worktree.ts
 init_active_session_registry();
 import { execFile as execFile28 } from "node:child_process";
-import { appendFileSync as appendFileSync2, existsSync as existsSync68, mkdirSync as mkdirSync11, readdirSync as readdirSync12, readFileSync as readFileSync25, realpathSync as realpathSync11, rmSync as rmSync9, statSync as statSync13 } from "node:fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync69, mkdirSync as mkdirSync11, readdirSync as readdirSync12, readFileSync as readFileSync25, realpathSync as realpathSync11, rmSync as rmSync9, statSync as statSync13 } from "node:fs";
 import { rm as rm13 } from "node:fs/promises";
 import { tmpdir as tmpdir10 } from "node:os";
 import { isAbsolute as isAbsolute21, join as join80, relative as relative18 } from "node:path";
@@ -251070,7 +250952,7 @@ function isBenignAbsentWorktreeError(err) {
 }
 function ensureAiMergeRootIgnored(projectRootDir, settings) {
   const excludePath = join80(projectRootDir, ".git", "info", "exclude");
-  if (!existsSync68(excludePath)) return;
+  if (!existsSync69(excludePath)) return;
   try {
     const current = readFileSync25(excludePath, "utf-8");
     const legacyAiMergeRoot = resolveLegacyAiMergeRootPath(projectRootDir);
@@ -251201,7 +251083,7 @@ async function cleanupAiMergeWorktree(input) {
   const cleanupMetadata = { taskId, mergeRoot: canonicalRoot, requestedMergeRoot: mergeRoot };
   let alreadyAbsent = false;
   if (worktreeAdded) {
-    if (!existsSync68(canonicalRoot) && !existsSync68(mergeRoot)) {
+    if (!existsSync69(canonicalRoot) && !existsSync69(mergeRoot)) {
       alreadyAbsent = true;
       await log41(`AI merge cleanup: worktree ${canonicalRoot} was already absent before git removal; treating cleanup as idempotent`);
       await audit.git({ type: "merge:ai-worktree-cleanup", target: canonicalRoot, metadata: { ...cleanupMetadata, phase: "git-remove", success: true, alreadyAbsent: true, idempotent: true, code: "ENOENT" } });