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

package/dist/extension.js

@@ -135461,7 +135461,8 @@ function wrapPluginRuntime(instance, runtimeId, runtimeName) {
         const result2 = await adapter.createSession(options);
         return {
           session: result2.session ?? result2,
-          sessionFile: result2.sessionFile
+          sessionFile: result2.sessionFile,
+          settleFallbackDispatch: result2.settleFallbackDispatch
         };
       }
       throw new Error(`Plugin runtime "${runtimeId}" does not implement createSession`);
@@ -135570,11 +135571,15 @@ var init_runtime_resolution = __esm({
       name = "Default PI Runtime";
       async createSession(options) {
         const { toolOutputMaxChars, mcpServers, ...agentOptions } = options;
-        return createFnAgent2({
+        const result2 = await createFnAgent2({
           ...agentOptions,
           toolOutputMaxChars,
           mcpServers: normalizeAgentRuntimeMcpServers(mcpServers)
         });
+        return {
+          ...result2,
+          settleFallbackDispatch: result2.settleFallbackDispatch ?? (async () => void 0)
+        };
       }
       async promptWithFallback(session, prompt, options) {
         return promptWithFallback(session, prompt, options);
@@ -136456,6 +136461,7 @@ async function createResolvedAgentSession(options) {
   return {
     session: result2.session,
     sessionFile: result2.sessionFile,
+    settleFallbackDispatch: result2.settleFallbackDispatch,
     runtimeId: resolved.runtimeId,
     wasConfigured: resolved.wasConfigured
   };
@@ -158451,7 +158457,11 @@ async function createFnAgent2(options) {
     }
   });
   attachSessionIdentity(promptableSession);
-  return { session: promptableSession, sessionFile: promptableSession.sessionFile };
+  return {
+    session: promptableSession,
+    sessionFile: promptableSession.sessionFile,
+    settleFallbackDispatch: async () => void 0
+  };
 }
 var execAsync, 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({
@@ -184940,6 +184950,25 @@ var init_scheduler = __esm({
               });
             }
           }
+          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((error3) => {
+                schedulerLog.warn(`Failed to reset dispatch oscillation state for ${task.id} on move to ${to2}: ${error3 instanceof Error ? error3.message : String(error3)}`);
+              });
+            }
+          }
           const resolvedParked = mergeParkedColumns(await resolveTaskParkedColumns(this.store, task.id), lanes);
           if (resolvedParked.terminal.has(to2)) {
             try {
@@ -185000,25 +185029,6 @@ var init_scheduler = __esm({
               schedulerLog.error(`Failed event-driven blocker reconciliation for ${task.id}`, error3);
             }
           }
-          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((error3) => {
-                schedulerLog.warn(`Failed to reset dispatch oscillation state for ${task.id} on move to ${to2}: ${error3 instanceof Error ? error3.message : String(error3)}`);
-              });
-            }
-          }
           if (resolvedParked.terminal.has(to2) || to2 === resolvedParked.hold) {
             schedulerLog.log(`Task moved to ${to2} \u2014 triggering scheduling`);
             this.schedule();
@@ -203276,7 +203286,6 @@ var init_self_healing = __esm({
               { 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.
@@ -212173,71 +212182,12 @@ var init_self_healing = __esm({
         }
       }
       /*
-      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()) {
-            log33.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`
-            );
-            log33.log(`Cleared durable PR block for ${task.id} (prs=${prNumbers.join(",")})`);
-            cleared += 1;
-          }
-          return cleared;
-        } catch (error3) {
-          log33.warn(`reconcile-external-pr-blockers failed: ${error3 instanceof Error ? error3.message : String(error3)}`);
-          return 0;
-        }
-      }
       async resolveExplicitDuplicateMarkerTasks() {
         try {
           const settings = await this.store.getSettings();
@@ -212991,6 +212941,7 @@ var init_self_healing = __esm({
 // ../engine/src/triage.ts
 import { Type as Type5 } from "@earendil-works/pi-ai";
 import { exec as exec34 } from "node:child_process";
+import { existsSync as existsSync60 } from "node:fs";
 import { readFile as readFile38, writeFile as writeFile27, rm as rm8 } from "node:fs/promises";
 import { join as join72 } from "node:path";
 import { promisify as promisify48 } from "node:util";
@@ -213497,6 +213448,8 @@ var init_triage = __esm({
       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;
@@ -214792,7 +214745,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 = join72(this.rootDir, promptPath);
+            const planningAttemptBaseline = existsSync60(authoritativePromptPath) ? await readFile38(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,
@@ -214831,13 +214805,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}`);
@@ -214907,6 +214875,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);
@@ -214999,12 +214971,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);
@@ -215046,6 +215048,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
@@ -216082,103 +216099,35 @@ Remove or replace these ids and call fn_task_create again.`
 // ../engine/src/execution-block-classifier.ts
 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) {
+function classifyBlockedExit(_reason, blockedBy = []) {
+  const { taskIds } = partitionBlockedByRefs(blockedBy);
+  if (taskIds.length > 0) {
     return {
       allowAutoReplan: false,
       class: "external",
-      externalBlockers: [],
-      thrashSignature: `tasks:${partitioned.taskIds.slice().sort().join(",")}`,
-      prNumbers
-    };
-  }
-  if (prNumbers.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"
   };
 }
 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) {
@@ -216190,18 +216139,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;
@@ -216210,38 +216148,26 @@ function countBlockedThrashHits(log41, signature, nowMs = Date.now(), windowMs =
   }
   return count2;
 }
-function isDurableBlockedError(error3) {
-  if (!error3?.startsWith("BLOCKED:")) return false;
-  const reason = error3.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: []
   };
 }
-var TASK_ID_RE, PR_REF_RE, PR_IN_TEXT_RE, CLAIM_REASON_RE, BLOCKED_THRASH_LIMIT, BLOCKED_THRASH_WINDOW_MS;
+var TASK_ID_RE, LEGACY_PR_REF_RE, BLOCKED_THRASH_LIMIT, BLOCKED_THRASH_WINDOW_MS;
 var init_execution_block_classifier = __esm({
   "../engine/src/execution-block-classifier.ts"() {
     "use strict";
     TASK_ID_RE = /^[A-Z][A-Z0-9]*-\d+$/i;
-    PR_REF_RE = /^(?:pr[:#-]|#|PR-)(\d+)$/i;
-    PR_IN_TEXT_RE = /\bPR\s*#?\s*(\d+)\b/gi;
-    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;
+    LEGACY_PR_REF_RE = /^(?:pr[:#-]|#|PR-)(\d+)$/i;
     BLOCKED_THRASH_LIMIT = 3;
     BLOCKED_THRASH_WINDOW_MS = 60 * 60 * 1e3;
   }
@@ -219059,7 +218985,7 @@ var init_workflow_completion_summary = __esm({
 
 // ../engine/src/review-checkout.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync60, realpathSync as realpathSync9, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync61, realpathSync as realpathSync9, statSync as statSync11 } from "node:fs";
 import { isAbsolute as isAbsolute15 } from "node:path";
 function readMetadataPath(value) {
   if (!value || typeof value !== "object") return void 0;
@@ -219083,7 +219009,7 @@ function resolveReviewCheckoutCwd(task, fallbackCwd) {
   const candidate = getTaskReviewCheckoutPath(task);
   if (!candidate || !isAbsolute15(candidate)) return fallbackCwd;
   try {
-    if (!existsSync60(candidate) || !statSync11(candidate).isDirectory()) return fallbackCwd;
+    if (!existsSync61(candidate) || !statSync11(candidate).isDirectory()) return fallbackCwd;
     const realCandidate = realpathSync9(candidate);
     const topLevel = execFileSync3("git", ["rev-parse", "--show-toplevel"], {
       cwd: realCandidate,
@@ -221689,7 +221615,7 @@ var init_external_integration_evidence = __esm({
 
 // ../engine/src/step-runner.ts
 import { exec as exec35 } from "node:child_process";
-import { existsSync as existsSync62, statSync as statSync12 } from "node:fs";
+import { existsSync as existsSync63, statSync as statSync12 } from "node:fs";
 import { promisify as promisify50 } from "node:util";
 async function runTaskStep(deps, task, stepIndex, opts = {}) {
   const { store, worktreePath } = deps;
@@ -221843,7 +221769,7 @@ function makeAncestryBlastRadiusGuard(opts) {
 function isUsableWorktreeDirectory(candidate) {
   if (!candidate) return false;
   try {
-    return existsSync62(candidate) && statSync12(candidate).isDirectory();
+    return existsSync63(candidate) && statSync12(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -221880,7 +221806,7 @@ var init_step_runner = __esm({
 
 // ../engine/src/auto-recovery-handlers/branch-worktree.ts
 import { exec as exec36 } from "node:child_process";
-import { existsSync as existsSync63 } from "node:fs";
+import { existsSync as existsSync64 } from "node:fs";
 import { promisify as promisify51 } from "node:util";
 var execAsync33, baseLog2, GIT_TIMEOUT_MS8, GIT_MAX_BUFFER6, BranchWorktreeAutoRecoveryHandler;
 var init_branch_worktree = __esm({
@@ -222071,7 +221997,7 @@ var init_branch_worktree = __esm({
         if (inspection.kind === "stale-resolved" || inspection.kind === "fully-subsumed" || inspection.kind === "tip-already-merged") {
           await this.requeueAfterRecovery(ctx.task, failure, inspection.kind, {
             branchExists: await this.hasBranchRef(repoDir, branchName),
-            worktreePresent: existsSync63(conflictingWorktreePath),
+            worktreePresent: existsSync64(conflictingWorktreePath),
             tipSha: "tipSha" in inspection ? inspection.tipSha : void 0,
             inspectionKind: inspection.kind
           });
@@ -222141,7 +222067,7 @@ var init_branch_worktree = __esm({
           let branchDeleted = false;
           let worktreeRemoved = false;
           if (!isLiveOwned) {
-            if (existsSync63(conflictingWorktreePath)) {
+            if (existsSync64(conflictingWorktreePath)) {
               try {
                 await execAsync33(`git worktree remove --force ${this.quote(conflictingWorktreePath)}`, {
                   cwd: repoDir,
@@ -222189,7 +222115,7 @@ var init_branch_worktree = __esm({
           });
           await this.requeueAfterRecovery(ctx.task, failure, "live-foreign-discard-and-recreate", {
             branchExists: !branchDeleted,
-            worktreePresent: !worktreeRemoved && existsSync63(conflictingWorktreePath),
+            worktreePresent: !worktreeRemoved && existsSync64(conflictingWorktreePath),
             tipSha: tipSha2,
             inspectionKind: inspection.kind
           });
@@ -222202,7 +222128,7 @@ var init_branch_worktree = __esm({
           conflictingWorktreePath,
           inspectionKind: inspection.kind,
           branchExists,
-          worktreePresent: existsSync63(conflictingWorktreePath),
+          worktreePresent: existsSync64(conflictingWorktreePath),
           tipSha
         });
       }
@@ -222363,7 +222289,7 @@ var init_file_scope2 = __esm({
 });
 
 // ../engine/src/run-verification-tool.ts
-import { existsSync as existsSync64, readdirSync as readdirSync11, readFileSync as readFileSync23 } from "node:fs";
+import { existsSync as existsSync65, readdirSync as readdirSync11, readFileSync as readFileSync23 } from "node:fs";
 import { isAbsolute as isAbsolute16, join as join77, relative as relative14 } from "node:path";
 import { Type as Type6 } from "@earendil-works/pi-ai";
 function shellSplit(input) {
@@ -222923,7 +222849,7 @@ function createRunVerificationTool(opts) {
       }
       if (effectiveCommand.trimStart().startsWith("pnpm --filter")) {
         const modulesYaml = join77(rootDir, "node_modules", ".modules.yaml");
-        if (!existsSync64(modulesYaml)) {
+        if (!existsSync65(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.`;
           warnings.push(msg);
@@ -223284,7 +223210,7 @@ import { exec as exec39, execFile as execFile26, execSync as execSync7 } from "n
 import { promisify as promisify54 } from "node:util";
 import { setImmediate as setImmediateCb3 } from "node:timers";
 import { basename as basename19, delimiter as delimiter2, isAbsolute as isAbsolute18, join as join78, relative as relative16, resolve as resolvePath3 } from "node:path";
-import { existsSync as existsSync65, lstatSync as lstatSync3, realpathSync as realpathSync10 } from "node:fs";
+import { existsSync as existsSync66, lstatSync as lstatSync3, realpathSync as realpathSync10 } from "node:fs";
 import { readFile as readFile40, rm as rm12, writeFile as writeFile29 } from "node:fs/promises";
 import { Type as Type7 } from "@earendil-works/pi-ai";
 import { SessionManager as SessionManager2 } from "@earendil-works/pi-coding-agent";
@@ -223302,7 +223228,7 @@ function isWorkflowStepSkillDiscoverable(skillName, additionalSkillPaths, ceSkil
     return false;
   }
   return (additionalSkillPaths ?? []).some(
-    (skillPath) => basename19(skillPath) === bareSkillName && existsSync65(join78(skillPath, "SKILL.md")) || existsSync65(join78(skillPath, bareSkillName, "SKILL.md"))
+    (skillPath) => basename19(skillPath) === bareSkillName && existsSync66(join78(skillPath, "SKILL.md")) || existsSync66(join78(skillPath, bareSkillName, "SKILL.md"))
   );
 }
 function getPromptSection(prompt, heading) {
@@ -224275,7 +224201,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
@@ -226864,7 +226790,7 @@ The tool prevents your session from being killed by the inactivity watchdog duri
             );
             return false;
           }
-          if (task.worktree && existsSync65(task.worktree)) {
+          if (task.worktree && existsSync66(task.worktree)) {
             const modifiedFiles = await this.captureModifiedFiles(task.worktree, task.baseCommitSha, task.id, void 0, "recovery");
             if (modifiedFiles.length > 0) {
               await this.store.updateTask(task.id, { modifiedFiles });
@@ -229826,7 +229752,7 @@ ${info.feedback}`, revisionKey),
           if (live.firstExecutionAt || live.executionStartedAt) return false;
           if (activeSessionRegistry.isPathActive(live.worktree) || activeSessionRegistry.isPathActive(resolvePath3(live.worktree))) return false;
           if (this.hasLiveTaskSessionSurface(taskId) || executingTaskLock.has(taskId)) return false;
-          if (existsSync65(live.worktree)) {
+          if (existsSync66(live.worktree)) {
             if (await this.preExecutionWorktreeHasWork(live.worktree)) {
               executorLog.log(`${taskId}: keeping pre-execution worktree ${live.worktree} \u2014 it carries commits or uncommitted changes`);
               return false;
@@ -229868,7 +229794,7 @@ ${info.feedback}`, revisionKey),
           }
           if (this.workspaceConfig && (this.workspaceConfig.repos.length ?? 0) > 0) return null;
           const live = await this.store.getTask(taskId);
-          if (live.worktree && existsSync65(live.worktree)) return live.worktree;
+          if (live.worktree && existsSync66(live.worktree)) return live.worktree;
           const settings = await this.store.getSettings();
           const acquisitionTask = live.worktree ? { ...live, worktree: void 0, sessionFile: void 0 } : live;
           const acquired = await this.ensureGraphCustomNodeWorktree(acquisitionTask, settings, "planning");
@@ -229882,8 +229808,8 @@ ${info.feedback}`, revisionKey),
         if (!requirement.requiresWorktree) return;
         const live = await this.store.getTask(nodeTask.id);
         const executionCodeNode = node.kind === "code";
-        if (live.worktree && existsSync65(live.worktree) && !executionCodeNode) return;
-        const taskForAcquisition = live.worktree && !existsSync65(live.worktree) ? { ...live, worktree: void 0, sessionFile: void 0 } : live;
+        if (live.worktree && existsSync66(live.worktree) && !executionCodeNode) return;
+        const taskForAcquisition = live.worktree && !existsSync66(live.worktree) ? { ...live, worktree: void 0, sessionFile: void 0 } : live;
         if (live.worktree) {
           await this.store.logEntry(
             live.id,
@@ -230009,7 +229935,7 @@ ${info.feedback}`, revisionKey),
         const nodeDisplayName = typeof cfg.name === "string" && cfg.name.trim() ? cfg.name.trim() : node.id;
         const isPlanReviewNode = node.id === "plan-review-step" || nodeDisplayName === "Plan Review" || optionalGroupId === "plan-review";
         if (!this.workspaceConfig) {
-          const recordedWorktreeMissing = Boolean(executionTarget.worktree) && !existsSync65(executionTarget.worktree);
+          const recordedWorktreeMissing = Boolean(executionTarget.worktree) && !existsSync66(executionTarget.worktree);
           const shouldAcquire = !executionTarget.worktree || recordedWorktreeMissing && isPlanReviewNode;
           if (shouldAcquire) {
             if (recordedWorktreeMissing) {
@@ -231683,75 +231609,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";
@@ -232932,7 +232799,7 @@ ${summary}`,
                     executorLog.warn(`\u26A1 ${task.id} transient error \u2014 retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay6}: ${errorMessage2}`);
                     await this.store.logEntry(task.id, `Transient error (retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay6}): ${errorMessage2}`, void 0, this.getRunContextFor(task.id));
                   }
-                  if (worktreePath && existsSync65(worktreePath)) {
+                  if (worktreePath && existsSync66(worktreePath)) {
                     try {
                       const settings2 = await this.store.getSettings();
                       await removeWorktree({
@@ -233013,7 +232880,7 @@ ${summary}`,
                     const settings2 = await this.store.getSettings();
                     const preserveProgress = settings2.preserveProgressOnStuckRequeue !== false;
                     await this.resetStepsIfWorkLost(latestTask);
-                    if (worktreePath && existsSync65(worktreePath)) {
+                    if (worktreePath && existsSync66(worktreePath)) {
                       try {
                         await removeWorktree({
                           worktreePath,
@@ -233296,7 +233163,7 @@ ${summary}`,
               nodeId: detail.effectiveNodeId ?? detail.nodeId ?? null,
               agentId: engineRunContext.agentId ?? null
             });
-            let isResuming = !!task.sessionFile && existsSync65(task.sessionFile);
+            let isResuming = !!task.sessionFile && existsSync66(task.sessionFile);
             if (isResuming) {
               const persistedWorktreePath = await extractPersistedSessionWorktreePath(task.sessionFile, this.rootDir, settings);
               if (!isSessionWorktreeCompatible(persistedWorktreePath, worktreePath)) {
@@ -234077,7 +233944,7 @@ ${summary}`,
               return;
             } else {
               executorLog.log(`${task.id} paused \u2014 moving to todo`);
-              if (worktreePath && existsSync65(worktreePath)) {
+              if (worktreePath && existsSync66(worktreePath)) {
                 try {
                   const settings2 = await this.store.getSettings();
                   await removeWorktree({
@@ -234474,7 +234341,7 @@ ${summary}`,
                   executorLog.warn(`\u26A1 ${task.id} transient error \u2014 retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay6}: ${errorMessage2}`);
                   await this.store.logEntry(task.id, `Transient error (retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay6}): ${errorMessage2}`, void 0, this.getRunContextFor(task.id));
                 }
-                if (worktreePath && existsSync65(worktreePath)) {
+                if (worktreePath && existsSync66(worktreePath)) {
                   try {
                     const settings2 = await this.store.getSettings();
                     await removeWorktree({
@@ -234610,7 +234477,7 @@ ${summary}`,
                   const settings2 = await this.store.getSettings();
                   const preserveProgress = settings2.preserveProgressOnStuckRequeue !== false;
                   await this.resetStepsIfWorkLost(latestTask);
-                  if (worktreePath && existsSync65(worktreePath)) {
+                  if (worktreePath && existsSync66(worktreePath)) {
                     try {
                       await removeWorktree({
                         worktreePath,
@@ -235037,7 +234904,7 @@ ${summary}`,
           for (const repoRel of Object.keys(workspaceWorktrees).sort()) {
             const repo = workspaceWorktrees[repoRel];
             const expectedBranch = repo.branch || canonicalFusionBranchName(task.id);
-            if (!existsSync65(repo.worktreePath)) {
+            if (!existsSync66(repo.worktreePath)) {
               executorLog.log(`${task.id}: workspace worktree for ${repoRel} not found at ${repo.worktreePath} \u2014 skipping git validation`);
               continue;
             }
@@ -235169,7 +235036,7 @@ ${summary}`,
             expected: `resolvable task worktree under ${resolveWorktreesDir(this.rootDir, settings)}/*`
           };
         }
-        if (!existsSync65(worktreePath)) {
+        if (!existsSync66(worktreePath)) {
           executorLog.log(
             `${task.id}: worktree directory not found at ${worktreePath} \u2014 skipping git validation for task completion`
           );
@@ -235498,10 +235365,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: Type7.Optional(Type7.Array(Type7.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: Type7.Optional(Type7.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) => {
@@ -235560,7 +235427,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)
                 );
@@ -235579,18 +235446,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: {}
               };
@@ -237648,7 +237514,7 @@ ${detectedQuestion}
        * rather than fail the task permanently.
        */
       async resolveWorktreeStartPoint(startPoint, taskId) {
-        const command = isAbsolute18(startPoint) && existsSync65(startPoint) ? `git -C "${startPoint}" rev-parse --verify HEAD^{commit}` : `git rev-parse --verify "${startPoint}^{commit}"`;
+        const command = isAbsolute18(startPoint) && existsSync66(startPoint) ? `git -C "${startPoint}" rev-parse --verify HEAD^{commit}` : `git rev-parse --verify "${startPoint}^{commit}"`;
         try {
           const { stdout } = await execAsync36(command, { cwd: this.rootDir });
           return stdout.trim() || startPoint;
@@ -237871,7 +237737,7 @@ ${detectedQuestion}
             throw error3;
           }
         };
-        if (existsSync65(path10)) {
+        if (existsSync66(path10)) {
           const isRegistered = await this.isRegisteredWorktree(path10);
           if (!isRegistered) {
             await this.store.logEntry(
@@ -238487,7 +238353,7 @@ ${detectedQuestion}
             const stillRegistered = await isRegisteredGitWorktree2(this.rootDir, worktreePath).catch(() => true);
             const activeOwner2 = await this.findActiveWorktreeOwner(worktreePath, taskId).catch(() => "unknown");
             let safeToRemove = isInsideWorktreesDir(this.rootDir, worktreePath, settings) && !stillRegistered && activeOwner2 === null;
-            if (safeToRemove && existsSync65(worktreePath)) {
+            if (safeToRemove && existsSync66(worktreePath)) {
               try {
                 if (lstatSync3(worktreePath).isSymbolicLink()) {
                   safeToRemove = false;
@@ -238515,7 +238381,7 @@ ${detectedQuestion}
               const pruneMsg = pruneErr instanceof Error ? pruneErr.message : String(pruneErr);
               executorLog.warn(`${taskId}: git worktree prune failed during stale-path cleanup of ${worktreePath}: ${pruneMsg}`);
             }
-            if (existsSync65(worktreePath)) {
+            if (existsSync66(worktreePath)) {
               try {
                 await rm12(worktreePath, { recursive: true, force: true });
               } catch (rmErr) {
@@ -238962,7 +238828,7 @@ ${detectedQuestion}
               this.clearPausedAborted(taskId);
               await this.resetStepsIfWorkLost(latestTask);
               let cleanupFailed = false;
-              if (worktreePath && existsSync65(worktreePath)) {
+              if (worktreePath && existsSync66(worktreePath)) {
                 try {
                   await removeWorktree({
                     worktreePath,
@@ -243049,7 +242915,7 @@ var init_overseer_noop_finalize_veto = __esm({
 
 // ../engine/src/merger-ai-worktree.ts
 import { execFile as execFile27 } from "node:child_process";
-import { appendFileSync as appendFileSync2, existsSync as existsSync66, mkdirSync as mkdirSync11, readdirSync as readdirSync12, readFileSync as readFileSync24, realpathSync as realpathSync11, rmSync as rmSync9, statSync as statSync13 } from "node:fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync67, mkdirSync as mkdirSync11, readdirSync as readdirSync12, readFileSync as readFileSync24, 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 isAbsolute19, join as join79, relative as relative17 } from "node:path";
@@ -243084,7 +242950,7 @@ function isBenignAbsentWorktreeError(err) {
 }
 function ensureAiMergeRootIgnored(projectRootDir, settings) {
   const excludePath = join79(projectRootDir, ".git", "info", "exclude");
-  if (!existsSync66(excludePath)) return;
+  if (!existsSync67(excludePath)) return;
   try {
     const current = readFileSync24(excludePath, "utf-8");
     const legacyAiMergeRoot = resolveLegacyAiMergeRootPath(projectRootDir);
@@ -243215,7 +243081,7 @@ async function cleanupAiMergeWorktree(input) {
   const cleanupMetadata = { taskId, mergeRoot: canonicalRoot, requestedMergeRoot: mergeRoot };
   let alreadyAbsent = false;
   if (worktreeAdded) {
-    if (!existsSync66(canonicalRoot) && !existsSync66(mergeRoot)) {
+    if (!existsSync67(canonicalRoot) && !existsSync67(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" } });
@@ -249537,12 +249403,12 @@ The note must be specific (what/where/why). Prefer citing File Scope, PROMPT, a
 });
 
 // ../engine/src/overseer-watchdog.ts
-import { existsSync as existsSync67, readFileSync as readFileSync25 } from "node:fs";
+import { existsSync as existsSync68, readFileSync as readFileSync25 } from "node:fs";
 import { dirname as dirname34, join as join82, relative as relative18, resolve as resolve40, sep as sep11 } from "node:path";
 import { homedir as homedir12 } from "node:os";
 function defaultReadText(path10) {
   try {
-    if (!existsSync67(path10)) return null;
+    if (!existsSync68(path10)) return null;
     return readFileSync25(path10, "utf8");
   } catch {
     return null;
@@ -255343,7 +255209,7 @@ var init_adapters = __esm({
 });
 
 // ../engine/src/cli-agent/resume-coordinator.ts
-import { existsSync as existsSync68 } from "node:fs";
+import { existsSync as existsSync69 } from "node:fs";
 import { execFile as execFile30 } from "node:child_process";
 import { promisify as promisify62 } from "node:util";
 async function defaultIsWorktreeDirty(worktreePath) {
@@ -255388,7 +255254,7 @@ var init_resume_coordinator = __esm({
         this.reattachTelemetry = opts.reattachTelemetry;
         this.maxResumeAttempts = opts.maxResumeAttempts ?? DEFAULT_MAX_RESUME_ATTEMPTS;
         this.resumeBackoffBaseMs = opts.resumeBackoffBaseMs ?? DEFAULT_RESUME_BACKOFF_BASE_MS;
-        this.worktreeExists = opts.worktreeExists ?? ((p2) => existsSync68(p2));
+        this.worktreeExists = opts.worktreeExists ?? ((p2) => existsSync69(p2));
         this.isWorktreeDirty = opts.isWorktreeDirty ?? defaultIsWorktreeDirty;
         this.log = opts.log ?? (() => {
         });
@@ -283184,7 +283050,7 @@ var init_cli_spawn = __esm({
 // ../../plugins/fusion-plugin-hermes-runtime/src/fusion-skill-install.ts
 import {
   cpSync as cpSync2,
-  existsSync as existsSync69,
+  existsSync as existsSync70,
   lstatSync as lstatSync4,
   mkdirSync as mkdirSync13,
   readFileSync as readFileSync26,
@@ -283214,7 +283080,7 @@ function getFusionSkillSourceCandidates(moduleUrl = import.meta.url) {
 function resolveBundledFusionSkillSource() {
   const candidates = getFusionSkillSourceCandidates();
   for (const candidate of candidates) {
-    if (existsSync69(join87(candidate, "SKILL.md"))) return candidate;
+    if (existsSync70(join87(candidate, "SKILL.md"))) return candidate;
   }
   return null;
 }
@@ -283232,7 +283098,7 @@ function installFusionSkillIntoHermesHome(options = {}) {
   try {
     mkdirSync13(dirname36(targetDir), { recursive: true });
     let replaced = false;
-    if (existsSync69(targetDir) || isBrokenSymlink(targetDir)) {
+    if (existsSync70(targetDir) || isBrokenSymlink(targetDir)) {
       const stat13 = lstatSync4(targetDir);
       if (stat13.isSymbolicLink()) {
         const currentTarget = safeReadlink(targetDir);
@@ -283303,14 +283169,14 @@ function safeReadlink(path10) {
 function isBrokenSymlink(path10) {
   try {
     const stat13 = lstatSync4(path10);
-    return stat13.isSymbolicLink() && !existsSync69(path10);
+    return stat13.isSymbolicLink() && !existsSync70(path10);
   } catch {
     return false;
   }
 }
 function looksLikePriorFusionInstall(path10) {
   const skillMd = join87(path10, "SKILL.md");
-  if (!existsSync69(skillMd)) return false;
+  if (!existsSync70(skillMd)) return false;
   try {
     const body = readFileSync26(skillMd, "utf-8");
     return /\bfusion\b/i.test(body) && /\bskill\b/i.test(body);
@@ -283321,7 +283187,7 @@ function looksLikePriorFusionInstall(path10) {
 function looksLikeFusionSkillTarget(path10) {
   if (!path10) return false;
   if (basename20(path10).toLowerCase() === FUSION_SKILL_NAME) return true;
-  return existsSync69(join87(path10, "SKILL.md"));
+  return existsSync70(join87(path10, "SKILL.md"));
 }
 var FUSION_SKILL_NAME;
 var init_fusion_skill_install = __esm({
@@ -284677,7 +284543,7 @@ var init_provider2 = __esm({
 });
 
 // ../../plugins/fusion-plugin-grok-runtime/src/acp/cli-spawn.ts
-import { existsSync as existsSync70 } from "node:fs";
+import { existsSync as existsSync71 } from "node:fs";
 import { dirname as dirname38, isAbsolute as isAbsolute22, join as join90, resolve as resolve42 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function asTrimmedString(value) {
@@ -284700,7 +284566,7 @@ function bundledClaudeBridgeBinPath(pluginRoot = pluginRootDir()) {
 }
 function resolveBundledClaudeBridgeBinary(options = {}) {
   const root = options.pluginRoot ?? pluginRootDir();
-  const exists2 = options.exists ?? existsSync70;
+  const exists2 = options.exists ?? existsSync71;
   const candidate = bundledClaudeBridgeBinPath(root);
   if (!exists2(candidate)) {
     return {
@@ -286049,7 +285915,7 @@ var init_mcp_forwarding = __esm({
 // ../../plugins/fusion-plugin-grok-runtime/src/skill-loader.ts
 import {
   cpSync as cpSync3,
-  existsSync as existsSync71,
+  existsSync as existsSync72,
   mkdirSync as mkdirSync14,
   mkdtempSync as mkdtempSync3,
   readdirSync as readdirSync14,
@@ -286062,7 +285928,7 @@ import { tmpdir as tmpdir15 } from "node:os";
 import { basename as basename22, dirname as dirname40, join as join92, resolve as resolve44 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function isSkillDir(dir) {
-  return existsSync71(join92(dir, "SKILL.md"));
+  return existsSync72(join92(dir, "SKILL.md"));
 }
 function pushUnique(out, candidate) {
   if (!candidate) return;
@@ -286126,7 +285992,7 @@ function resolveBundledFusionSkillSource2(moduleUrl = import.meta.url) {
 function installSkillDir(sourceDir, targetDir) {
   if (!isSkillDir(sourceDir)) return false;
   mkdirSync14(dirname40(targetDir), { recursive: true });
-  if (existsSync71(targetDir)) {
+  if (existsSync72(targetDir)) {
     rmSync11(targetDir, { recursive: true, force: true });
   }
   try {
@@ -286142,7 +286008,7 @@ function installSkillDir(sourceDir, targetDir) {
   }
 }
 function collectSkillsFromRoot(root, out) {
-  if (!existsSync71(root)) return;
+  if (!existsSync72(root)) return;
   if (isSkillDir(root)) {
     out.set(basename22(root), root);
     return;
@@ -286181,7 +286047,7 @@ function stageGrokSessionSkills(options = {}) {
     installSkillDir(source, join92(skillsDir, name2));
   }
   for (const [name2, source] of installed) {
-    if (!existsSync71(join92(skillsDir, name2))) {
+    if (!existsSync72(join92(skillsDir, name2))) {
       installSkillDir(source, join92(skillsDir, name2));
     }
   }
@@ -286250,7 +286116,7 @@ var init_skill_loader = __esm({
 
 // ../../plugins/fusion-plugin-grok-runtime/src/tool-bridge.ts
 import { createServer as createServer2 } from "node:http";
-import { existsSync as existsSync72, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync73, writeFileSync as writeFileSync15 } from "node:fs";
 import { tmpdir as tmpdir16 } from "node:os";
 import { dirname as dirname41, join as join93 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
@@ -286296,7 +286162,7 @@ async function startFusionToolBridge(tools) {
   const defs = toolsToMcpToolDefs2(tools);
   if (defs.length === 0) return null;
   const serverPath = fusionToolsMcpServerPath();
-  if (!existsSync72(serverPath)) {
+  if (!existsSync73(serverPath)) {
     throw missingMcpSchemaServerError(serverPath);
   }
   const byName = /* @__PURE__ */ new Map();
@@ -286737,7 +286603,7 @@ var init_src11 = __esm({
 });
 
 // ../../plugins/fusion-plugin-claude-runtime/src/acp/cli-spawn.ts
-import { existsSync as existsSync73 } from "node:fs";
+import { existsSync as existsSync74 } from "node:fs";
 import { dirname as dirname42, isAbsolute as isAbsolute23, join as join94, resolve as resolve45 } from "node:path";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
 function asTrimmedString2(value) {
@@ -286760,7 +286626,7 @@ function bundledClaudeBridgeBinPath2(pluginRoot = pluginRootDir2()) {
 }
 function resolveBundledClaudeBridgeBinary2(options = {}) {
   const root = options.pluginRoot ?? pluginRootDir2();
-  const exists2 = options.exists ?? existsSync73;
+  const exists2 = options.exists ?? existsSync74;
   const candidate = bundledClaudeBridgeBinPath2(root);
   if (!exists2(candidate)) {
     return {
@@ -287995,7 +287861,7 @@ var init_acp2 = __esm({
 
 // ../../plugins/fusion-plugin-claude-runtime/src/cli-spawn.ts
 import { spawn as spawn19 } from "node:child_process";
-import { existsSync as existsSync74 } from "node:fs";
+import { existsSync as existsSync75 } from "node:fs";
 import { basename as basename24, dirname as dirname44, isAbsolute as isAbsolute24, join as join96, resolve as resolve47 } from "node:path";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 function pluginRootDir3() {
@@ -288007,7 +287873,7 @@ function bundledClaudeBridgeBinPath3(pluginRoot = pluginRootDir3()) {
 }
 function resolveBundledClaudeBridgeBinary3(options = {}) {
   const candidate = bundledClaudeBridgeBinPath3(options.pluginRoot ?? pluginRootDir3());
-  const exists2 = options.exists ?? existsSync74;
+  const exists2 = options.exists ?? existsSync75;
   if (!exists2(candidate) || !isAbsolute24(candidate)) return { kind: "not_resolved", requested: CLAUDE_CODE_CLI_ACP_BINARY3, path: candidate, reason: `Staged ${CLAUDE_CODE_CLI_ACP_BINARY3} bridge was not found at ${candidate}` };
   return { kind: "resolved", requested: CLAUDE_CODE_CLI_ACP_BINARY3, path: candidate };
 }
@@ -288170,7 +288036,7 @@ var init_mcp_forwarding2 = __esm({
 // ../../plugins/fusion-plugin-claude-runtime/src/skill-loader.ts
 import {
   cpSync as cpSync4,
-  existsSync as existsSync75,
+  existsSync as existsSync76,
   mkdirSync as mkdirSync15,
   mkdtempSync as mkdtempSync4,
   readdirSync as readdirSync15,
@@ -288183,7 +288049,7 @@ import { tmpdir as tmpdir17 } from "node:os";
 import { basename as basename25, dirname as dirname45, join as join97, resolve as resolve48 } from "node:path";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
 function isSkillDir2(dir) {
-  return existsSync75(join97(dir, "SKILL.md"));
+  return existsSync76(join97(dir, "SKILL.md"));
 }
 function pushUnique2(out, candidate) {
   if (!candidate) return;
@@ -288247,7 +288113,7 @@ function resolveBundledFusionSkillSource3(moduleUrl = import.meta.url) {
 function installSkillDir2(sourceDir, targetDir) {
   if (!isSkillDir2(sourceDir)) return false;
   mkdirSync15(dirname45(targetDir), { recursive: true });
-  if (existsSync75(targetDir)) {
+  if (existsSync76(targetDir)) {
     rmSync12(targetDir, { recursive: true, force: true });
   }
   try {
@@ -288263,7 +288129,7 @@ function installSkillDir2(sourceDir, targetDir) {
   }
 }
 function collectSkillsFromRoot2(root, out) {
-  if (!existsSync75(root)) return;
+  if (!existsSync76(root)) return;
   if (isSkillDir2(root)) {
     out.set(basename25(root), root);
     return;
@@ -288302,7 +288168,7 @@ function stageClaudeSessionSkills(options = {}) {
     installSkillDir2(source, join97(skillsDir, name2));
   }
   for (const [name2, source] of installed) {
-    if (!existsSync75(join97(skillsDir, name2))) {
+    if (!existsSync76(join97(skillsDir, name2))) {
       installSkillDir2(source, join97(skillsDir, name2));
     }
   }
@@ -288371,7 +288237,7 @@ var init_skill_loader2 = __esm({
 
 // ../../plugins/fusion-plugin-claude-runtime/src/tool-bridge.ts
 import { createServer as createServer3 } from "node:http";
-import { existsSync as existsSync76, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
+import { existsSync as existsSync77, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
 import { tmpdir as tmpdir18 } from "node:os";
 import { dirname as dirname46, join as join98 } from "node:path";
 import { fileURLToPath as fileURLToPath13 } from "node:url";
@@ -288417,7 +288283,7 @@ async function startFusionToolBridge2(tools, options = {}) {
   const defs = toolsToMcpToolDefs3(tools);
   if (defs.length === 0) return null;
   const serverPath = fusionToolsMcpServerPath2();
-  if (!existsSync76(serverPath)) {
+  if (!existsSync77(serverPath)) {
     throw missingMcpSchemaServerError2(serverPath);
   }
   const byName = /* @__PURE__ */ new Map();
@@ -289229,7 +289095,7 @@ var init_provider6 = __esm({
 });
 
 // ../../plugins/fusion-plugin-omp-runtime/src/acp/cli-spawn.ts
-import { existsSync as existsSync77 } from "node:fs";
+import { existsSync as existsSync78 } from "node:fs";
 import { dirname as dirname47, isAbsolute as isAbsolute25, join as join99, resolve as resolve49 } from "node:path";
 import { fileURLToPath as fileURLToPath14 } from "node:url";
 function asTrimmedString3(value) {
@@ -289252,7 +289118,7 @@ function bundledClaudeBridgeBinPath4(pluginRoot = pluginRootDir4()) {
 }
 function resolveBundledClaudeBridgeBinary4(options = {}) {
   const root = options.pluginRoot ?? pluginRootDir4();
-  const exists2 = options.exists ?? existsSync77;
+  const exists2 = options.exists ?? existsSync78;
   const candidate = bundledClaudeBridgeBinPath4(root);
   if (!exists2(candidate)) {
     return {
@@ -290564,7 +290430,7 @@ var init_mcp_forwarding3 = __esm({
 
 // ../../plugins/fusion-plugin-omp-runtime/src/tool-bridge.ts
 import { createServer as createServer4 } from "node:http";
-import { existsSync as existsSync78, unlinkSync as unlinkSync5, writeFileSync as writeFileSync18 } from "node:fs";
+import { existsSync as existsSync79, unlinkSync as unlinkSync5, writeFileSync as writeFileSync18 } from "node:fs";
 import { tmpdir as tmpdir19 } from "node:os";
 import { dirname as dirname49, join as join101 } from "node:path";
 import { fileURLToPath as fileURLToPath15 } from "node:url";
@@ -290591,7 +290457,7 @@ function fusionToolsMcpServerPath3() {
     join101(here, "..", "mcp-schema-server.cjs")
   ];
   for (const candidate of candidates) {
-    if (existsSync78(candidate)) return candidate;
+    if (existsSync79(candidate)) return candidate;
   }
   return null;
 }
@@ -290729,7 +290595,7 @@ var init_tool_bridge3 = __esm({
 });
 
 // ../../plugins/fusion-plugin-omp-runtime/src/runtime-adapter.ts
-import { existsSync as existsSync79 } from "node:fs";
+import { existsSync as existsSync80 } from "node:fs";
 function compactDiagnostic3(value) {
   return value.replace(/\s+/g, " ").trim();
 }
@@ -290920,7 +290786,7 @@ var init_runtime_adapter9 = __esm({
           const command = server.command.trim();
           if (!command) return false;
           if (command.includes("/") || command.includes("\\")) {
-            return existsSync79(command);
+            return existsSync80(command);
           }
           return true;
         });
@@ -294142,7 +294008,7 @@ __export(task_exports, {
   runTaskUpdate: () => runTaskUpdate
 });
 import { createInterface as createInterface2 } from "node:readline/promises";
-import { watchFile, unwatchFile, statSync as statSync14, existsSync as existsSync80, readFileSync as readFileSync27 } from "node:fs";
+import { watchFile, unwatchFile, statSync as statSync14, existsSync as existsSync81, readFileSync as readFileSync27 } from "node:fs";
 import { basename as basename28, join as join104 } from "node:path";
 function columnLabel(column) {
   return COLUMN_LABELS[column] ?? column;
@@ -294716,7 +294582,7 @@ async function runTaskLogs(id, options = {}, projectName) {
   if (options.follow) {
     const projectPath = context.projectPath ?? process.cwd();
     const logPath = join104(projectPath, ".fusion", "tasks", id, "agent.log");
-    if (!existsSync80(logPath)) {
+    if (!existsSync81(logPath)) {
       console.log(`
   Waiting for log file to be created...`);
     }
@@ -296119,7 +295985,7 @@ import { Type as Type9 } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { resolve as resolve53, relative as relative20, isAbsolute as isAbsolute26, sep as sep16, basename as basename29, extname as extname4, join as join105 } from "node:path";
 import { readFile as readFile47 } from "node:fs/promises";
-import { existsSync as existsSync81 } from "node:fs";
+import { existsSync as existsSync82 } from "node:fs";
 import { spawn as spawn23 } from "node:child_process";
 import { AsyncLocalStorage } from "node:async_hooks";
 function truncateAgentDiagnosticText(value, maxChars) {
@@ -296199,12 +296065,12 @@ function resolveProjectRoot2(cwd) {
     warnedMissingProjectRootResolver = true;
     console.warn("[fusion-extension] @fusion/core.getProjectRootFromWorktree is unavailable; using filesystem fallback resolution.");
   }
-  if (worktreeProjectRoot && existsSync81(join105(worktreeProjectRoot, ".fusion"))) {
+  if (worktreeProjectRoot && existsSync82(join105(worktreeProjectRoot, ".fusion"))) {
     return worktreeProjectRoot;
   }
   let current = resolve53(cwd);
   while (true) {
-    if (existsSync81(join105(current, ".fusion"))) {
+    if (existsSync82(join105(current, ".fusion"))) {
       return current;
     }
     const parent = resolve53(current, "..");