@runfusion/fusion 0.74.0-beta.1 → 0.74.0-beta.3

package/dist/extension.js

@@ -5525,7 +5525,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       sql2.raw = raw;
-      function join108(chunks, separator) {
+      function join109(chunks, separator) {
         const result2 = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -5535,7 +5535,7 @@ var init_sql = __esm({
         }
         return new SQL(result2);
       }
-      sql2.join = join108;
+      sql2.join = join109;
       function identifier(value) {
         return new Name(value);
       }
@@ -10183,7 +10183,7 @@ var init_select2 = __esm({
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table)) this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join108) => join108.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join109) => join109.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -11718,7 +11718,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join108) => join108.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join109) => join109.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -11814,10 +11814,10 @@ var init_update = __esm({
               const fromFields = this.getTableLikeFields(this.config.from);
               fields[tableName] = fromFields;
             }
-            for (const join108 of this.config.joins) {
-              const tableName2 = getTableLikeName(join108.table);
-              if (typeof tableName2 === "string" && !is(join108.table, SQL)) {
-                const fromFields = this.getTableLikeFields(join108.table);
+            for (const join109 of this.config.joins) {
+              const tableName2 = getTableLikeName(join109.table);
+              if (typeof tableName2 === "string" && !is(join109.table, SQL)) {
+                const fromFields = this.getTableLikeFields(join109.table);
                 fields[tableName2] = fromFields;
               }
             }
@@ -20421,26 +20421,26 @@ function validateParallelism(nodes2, outgoing, nodesById) {
     }
     const joinsReached = /* @__PURE__ */ new Set();
     for (const edge of branchEdges) {
-      const join109 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
-      if (!join109) {
+      const join110 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
+      if (!join110) {
         throw new WorkflowIrError(`split '${split.id}' has a branch with no reachable matching join`);
       }
-      joinsReached.add(join109);
+      joinsReached.add(join110);
     }
     if (joinsReached.size !== 1) {
       throw new WorkflowIrError(`split '${split.id}' branches converge on more than one join`);
     }
     const joinId = [...joinsReached][0];
-    const join108 = nodesById.get(joinId);
-    const mode = join108.config?.mode;
+    const join109 = nodesById.get(joinId);
+    const mode = join109.config?.mode;
     if (mode && typeof mode === "object" && "quorum" in mode) {
       const n = mode.quorum;
       if (typeof n !== "number" || !Number.isInteger(n) || n < 1) {
-        throw new WorkflowIrError(`join '${join108.id}' quorum must be a positive integer`);
+        throw new WorkflowIrError(`join '${join109.id}' quorum must be a positive integer`);
       }
       if (n > branchEdges.length) {
         throw new WorkflowIrError(
-          `join '${join108.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
+          `join '${join109.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
         );
       }
     }
@@ -23996,14 +23996,14 @@ async function detectWorkspaceRepos(dir, runner = runGitCommand, timeout = DEFAU
     return [];
   }
   const { stat: stat13 } = await import("node:fs/promises");
-  const { join: join108 } = await import("node:path");
+  const { join: join109 } = await import("node:path");
   const found = [];
   const EXCLUDED_ENTRIES = /* @__PURE__ */ new Set(["node_modules", ".fusion", ".git", ".pi"]);
   for (const entry of entries) {
     if (EXCLUDED_ENTRIES.has(entry)) continue;
-    const childDir = join108(dir, entry);
+    const childDir = join109(dir, entry);
     try {
-      const s3 = await stat13(join108(childDir, ".git"));
+      const s3 = await stat13(join109(childDir, ".git"));
       if (!s3.isDirectory() && !s3.isFile()) continue;
     } catch {
       continue;
@@ -24016,9 +24016,9 @@ async function detectWorkspaceRepos(dir, runner = runGitCommand, timeout = DEFAU
 }
 async function isWorkspaceModeExplicitlyDisabled(projectPath) {
   try {
-    const { readFile: readFile46 } = await import("node:fs/promises");
-    const { join: join108 } = await import("node:path");
-    const raw = await readFile46(join108(projectPath, ".fusion", "config.json"), "utf-8");
+    const { readFile: readFile47 } = await import("node:fs/promises");
+    const { join: join109 } = await import("node:path");
+    const raw = await readFile47(join109(projectPath, ".fusion", "config.json"), "utf-8");
     const config3 = JSON.parse(raw);
     return config3.settings?.workspaceMode === false;
   } catch {
@@ -24026,12 +24026,12 @@ async function isWorkspaceModeExplicitlyDisabled(projectPath) {
   }
 }
 async function setWorkspaceModeInConfig(projectPath, value) {
-  const { readFile: readFile46, writeFile: writeFile35, mkdir: mkdir32 } = await import("node:fs/promises");
-  const { join: join108 } = await import("node:path");
-  const configPath = join108(projectPath, ".fusion", "config.json");
+  const { readFile: readFile47, writeFile: writeFile35, mkdir: mkdir32 } = await import("node:fs/promises");
+  const { join: join109 } = await import("node:path");
+  const configPath = join109(projectPath, ".fusion", "config.json");
   let config3 = {};
   try {
-    config3 = JSON.parse(await readFile46(configPath, "utf-8"));
+    config3 = JSON.parse(await readFile47(configPath, "utf-8"));
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
@@ -24040,7 +24040,7 @@ async function setWorkspaceModeInConfig(projectPath, value) {
   }
   const settings = config3.settings;
   settings.workspaceMode = value;
-  await mkdir32(join108(projectPath, ".fusion"), { recursive: true });
+  await mkdir32(join109(projectPath, ".fusion"), { recursive: true });
   await writeFile35(configPath, JSON.stringify(config3, null, 2), "utf-8");
 }
 function isInRootRelativePath(entry, pathMod) {
@@ -24053,12 +24053,12 @@ function isInRootRelativePath(entry, pathMod) {
   return true;
 }
 async function loadWorkspaceConfig(rootDir) {
-  const { readFile: readFile46 } = await import("node:fs/promises");
+  const { readFile: readFile47 } = await import("node:fs/promises");
   const pathMod = await import("node:path");
-  const { join: join108 } = pathMod;
-  const configPath = join108(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME);
+  const { join: join109 } = pathMod;
+  const configPath = join109(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME);
   try {
-    const raw = await readFile46(configPath, "utf-8");
+    const raw = await readFile47(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object" && "repos" in parsed && Array.isArray(parsed.repos) && parsed.repos.every((r) => typeof r === "string")) {
       const rawRepos = parsed.repos;
@@ -24072,11 +24072,11 @@ async function loadWorkspaceConfig(rootDir) {
 }
 async function saveWorkspaceConfig(rootDir, config3) {
   const { mkdir: mkdir32, writeFile: writeFile35 } = await import("node:fs/promises");
-  const { join: join108 } = await import("node:path");
-  const fusionDir = join108(rootDir, ".fusion");
+  const { join: join109 } = await import("node:path");
+  const fusionDir = join109(rootDir, ".fusion");
   await mkdir32(fusionDir, { recursive: true });
   await writeFile35(
-    join108(fusionDir, WORKSPACE_CONFIG_FILENAME),
+    join109(fusionDir, WORKSPACE_CONFIG_FILENAME),
     JSON.stringify(config3, null, 2),
     "utf-8"
   );
@@ -38905,11 +38905,11 @@ async function rekeyFallbackProjectPartition(db, fallbackProjectId, registeredPr
       const parentKey = `${fk.parentSchema}.${fk.parentTable}`;
       if (!targetKeys.has(parentKey)) continue;
       const childTarget = targetKeys.has(`${fk.childSchema}.${fk.childTable}`);
-      const join108 = fk.childColumns.map((column, index2) => `child.${quoteIdentifier(column)} IS NOT DISTINCT FROM parent.${quoteIdentifier(fk.parentColumns[index2])}`).join(" AND ");
+      const join109 = fk.childColumns.map((column, index2) => `child.${quoteIdentifier(column)} IS NOT DISTINCT FROM parent.${quoteIdentifier(fk.parentColumns[index2])}`).join(" AND ");
       const registeredChildScope = childTarget ? ` AND child.${quoteIdentifier("project_id")} = ${quoteLiteral(registeredProjectId)}` : "";
       const unreplaced = await tx.execute(sql.raw(`SELECT EXISTS (
         SELECT 1 FROM ${relationName({ schema: fk.childSchema, table: fk.childTable })} child
-        JOIN ${relationName({ schema: fk.parentSchema, table: fk.parentTable })} parent ON ${join108}
+        JOIN ${relationName({ schema: fk.parentSchema, table: fk.parentTable })} parent ON ${join109}
         JOIN fusion_rekey_conflict_candidates parent_candidate
           ON parent_candidate.schema_name = ${quoteLiteral(fk.parentSchema)}
          AND parent_candidate.table_name = ${quoteLiteral(fk.parentTable)}
@@ -49746,8 +49746,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static async parseFile(filePath) {
-        const { readFile: readFile46 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
-        const data = await readFile46(filePath, "utf8");
+        const { readFile: readFile47 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
+        const data = await readFile47(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -132671,8 +132671,8 @@ var require_graceful_fs = __commonJS({
       fs10.createReadStream = createReadStream;
       fs10.createWriteStream = createWriteStream;
       var fs$readFile = fs10.readFile;
-      fs10.readFile = readFile46;
-      function readFile46(path10, options, cb) {
+      fs10.readFile = readFile47;
+      function readFile47(path10, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path10, options, cb);
@@ -135388,10 +135388,10 @@ async function runHoldReleaseSweep(store, deps) {
   }
   return result2;
 }
-async function issueRelease(store, deps, task, target, ir2) {
+async function issueRelease(store, deps, task, target, ir2, options = {}) {
   const targetColumn = findColumn2(ir2, target);
   const targetIsProcessing = targetColumn ? resolveColumnFlags(targetColumn).countsTowardWip === true : false;
-  if (targetIsProcessing && await isUnplannedForExecution(store, task, ir2)) {
+  if (targetIsProcessing && !options.allowUnplanned && await isUnplannedForExecution(store, task, ir2)) {
     schedulerLog.log(`Hold release for ${task.id} blocked \u2014 card is unplanned and cannot enter processing column ${target}`);
     return false;
   }
@@ -135433,7 +135433,7 @@ async function issueRelease(store, deps, task, target, ir2) {
     return false;
   }
 }
-async function promoteHeldTask(store, taskId, deps = {}) {
+async function promoteHeldTask(store, taskId, deps = {}, options = {}) {
   const task = await store.getTask(taskId);
   if (!task) return { released: false, rejection: "task-not-found" };
   const ir2 = await resolveWorkflowIrForTask(store, taskId);
@@ -135444,17 +135444,50 @@ async function promoteHeldTask(store, taskId, deps = {}) {
   if (!target) return { released: false, rejection: "no-release-target" };
   const targetColumn = findColumn2(ir2, target);
   const targetIsProcessing = targetColumn ? resolveColumnFlags(targetColumn).countsTowardWip === true : false;
-  if (targetIsProcessing && await isUnplannedForExecution(store, task, ir2)) {
+  const unplanned = targetIsProcessing && await isUnplannedForExecution(store, task, ir2);
+  if (unplanned && options.force !== true) {
     return { released: false, rejection: "unplanned-for-execution", toColumn: target };
   }
+  let promoted = task;
+  if (unplanned) {
+    if (task.status === "needs-replan" || task.status === "plan-review-unavailable") {
+      try {
+        await store.updateTask(task.id, { status: null });
+        promoted = { ...task, status: void 0 };
+      } catch (error3) {
+        schedulerLog.warn(
+          `Force-promote for ${task.id} could not clear replan status: ${error3 instanceof Error ? error3.message : String(error3)}`
+        );
+      }
+    }
+    if (typeof store.recordRunAuditEvent === "function") {
+      try {
+        await store.recordRunAuditEvent({
+          domain: "database",
+          mutationType: "task:promote-forced-unplanned",
+          target: task.id,
+          taskId: task.id,
+          agentId: "system",
+          runId: `promote-force-${task.id}`,
+          metadata: { fromColumn: task.column, toColumn: target, priorStatus: task.status ?? null }
+        });
+      } catch {
+      }
+    }
+    schedulerLog.log(`Force-promote for ${task.id} bypassing unplanned gate into ${target} (operator override)`);
+  }
   const released = await issueRelease(
     store,
     { now: () => Date.now(), reserveSlot: deps.reserveSlot, allocateWorktree: deps.allocateWorktree },
-    task,
+    promoted,
     target,
-    ir2
+    ir2,
+    { allowUnplanned: unplanned }
   );
-  return released ? { released: true, toColumn: target } : { released: false, rejection: "capacity-exhausted-or-no-slot" };
+  if (!released) {
+    return { released: false, rejection: "capacity-exhausted-or-no-slot" };
+  }
+  return { released: true, toColumn: target, forcedUnplanned: unplanned || void 0 };
 }
 async function releaseHeldTaskByEvent(store, taskId, eventTag, deps = {}) {
   const task = await store.getTask(taskId);
@@ -138568,6 +138601,12 @@ var init_usage_limit_detector = __esm({
 });
 
 // ../engine/src/transient-error-patterns.ts
+function isSessionContentionError(errorMessage2) {
+  if (!errorMessage2 || typeof errorMessage2 !== "string") {
+    return false;
+  }
+  return SESSION_CONTENTION_PATTERNS.some((pattern) => pattern.test(errorMessage2));
+}
 function isTransientError(errorMessage2) {
   if (!errorMessage2 || typeof errorMessage2 !== "string") {
     return false;
@@ -138575,6 +138614,9 @@ function isTransientError(errorMessage2) {
   if (isTransientAuthCredentialError(errorMessage2)) {
     return true;
   }
+  if (isSessionContentionError(errorMessage2)) {
+    return true;
+  }
   return TRANSIENT_ERROR_PATTERNS.some((pattern) => pattern.test(errorMessage2));
 }
 function isTransientAuthCredentialError(errorMessage2) {
@@ -138586,7 +138628,7 @@ function isTransientAuthCredentialError(errorMessage2) {
   }
   return TRANSIENT_AUTH_CREDENTIAL_ROTATION_PATTERN.test(errorMessage2);
 }
-var TRANSIENT_ERROR_PATTERNS, TRANSIENT_AUTH_CREDENTIAL_ROTATION_PATTERN, OPERATOR_ACTIONABLE_AUTH_EXCLUSION_PATTERN;
+var TRANSIENT_ERROR_PATTERNS, SESSION_CONTENTION_PATTERNS, TRANSIENT_AUTH_CREDENTIAL_ROTATION_PATTERN, OPERATOR_ACTIONABLE_AUTH_EXCLUSION_PATTERN;
 var init_transient_error_patterns = __esm({
   "../engine/src/transient-error-patterns.ts"() {
     "use strict";
@@ -138647,6 +138689,14 @@ var init_transient_error_patterns = __esm({
       /\bACP failed to start\b/i,
       /\bACP session has no live connection\b/i
     ];
+    SESSION_CONTENTION_PATTERNS = [
+      // ActiveSessionPathHeldByForeignTaskError (active-session-registry.ts)
+      /active-session path\s+\S+\s+is held by task\s+\S+/i,
+      // WorkspaceRepoAcquireBusyError (worktree-acquisition.ts)
+      /workspace sub-repo\s+\S+\s+acquisition is in progress for task\s+\S+/i,
+      // WorkspaceRepoLandBusyError (merger-ai.ts)
+      /workspace sub-repo\s+\S+\s+land is in progress for task\s+\S+/i
+    ];
     TRANSIENT_AUTH_CREDENTIAL_ROTATION_PATTERN = /"type":\s*"authentication_error"|invalid authentication credentials|token[_\s]?expired/i;
     OPERATOR_ACTIONABLE_AUTH_EXCLUSION_PATTERN = /oauth token does not meet scope|insufficient[_\s-]?scope|invalid[_\s-]?scope|invalid (?:api[_\s-]?key|x-api-key)|missing\s+(?:\S+\s+)?(?:api[_\s-]?)?key|revoked|suspend(?:ed)?|disabled|deactivated|subscription|account (?:is )?(?:locked|closed|inactive)|access denied/i;
   }
@@ -138655,6 +138705,9 @@ var init_transient_error_patterns = __esm({
 // ../engine/src/transient-error-detector.ts
 function isNonPlanDefectPlanReviewFailure(input) {
   if (input.verdict === "REVISE") return false;
+  if (input.failureValue?.trim().toLowerCase() === "session-contention-hold" || (input.errorMessage ? isSessionContentionError(input.errorMessage) : false)) {
+    return false;
+  }
   const failureValue = input.failureValue?.trim().toLowerCase();
   if (failureValue === "exception" || failureValue === "aborted") return true;
   const errorMessage2 = input.errorMessage?.trim();
@@ -161607,6 +161660,86 @@ var init_research_step_runner = __esm({
   }
 });
 
+// ../engine/src/plan-artifact-writeback.ts
+import { readFile as readFile29 } from "node:fs/promises";
+import { join as join61 } from "node:path";
+function relativePromptPath(taskId) {
+  return `.fusion/tasks/${taskId}/PROMPT.md`;
+}
+async function readIfPresent(path10) {
+  try {
+    return await readFile29(path10, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function reconcileWorktreePlanArtifact(options) {
+  const { store, taskId, rootDir, planningCwd, logger: logger3 } = options;
+  const relPath = relativePromptPath(taskId);
+  const rootContent = await readIfPresent(join61(rootDir, relPath));
+  if (planningCwd === rootDir) {
+    return { outcome: "not-worktree", content: rootContent ?? void 0 };
+  }
+  const worktreeContent = await readIfPresent(join61(planningCwd, relPath));
+  if (worktreeContent === null) {
+    return { outcome: "no-worktree-artifact", content: rootContent ?? void 0 };
+  }
+  if (worktreeContent.trim().length === 0) {
+    return { outcome: "worktree-artifact-empty", content: rootContent ?? void 0 };
+  }
+  if (rootContent === worktreeContent) {
+    return { outcome: "already-authoritative", content: rootContent };
+  }
+  try {
+    await store.updateTask(taskId, { prompt: worktreeContent });
+    logger3?.log?.(
+      `${taskId}: recovered a worktree-local PROMPT.md into the project .fusion folder (${planningCwd})`
+    );
+    return { outcome: "recovered", content: worktreeContent };
+  } catch (error3) {
+    const message = error3 instanceof Error ? error3.message : String(error3);
+    logger3?.warn?.(
+      `${taskId}: failed to copy the worktree-local PROMPT.md back into the project .fusion folder: ${message}`
+    );
+    return { outcome: "recovery-failed", content: rootContent ?? void 0 };
+  }
+}
+async function mirrorPlanToProjectDb(store, taskId, content, options = {}) {
+  if (content.trim().length === 0) return false;
+  if (typeof store.upsertTaskDocument !== "function") return false;
+  try {
+    if (typeof store.getTaskDocument === "function") {
+      const existing = await store.getTaskDocument(taskId, PLAN_DOCUMENT_KEY);
+      if (typeof existing?.content === "string" && existing.content === content) return false;
+    }
+    await store.upsertTaskDocument(taskId, {
+      key: PLAN_DOCUMENT_KEY,
+      content,
+      author: options.author ?? "agent"
+    });
+    return true;
+  } catch (error3) {
+    const message = error3 instanceof Error ? error3.message : String(error3);
+    options.logger?.warn?.(`${taskId}: failed to mirror the plan into the project database: ${message}`);
+    return false;
+  }
+}
+async function persistPlanArtifact(options) {
+  const result2 = await reconcileWorktreePlanArtifact(options);
+  const mirrored = result2.content ? await mirrorPlanToProjectDb(options.store, options.taskId, result2.content, {
+    author: options.author,
+    logger: options.logger
+  }) : false;
+  return { ...result2, mirrored };
+}
+var PLAN_DOCUMENT_KEY;
+var init_plan_artifact_writeback = __esm({
+  "../engine/src/plan-artifact-writeback.ts"() {
+    "use strict";
+    PLAN_DOCUMENT_KEY = "plan";
+  }
+});
+
 // ../engine/src/auto-recovery-handlers/message-delivery.ts
 import { setTimeout as delay2 } from "node:timers/promises";
 var baseLog, MessageDeliveryAutoRecoveryHandler;
@@ -163109,6 +163242,23 @@ var init_worktrunk_installer = __esm({
 });
 
 // ../engine/src/active-session-registry.ts
+function acquireActiveSessionPath(registry3, path10, registration, options = {}) {
+  const existing = registry3.lookupByPath(path10);
+  if (!existing || existing.taskId === registration.taskId) {
+    registry3.registerPath(path10, registration);
+    return { action: "registered" };
+  }
+  const now = options.now?.() ?? Date.now();
+  const ageMs = now - existing.registeredAt;
+  const minIdleMs = options.minIdleMs ?? DEFAULT_SELF_OWNED_MIN_IDLE_MS;
+  const holderIsLive = options.holderLiveProbe?.(existing.taskId, path10) ?? true;
+  if (holderIsLive || ageMs < minIdleMs) {
+    return { action: "contended", holderTaskId: existing.taskId, holderKind: existing.kind, ageMs };
+  }
+  registry3.unregisterPath(path10);
+  registry3.registerPath(path10, registration);
+  return { action: "reclaimed-stale-foreign", holderTaskId: existing.taskId, ageMs };
+}
 function reconcileSelfOwnedActiveSessionForRemoval(registry3, worktreePath, requestingTaskId, liveBindingProbe, options = {}) {
   const record2 = registry3.lookupByPath(worktreePath);
   if (!record2) {
@@ -163599,7 +163749,7 @@ var init_worktree_prune = __esm({
 
 // ../engine/src/worktree-stale-lock.ts
 import { exec as exec8 } from "node:child_process";
-import { readFile as readFile30, stat as stat8, unlink as unlink9 } from "node:fs/promises";
+import { readFile as readFile31, stat as stat8, unlink as unlink9 } from "node:fs/promises";
 import { dirname as dirname23, resolve as resolve26 } from "node:path";
 import { promisify as promisify12 } from "node:util";
 function parseIndexLockPath(stderr) {
@@ -163624,7 +163774,7 @@ async function resolveOwningWorktreePath(input) {
   if (!worktreeName) return void 0;
   const gitdirFile = resolve26(dirname23(input.lockPath), "gitdir");
   try {
-    const gitdirRef = (await readFile30(gitdirFile, "utf-8")).trim();
+    const gitdirRef = (await readFile31(gitdirFile, "utf-8")).trim();
     if (gitdirRef) {
       const resolvedGitdirRef = resolve26(dirname23(gitdirFile), gitdirRef);
       if (resolvedGitdirRef.endsWith("/.git") || resolvedGitdirRef.endsWith("\\.git")) {
@@ -165003,7 +165153,7 @@ import { exec as exec11, execFile as execFile9 } from "node:child_process";
 import { promisify as promisify15 } from "node:util";
 import { existsSync as existsSync47, lstatSync as lstatSync2, readdirSync as readdirSync7, readFileSync as readFileSync16, rmSync as rmSync5, realpathSync as realpathSync6 } from "node:fs";
 import { mkdir as mkdir24 } from "node:fs/promises";
-import { basename as basename15, dirname as dirname24, join as join61, relative as relative8, resolve as resolve29, isAbsolute as isAbsolute9 } from "node:path";
+import { basename as basename15, dirname as dirname24, join as join62, relative as relative8, resolve as resolve29, isAbsolute as isAbsolute9 } from "node:path";
 async function getWorktrunkBinary(settings) {
   const cacheKey = `${process.env.HOME ?? ""}::${settings.binaryPath ?? ""}`;
   const cached2 = _worktrunkBinaryCache.get(cacheKey);
@@ -165154,7 +165304,7 @@ async function isRegisteredGitWorktree2(rootDir, worktreePath) {
   return (await getRegisteredWorktreePaths(rootDir)).has(canonicalizePath(worktreePath));
 }
 function hasRequiredWorktreeFiles(worktreePath) {
-  return existsSync47(join61(worktreePath, ".git"));
+  return existsSync47(join62(worktreePath, ".git"));
 }
 async function isInsideGitWorkTree2(worktreePath) {
   try {
@@ -165287,7 +165437,7 @@ async function scanIdleWorktrees(rootDir, store, settings) {
   let dirs;
   try {
     const entries = readdirSync7(worktreesDir, { withFileTypes: true });
-    dirs = entries.filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join61(worktreesDir, e.name));
+    dirs = entries.filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join62(worktreesDir, e.name));
   } catch (err) {
     const errorMessage2 = err instanceof Error ? err.message : String(err);
     worktreePoolLog.warn(`Failed to read .worktrees/ directory: ${errorMessage2}`);
@@ -165319,7 +165469,7 @@ async function cleanupOrphanedWorktrees(rootDir, store, settings) {
   let dirs = [];
   if (existsSync47(worktreesDir)) {
     try {
-      dirs = readdirSync7(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join61(worktreesDir, e.name));
+      dirs = readdirSync7(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join62(worktreesDir, e.name));
     } catch (err) {
       const errorMessage2 = err instanceof Error ? err.message : String(err);
       worktreePoolLog.warn(`Failed to read .worktrees/ directory for cleanup: ${errorMessage2}`);
@@ -165397,11 +165547,11 @@ async function reapOrphanWorktrees(projectRoot, settings) {
     entries = readdirSync7(worktreesDir, { withFileTypes: true }).filter((e) => {
       if (!e.isDirectory() || isAiMergeContainerDir(e.name)) return false;
       try {
-        return lstatSync2(join61(worktreesDir, e.name)).isDirectory() && !lstatSync2(join61(worktreesDir, e.name)).isSymbolicLink();
+        return lstatSync2(join62(worktreesDir, e.name)).isDirectory() && !lstatSync2(join62(worktreesDir, e.name)).isSymbolicLink();
       } catch {
         return false;
       }
-    }).map((e) => ({ name: e.name, fullPath: join61(worktreesDir, e.name) }));
+    }).map((e) => ({ name: e.name, fullPath: join62(worktreesDir, e.name) }));
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     worktreePoolLog.warn(`reapOrphanWorktrees: failed to read .worktrees/ \u2014 ${msg}`);
@@ -165420,7 +165570,7 @@ async function reapOrphanWorktrees(projectRoot, settings) {
     if (registered2.has(resolvedFull)) {
       continue;
     }
-    const dotGit = join61(resolvedFull, ".git");
+    const dotGit = join62(resolvedFull, ".git");
     if (existsSync47(dotGit)) {
       if (!dotGitPointerIsDangling(dotGit)) {
         worktreePoolLog.log(`reapOrphanWorktrees: skipping ${name2} (has .git entry but not in registered list \u2014 may be partially registered)`);
@@ -165786,27 +165936,27 @@ var init_worktree_pool = __esm({
 
 // ../engine/src/worktree-paths.ts
 import { homedir as homedir10 } from "node:os";
-import { basename as basename16, isAbsolute as isAbsolute10, join as join62, relative as relative9, resolve as resolve30 } from "node:path";
+import { basename as basename16, isAbsolute as isAbsolute10, join as join63, relative as relative9, resolve as resolve30 } from "node:path";
 function isAiMergeContainerDir(name2) {
   return name2 === AI_MERGE_DIRNAME;
 }
 function resolveAiMergeRootPath(rootDir, settings) {
-  return join62(resolveWorktreesDir(rootDir, settings), AI_MERGE_DIRNAME);
+  return join63(resolveWorktreesDir(rootDir, settings), AI_MERGE_DIRNAME);
 }
 function resolveLegacyAiMergeRootPath(rootDir) {
-  return join62(rootDir, ".fusion", "ai-merge");
+  return join63(rootDir, ".fusion", "ai-merge");
 }
 function resolveWorktreesDir(rootDir, settings) {
   const configured = settings?.worktreesDir;
   if (!configured) {
-    return join62(rootDir, ".worktrees");
+    return join63(rootDir, ".worktrees");
   }
   const expandedHome = configured.replace(/^~(?=$|[\\/])/, homedir10());
   const expandedRepo = expandedHome.replaceAll("{repo}", basename16(rootDir));
   return resolve30(rootDir, expandedRepo);
 }
 function resolveTaskWorktreePath(rootDir, settings, worktreeName) {
-  return join62(resolveWorktreesDir(rootDir, settings), worktreeName);
+  return join63(resolveWorktreesDir(rootDir, settings), worktreeName);
 }
 async function resolveTaskWorktreePathForBackend(rootDir, worktreeName, settings, backend, branch) {
   if (backend.kind === "worktrunk" && backend.resolveWorktreePath) {
@@ -166920,9 +167070,9 @@ function assertInRootRepoRelPath(repoRelPath, sep17, isAbsolute27, normalize8) {
 async function acquireWorkspaceRepoWorktree(opts) {
   const { repoRelPath, workspaceRootDir, task, store, settings, logger: logger3, secretsStore, audit, runContext, runConfiguredCommand: runConfiguredCommand2, taskEnv } = opts;
   const registry3 = opts.registry ?? activeSessionRegistry;
-  const { join: join108, isAbsolute: isAbsolute27, normalize: normalize8, sep: sep17 } = await import("node:path");
+  const { join: join109, isAbsolute: isAbsolute27, normalize: normalize8, sep: sep17 } = await import("node:path");
   assertInRootRepoRelPath(repoRelPath, sep17, isAbsolute27, normalize8);
-  const repoAbsPath = join108(workspaceRootDir, repoRelPath);
+  const repoAbsPath = join109(workspaceRootDir, repoRelPath);
   const existing = task.workspaceWorktrees?.[repoRelPath];
   if (existing) {
     let live = existsSync49(existing.worktreePath);
@@ -168646,7 +168796,7 @@ import { execFile as execFile11 } from "node:child_process";
 import { createRequire as createRequire6 } from "node:module";
 import { mkdtemp, rm as rm7, writeFile as writeFile24 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join63 } from "node:path";
+import { join as join64 } from "node:path";
 function getTransformSync() {
   if (!cachedTransformSync) {
     const req = createRequire6(import.meta.url);
@@ -168733,9 +168883,9 @@ function readStdin() {
 async function runCodeNode(opts) {
   const timeoutMs = resolveCodeNodeTimeout(opts.timeoutMs);
   const compiled = await compileCodeNodeSource(opts.source);
-  const dir = await mkdtemp(join63(tmpdir4(), "fusion-code-node-"));
-  const userModuleFile = join63(dir, "user.mjs");
-  const harnessFile = join63(dir, "harness.mjs");
+  const dir = await mkdtemp(join64(tmpdir4(), "fusion-code-node-"));
+  const userModuleFile = join64(dir, "user.mjs");
+  const harnessFile = join64(dir, "harness.mjs");
   try {
     await writeFile24(userModuleFile, compiled, "utf8");
     await writeFile24(harnessFile, buildChildHarness(userModuleFile), "utf8");
@@ -168963,11 +169113,11 @@ var init_code_node_runner = __esm({
 });
 
 // ../engine/src/agent-tools.ts
-import { appendFile as appendFile3, mkdir as mkdir26, readFile as readFile31, readdir as readdir9, realpath, stat as stat9, writeFile as writeFile25 } from "node:fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir26, readFile as readFile32, readdir as readdir9, realpath, stat as stat9, writeFile as writeFile25 } from "node:fs/promises";
 import { existsSync as existsSync50 } from "node:fs";
 import { createHash as createHash16, randomUUID as randomUUID45 } from "node:crypto";
 import { tmpdir as tmpdir5 } from "node:os";
-import { extname as extname3, isAbsolute as isAbsolute12, join as join64, relative as relative11, resolve as resolve32, sep as sep9 } from "node:path";
+import { extname as extname3, isAbsolute as isAbsolute12, join as join65, relative as relative11, resolve as resolve32, sep as sep9 } from "node:path";
 import { Type as Type2 } from "@earendil-works/pi-ai";
 function sanitizeAgentMemoryId(agentId) {
   return agentId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
@@ -168979,16 +169129,16 @@ function agentDreamsDisplayPath(agentId) {
   return `${AGENT_MEMORY_ROOT3}/${sanitizeAgentMemoryId(agentId)}/${AGENT_DREAMS_FILENAME2}`;
 }
 function agentMemoryDirectory(rootDir, agentId) {
-  return join64(rootDir, AGENT_MEMORY_ROOT3, sanitizeAgentMemoryId(agentId));
+  return join65(rootDir, AGENT_MEMORY_ROOT3, sanitizeAgentMemoryId(agentId));
 }
 function agentMemoryFilePath(rootDir, agentId) {
-  return join64(agentMemoryDirectory(rootDir, agentId), AGENT_MEMORY_FILENAME2);
+  return join65(agentMemoryDirectory(rootDir, agentId), AGENT_MEMORY_FILENAME2);
 }
 function agentDreamsFilePath(rootDir, agentId) {
-  return join64(agentMemoryDirectory(rootDir, agentId), AGENT_DREAMS_FILENAME2);
+  return join65(agentMemoryDirectory(rootDir, agentId), AGENT_DREAMS_FILENAME2);
 }
 function agentDailyFilePath(rootDir, agentId, date5 = /* @__PURE__ */ new Date()) {
-  return join64(agentMemoryDirectory(rootDir, agentId), `${date5.toISOString().slice(0, 10)}.md`);
+  return join65(agentMemoryDirectory(rootDir, agentId), `${date5.toISOString().slice(0, 10)}.md`);
 }
 async function readAgentMemoryWorkspaceLongTerm(rootDir, agentId) {
   const safeRoot = typeof rootDir === "string" ? rootDir.trim() : "";
@@ -169002,7 +169152,7 @@ async function readAgentMemoryWorkspaceLongTerm(rootDir, agentId) {
     if (!fileStat.isFile()) {
       return "";
     }
-    const content = await readFile31(filePath, "utf-8");
+    const content = await readFile32(filePath, "utf-8");
     return typeof content === "string" ? content.trim() : "";
   } catch {
     return "";
@@ -169081,7 +169231,7 @@ async function listAgentMemoryFiles2(rootDir, agentMemory) {
   }
   for (const entry of entries) {
     if (!DAILY_AGENT_MEMORY_RE2.test(entry)) continue;
-    const absPath = join64(dir, entry);
+    const absPath = join65(dir, entry);
     const fileStat = await stat9(absPath);
     if (fileStat.isFile()) {
       files.push({
@@ -169104,7 +169254,7 @@ async function searchAgentMemoryFile(rootDir, agentMemory, query, limit) {
   }
   const results = [];
   for (const file of await listAgentMemoryFiles2(rootDir, agentMemory)) {
-    const content = await readFile31(file.absPath, "utf-8");
+    const content = await readFile32(file.absPath, "utf-8");
     const lines = content.split("\n");
     for (let index2 = 0; index2 < lines.length; index2 += 8) {
       const chunk = lines.slice(index2, index2 + 12).join("\n").trim();
@@ -169250,7 +169400,7 @@ function resolveAgentMemoryPath(rootDir, agentId, path10) {
     return null;
   }
   return {
-    absPath: join64(agentMemoryDirectory(rootDir, agentId), filename),
+    absPath: join65(agentMemoryDirectory(rootDir, agentId), filename),
     displayPath: `${prefix}${filename}`
   };
 }
@@ -169260,7 +169410,7 @@ async function getAgentMemoryWindow(rootDir, agentMemory, path10, startLine = 1,
     return null;
   }
   await syncAgentMemoryFile(rootDir, agentMemory);
-  const content = await readFile31(resolved.absPath, "utf-8");
+  const content = await readFile32(resolved.absPath, "utf-8");
   const lines = content.split("\n");
   const start = Math.max(1, Math.floor(startLine));
   const count2 = Math.max(1, Math.min(Math.floor(lineCount), 200));
@@ -169919,6 +170069,9 @@ function createTaskPromptWriteTool(store, taskId, runContext) {
         if (persisted?.prompt !== params.content) {
           throw new Error("authoritative PROMPT.md read-back did not match the requested content; persistence could not be verified");
         }
+        await mirrorPlanToProjectDb(store, taskId, params.content, {
+          author: runContext?.agentId ?? "agent"
+        });
         return {
           content: [{ type: "text", text: `Updated PROMPT.md for ${taskId}.` }],
           details: {}
@@ -170207,7 +170360,7 @@ async function readArtifactFileFromPath(params, baseDir) {
   if (!mimeType) {
     throw new Error(`Could not infer a MIME type from ${resolvedPath}; pass mimeType explicitly.`);
   }
-  const data = await readFile31(canonicalPath);
+  const data = await readFile32(canonicalPath);
   if (params.type === "image") {
     if (!mimeType.startsWith("image/")) {
       throw new Error(`image artifacts require an image/* mimeType, got ${mimeType}.`);
@@ -170550,25 +170703,33 @@ function createTaskPromoteTool(store, currentTaskId) {
   return {
     name: "fn_task_promote",
     label: "Promote Held Task",
-    description: "Manually promote a held task out of its hold column, releasing it regardless of the hold's release kind (the explicit operator action a 'manual' hold waits for). Defaults to the current task. Returns the destination column, or a rejection reason when the task is not held or the destination is full.",
+    description: "Manually promote a held task out of its hold column, releasing it regardless of the hold's release kind (the explicit operator action a 'manual' hold waits for). Defaults to the current task. Returns the destination column, or a rejection reason when the task is not held or the destination is full. Pass force:true to start execution even when planning or plan review is still outstanding (that waives the plan gate and cancels the pending replan; capacity still applies).",
     parameters: taskPromoteParams,
     execute: async (_id, params) => {
       const taskId = params.task_id?.trim() || currentTaskId;
+      const force = params.force === true;
       try {
-        const outcome = await promoteHeldTask(store, taskId);
+        const outcome = await promoteHeldTask(store, taskId, {}, { force });
         if (outcome.released) {
+          const forcedNote = outcome.forcedUnplanned ? " Forced past the outstanding planning/plan review \u2014 the pending replan was cancelled." : "";
           return {
             content: [{
               type: "text",
-              text: `Promoted ${taskId} to column '${outcome.toColumn}'.`
+              text: `Promoted ${taskId} to column '${outcome.toColumn}'.${forcedNote}`
             }],
-            details: { taskId, released: true, toColumn: outcome.toColumn }
+            details: {
+              taskId,
+              released: true,
+              toColumn: outcome.toColumn,
+              forcedUnplanned: outcome.forcedUnplanned === true
+            }
           };
         }
+        const forceHint = outcome.rejection === "unplanned-for-execution" ? " Pass force:true to start execution anyway." : "";
         return {
           content: [{
             type: "text",
-            text: `ERROR: Could not promote ${taskId}: ${outcome.rejection ?? "unknown"}.`
+            text: `ERROR: Could not promote ${taskId}: ${outcome.rejection ?? "unknown"}.${forceHint}`
           }],
           details: { taskId, released: false, rejection: outcome.rejection },
           isError: true
@@ -172792,6 +172953,7 @@ var init_agent_tools = __esm({
     init_provider_registry();
     init_research_step_runner();
     init_logger3();
+    init_plan_artifact_writeback();
     init_web_fetch();
     init_agent_action_gate();
     init_message_delivery();
@@ -172971,6 +173133,19 @@ var init_agent_tools = __esm({
     taskPromoteParams = Type2.Object({
       task_id: Type2.Optional(
         Type2.String({ description: "Held task to promote. Defaults to the current task." })
+      ),
+      /*
+      FNXC:WorkflowScheduling 2026-07-25-05:40:
+      Agent-native parity with the dashboard's force-promote override: an agent that
+      has read the card and judged the pending replan / Plan Review not worth waiting
+      for can start execution anyway. Opt-in per call and never defaulted on — the
+      automatic surfaces (hold-release sweep, webhook release) still cannot force, so
+      FN-7648 holds for everything that is not an explicit promote request.
+      */
+      force: Type2.Optional(
+        Type2.Boolean({
+          description: "Start execution even when the task is still waiting on planning or plan review (rejection 'unplanned-for-execution'). Waives ONLY that gate \u2014 hold membership and downstream capacity still apply \u2014 and cancels the pending replan. Default false."
+        })
       )
     });
     workflowCreateParams = Type2.Object({
@@ -173488,7 +173663,7 @@ function hasAdvancedPastPlanning(task) {
   if (task.column === "in-progress" || task.column === "in-review" || task.column === "done" || task.column === "archived") {
     return true;
   }
-  if (task.worktree != null) {
+  if (task.firstExecutionAt != null || task.executionStartedAt != null) {
     return true;
   }
   if (task.column === "triage") {
@@ -177279,7 +177454,7 @@ Follow instructions precisely and avoid unrelated changes.`,
 
 // ../engine/src/spec-validation/task-document-references.ts
 import { access as access7 } from "node:fs/promises";
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 function normalizePathToken(token) {
   return token.replace(/^[`([{"']+/, "").replace(/[`),.;:!?\]}'"]+$/, "");
 }
@@ -177367,7 +177542,7 @@ async function detectDanglingTaskDocReferences(promptContent, opts) {
   }
   const dangling = [];
   for (const [path10, sections] of references.entries()) {
-    const absPath = join65(opts.rootDir, path10);
+    const absPath = join66(opts.rootDir, path10);
     if (await existsImpl(absPath)) continue;
     dangling.push({ path: path10, sections: Array.from(sections).sort() });
   }
@@ -177628,8 +177803,8 @@ var init_session_skill_context = __esm({
 });
 
 // ../engine/src/agent-memory-index.ts
-import { readFile as readFile32 } from "node:fs/promises";
-import { join as join66 } from "node:path";
+import { readFile as readFile33 } from "node:fs/promises";
+import { join as join67 } from "node:path";
 function clampUtf8(input, maxBytes) {
   if (Buffer.byteLength(input, "utf8") <= maxBytes) return input;
   let out = "";
@@ -177661,7 +177836,7 @@ function parseHeadings(content) {
 }
 async function buildFileSection(sectionHeader, displayPath, fsPath) {
   try {
-    const content = await readFile32(fsPath, "utf-8");
+    const content = await readFile33(fsPath, "utf-8");
     const headings = parseHeadings(content);
     const lines = [sectionHeader, `- ${displayPath}`];
     for (const entry of headings) {
@@ -177677,9 +177852,9 @@ async function buildFileSection(sectionHeader, displayPath, fsPath) {
 async function buildMemoryIndex({ rootDir, agentId }) {
   const safeAgentId = agentId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
   const agentDisplayPath = `.fusion/agent-memory/${safeAgentId}/MEMORY.md`;
-  const agentFsPath = join66(rootDir, ".fusion", "agent-memory", safeAgentId, "MEMORY.md");
+  const agentFsPath = join67(rootDir, ".fusion", "agent-memory", safeAgentId, "MEMORY.md");
   const projectDisplayPath = ".fusion/memory/MEMORY.md";
-  const projectFsPath = join66(rootDir, ".fusion", "memory", "MEMORY.md");
+  const projectFsPath = join67(rootDir, ".fusion", "memory", "MEMORY.md");
   const [agentSection, projectSection] = await Promise.all([
     buildFileSection("## Agent Memory Index (use fn_memory_search / fn_memory_get to read)", agentDisplayPath, agentFsPath),
     buildFileSection("## Project Memory Index", projectDisplayPath, projectFsPath)
@@ -177698,7 +177873,7 @@ var init_agent_memory_index = __esm({
 });
 
 // ../engine/src/agent-instructions.ts
-import { readFile as readFile33, writeFile as writeFile26, mkdir as mkdir27, access as access8 } from "node:fs/promises";
+import { readFile as readFile34, writeFile as writeFile26, mkdir as mkdir27, access as access8 } from "node:fs/promises";
 import { constants as fsConstants3 } from "node:fs";
 import { isAbsolute as isAbsolute13, resolve as resolve33, relative as relative12, normalize as normalize7, sep as sep10, dirname as dirname28 } from "node:path";
 function trimAndClamp(value, maxLength, label, agentId) {
@@ -177760,7 +177935,7 @@ async function resolveAgentHeartbeatProcedure(agent, rootDir) {
     return null;
   }
   try {
-    const content = await readFile33(filePath, "utf-8");
+    const content = await readFile34(filePath, "utf-8");
     const normalized = trimAndClamp(
       content,
       MAX_INSTRUCTIONS_TEXT_LENGTH2,
@@ -177906,7 +178081,7 @@ async function resolveAgentInstructions(agent, rootDir, ratingSummary, inclusion
     const filePath = resolveValidatedInstructionsPath(agent.instructionsPath, rootDir, agent.id);
     if (filePath) {
       try {
-        const content = await readFile33(filePath, "utf-8");
+        const content = await readFile34(filePath, "utf-8");
         const normalizedContent = trimAndClamp(
           content,
           MAX_INSTRUCTIONS_TEXT_LENGTH2,
@@ -185913,8 +186088,8 @@ var init_mission_symbol_admission = __esm({
 
 // ../engine/src/scheduler.ts
 import { existsSync as existsSync54 } from "node:fs";
-import { readFile as readFile34 } from "node:fs/promises";
-import { join as join67 } from "node:path";
+import { readFile as readFile35 } from "node:fs/promises";
+import { join as join68 } from "node:path";
 function logTaskRouting(taskId, node) {
   const message = `Task ${taskId} routed to node=${node.nodeId ?? "local"} (source=${node.source})`;
   if (node.nodeId === void 0) {
@@ -186547,16 +186722,16 @@ var init_scheduler = __esm({
         if (typeof this.store.getTasksDir !== "function") {
           return { valid: true };
         }
-        const taskDir = join67(this.store.getTasksDir(), id);
+        const taskDir = join68(this.store.getTasksDir(), id);
         if (!existsSync54(taskDir)) {
           return { valid: false, reason: "missing directory" };
         }
-        const promptPath = join67(taskDir, "PROMPT.md");
+        const promptPath = join68(taskDir, "PROMPT.md");
         if (!existsSync54(promptPath)) {
           return { valid: false, reason: "missing or empty PROMPT.md" };
         }
         try {
-          const content = await readFile34(promptPath, "utf-8");
+          const content = await readFile35(promptPath, "utf-8");
           if (!content || content.trim().length === 0) {
             return { valid: false, reason: "missing or empty PROMPT.md" };
           }
@@ -186926,7 +187101,7 @@ var init_scheduler = __esm({
           todo = (await Promise.all(
             todo.map(async (t) => {
               try {
-                const content = await readFile34(getPromptPath(this.store.getTasksDir(), t.id), "utf-8");
+                const content = await readFile35(getPromptPath(this.store.getTasksDir(), t.id), "utf-8");
                 if (isUnplannedSeedPrompt(content, t.id, t.title, t.description)) return null;
               } catch {
               }
@@ -190493,10 +190668,10 @@ var init_verification_utils = __esm({
 import { exec as exec23 } from "node:child_process";
 import { createHash as createHash18 } from "node:crypto";
 import { existsSync as existsSync55, readFileSync as readFileSync18, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 import { promisify as promisify32 } from "node:util";
 function hasInstallState(rootDir) {
-  return existsSync55(join68(rootDir, "node_modules")) || existsSync55(join68(rootDir, ".pnp.cjs"));
+  return existsSync55(join69(rootDir, "node_modules")) || existsSync55(join69(rootDir, ".pnp.cjs"));
 }
 function getConfiguredWorktreeInitCommand(settings) {
   const trimmed = settings?.worktreeInitCommand?.trim();
@@ -190505,17 +190680,17 @@ function getConfiguredWorktreeInitCommand(settings) {
 function getDependencySyncCommand(rootDir, settings) {
   const configuredCommand = getConfiguredWorktreeInitCommand(settings);
   if (configuredCommand) return configuredCommand;
-  if (existsSync55(join68(rootDir, "pnpm-lock.yaml"))) return "pnpm install --frozen-lockfile";
-  if (existsSync55(join68(rootDir, "package-lock.json"))) return "npm install";
-  if (existsSync55(join68(rootDir, "yarn.lock"))) return "yarn install --frozen-lockfile";
-  if (existsSync55(join68(rootDir, "bun.lock")) || existsSync55(join68(rootDir, "bun.lockb"))) {
+  if (existsSync55(join69(rootDir, "pnpm-lock.yaml"))) return "pnpm install --frozen-lockfile";
+  if (existsSync55(join69(rootDir, "package-lock.json"))) return "npm install";
+  if (existsSync55(join69(rootDir, "yarn.lock"))) return "yarn install --frozen-lockfile";
+  if (existsSync55(join69(rootDir, "bun.lock")) || existsSync55(join69(rootDir, "bun.lockb"))) {
     return "bun install --frozen-lockfile";
   }
   return null;
 }
 function computeLockfileHash(rootDir) {
   for (const name2 of LOCKFILE_CANDIDATES) {
-    const p2 = join68(rootDir, name2);
+    const p2 = join69(rootDir, name2);
     if (existsSync55(p2)) {
       try {
         return createHash18("sha256").update(readFileSync18(p2)).digest("hex");
@@ -190528,7 +190703,7 @@ function computeLockfileHash(rootDir) {
 }
 function readInstallMarker(rootDir) {
   try {
-    const value = readFileSync18(join68(rootDir, INSTALL_MARKER_RELPATH), "utf-8").trim();
+    const value = readFileSync18(join69(rootDir, INSTALL_MARKER_RELPATH), "utf-8").trim();
     return value || null;
   } catch {
     return null;
@@ -190536,7 +190711,7 @@ function readInstallMarker(rootDir) {
 }
 function writeInstallMarker(rootDir, hash) {
   try {
-    writeFileSync7(join68(rootDir, INSTALL_MARKER_RELPATH), hash);
+    writeFileSync7(join69(rootDir, INSTALL_MARKER_RELPATH), hash);
   } catch {
   }
 }
@@ -190627,7 +190802,7 @@ var init_merge_dependency_sync = __esm({
   "../engine/src/merge-dependency-sync.ts"() {
     "use strict";
     execAsync21 = promisify32(exec23);
-    INSTALL_MARKER_RELPATH = join68("node_modules", ".fusion-install-marker");
+    INSTALL_MARKER_RELPATH = join69("node_modules", ".fusion-install-marker");
     LOCKFILE_CANDIDATES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb", "bun.lock"];
     INSTALL_TIMEOUT_MS = 3e5;
   }
@@ -191004,7 +191179,7 @@ var init_merger_glob = __esm({
 
 // ../engine/src/merger-workspace-test-commands.ts
 import { existsSync as existsSync56, readdirSync as readdirSync9, readFileSync as readFileSync19 } from "node:fs";
-import { basename as basename18, dirname as dirname31, join as join69 } from "node:path";
+import { basename as basename18, dirname as dirname31, join as join70 } from "node:path";
 import { execSync as execSync4 } from "node:child_process";
 function quoteArg2(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
@@ -191035,14 +191210,14 @@ function resolveWorkspacePackageRoots(rootDir, globs) {
   for (const glob of globs) {
     const starIdx = glob.indexOf("*");
     if (starIdx === -1) {
-      const candidate = join69(rootDir, glob);
-      if (existsSync56(join69(candidate, "package.json"))) {
+      const candidate = join70(rootDir, glob);
+      if (existsSync56(join70(candidate, "package.json"))) {
         roots.push(glob);
       }
       continue;
     }
     const prefix = glob.slice(0, starIdx);
-    const parentDir = join69(rootDir, prefix.replace(/\/$/, ""));
+    const parentDir = join70(rootDir, prefix.replace(/\/$/, ""));
     let entries;
     try {
       entries = readdirSync9(parentDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -191051,8 +191226,8 @@ function resolveWorkspacePackageRoots(rootDir, globs) {
     }
     for (const entry of entries) {
       const relPath = `${prefix.replace(/\/$/, "")}/${entry}`;
-      const absPath = join69(rootDir, relPath);
-      if (existsSync56(join69(absPath, "package.json"))) {
+      const absPath = join70(rootDir, relPath);
+      if (existsSync56(join70(absPath, "package.json"))) {
         roots.push(relPath);
       }
     }
@@ -191075,7 +191250,7 @@ function mapChangedFilesToPackageNames(changedFiles, packageRoots, rootDir) {
     }
     if (bestRoot !== null) {
       try {
-        const pkgJsonPath = join69(rootDir, bestRoot, "package.json");
+        const pkgJsonPath = join70(rootDir, bestRoot, "package.json");
         const raw = readFileSync19(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed.name) {
@@ -191092,7 +191267,7 @@ function packageNamesForFiles(rootDir, files) {
   if (files.length === 0) return [];
   let workspaceContent;
   try {
-    workspaceContent = readFileSync19(join69(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    workspaceContent = readFileSync19(join70(rootDir, "pnpm-workspace.yaml"), "utf-8");
   } catch {
     return [];
   }
@@ -191103,7 +191278,7 @@ function packageNamesForFiles(rootDir, files) {
   return mapChangedFilesToPackageNames(files, packageRoots, rootDir);
 }
 function deriveScopedPnpmTestCommand(rootDir, baseBranch, branch) {
-  const workspacePath = join69(rootDir, "pnpm-workspace.yaml");
+  const workspacePath = join70(rootDir, "pnpm-workspace.yaml");
   let workspaceContent;
   try {
     workspaceContent = readFileSync19(workspacePath, "utf-8");
@@ -191141,7 +191316,7 @@ function deriveScopedPnpmTestCommand(rootDir, baseBranch, branch) {
 function deriveFileScopedPnpmTestCommand(rootDir, baseBranch, branch) {
   let workspaceContent;
   try {
-    workspaceContent = readFileSync19(join69(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    workspaceContent = readFileSync19(join70(rootDir, "pnpm-workspace.yaml"), "utf-8");
   } catch {
     return null;
   }
@@ -191183,7 +191358,7 @@ function deriveFileScopedPnpmTestCommand(rootDir, baseBranch, branch) {
     ];
     for (const candidate of candidates) {
       const normalized = candidate.startsWith("./") ? candidate.slice(2) : candidate;
-      if (existsSync56(join69(rootDir, normalized))) {
+      if (existsSync56(join70(rootDir, normalized))) {
         resolvedTests.add(normalized);
       }
     }
@@ -191211,7 +191386,7 @@ function deriveFileScopedPnpmTestCommand(rootDir, baseBranch, branch) {
       let name2 = bestRoot;
       try {
         const parsed = JSON.parse(
-          readFileSync19(join69(rootDir, bestRoot, "package.json"), "utf-8")
+          readFileSync19(join70(rootDir, bestRoot, "package.json"), "utf-8")
         );
         if (parsed.name) name2 = parsed.name;
       } catch {
@@ -191255,8 +191430,8 @@ function inferDefaultTestCommand(rootDir, explicitTestCommand, explicitBuildComm
     };
   }
   const buildSource = explicitBuildCommand?.trim() ? "explicit" : void 0;
-  if (existsSync56(join69(rootDir, "pnpm-lock.yaml"))) {
-    if (existsSync56(join69(rootDir, "pnpm-workspace.yaml"))) {
+  if (existsSync56(join70(rootDir, "pnpm-lock.yaml"))) {
+    if (existsSync56(join70(rootDir, "pnpm-workspace.yaml"))) {
       if (baseBranch?.trim() && branch?.trim()) {
         try {
           const scoped = deriveScopedPnpmTestCommand(rootDir, baseBranch.trim(), branch.trim());
@@ -191275,13 +191450,13 @@ function inferDefaultTestCommand(rootDir, explicitTestCommand, explicitBuildComm
     }
     return { command: "pnpm test", testSource: "inferred", buildSource };
   }
-  if (existsSync56(join69(rootDir, "yarn.lock"))) {
+  if (existsSync56(join70(rootDir, "yarn.lock"))) {
     return { command: "yarn test", testSource: "inferred", buildSource };
   }
-  if (existsSync56(join69(rootDir, "bun.lock")) || existsSync56(join69(rootDir, "bun.lockb"))) {
+  if (existsSync56(join70(rootDir, "bun.lock")) || existsSync56(join70(rootDir, "bun.lockb"))) {
     return { command: "bun test", testSource: "inferred", buildSource };
   }
-  if (existsSync56(join69(rootDir, "package-lock.json"))) {
+  if (existsSync56(join70(rootDir, "package-lock.json"))) {
     return { command: "npm test", testSource: "inferred", buildSource };
   }
   return null;
@@ -193558,7 +193733,7 @@ var init_merger_integration_worktree = __esm({
 import { execFile as execFile23, spawn as spawn7 } from "node:child_process";
 import { promisify as promisify43 } from "node:util";
 import { copyFileSync, existsSync as existsSync57, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync2, readFileSync as readFileSync20, rmSync as rmSync7, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname32, join as join70 } from "node:path";
+import { dirname as dirname32, join as join71 } from "node:path";
 import { tmpdir as tmpdir6 } from "node:os";
 async function runGit4(args, cwd, timeoutMs) {
   const result2 = await execFileAsync16("git", ["-c", "core.quotePath=false", ...args], {
@@ -193644,9 +193819,9 @@ async function syncWorktreeToHead(input) {
   if (mode === "ff-only") {
     return { kind: "skipped-dirty", fromSha: previousSha, reason: "ff-only-mode-requires-clean-tree", dirtyFiles, untrackedFiles };
   }
-  const stageDir = mkdtempSync2(join70(tmpdir6(), "fusion-worktree-sync-"));
-  const patchPath = join70(stageDir, "edits.patch");
-  const untrackedDir = join70(stageDir, "untracked");
+  const stageDir = mkdtempSync2(join71(tmpdir6(), "fusion-worktree-sync-"));
+  const patchPath = join71(stageDir, "edits.patch");
+  const untrackedDir = join71(stageDir, "untracked");
   let preserveStageDir = false;
   try {
     mkdirSync9(untrackedDir, { recursive: true });
@@ -193666,8 +193841,8 @@ async function syncWorktreeToHead(input) {
       }
     }
     for (const rel of untrackedFiles) {
-      const src = join70(worktreePath, rel);
-      const dst = join70(untrackedDir, rel);
+      const src = join71(worktreePath, rel);
+      const dst = join71(untrackedDir, rel);
       try {
         mkdirSync9(dirname32(dst), { recursive: true });
         copyFileSync(src, dst);
@@ -193730,13 +193905,13 @@ async function syncWorktreeToHead(input) {
     const restored = [];
     const untrackedSkippedAsTracked = [];
     for (const rel of untrackedFiles) {
-      const src = join70(untrackedDir, rel);
+      const src = join71(untrackedDir, rel);
       if (!existsSync57(src)) continue;
       if (trackedAtHead.has(rel)) {
         untrackedSkippedAsTracked.push(rel);
         continue;
       }
-      const dst = join70(worktreePath, rel);
+      const dst = join71(worktreePath, rel);
       try {
         mkdirSync9(dirname32(dst), { recursive: true });
         const data = readFileSync20(src);
@@ -193805,8 +193980,8 @@ var init_worktree_ref_sync = __esm({
 
 // ../engine/src/merger-scope-auto-widen.ts
 import { exec as exec30 } from "node:child_process";
-import { readFile as readFile35, writeFile as writeFile27 } from "node:fs/promises";
-import { join as join71 } from "node:path";
+import { readFile as readFile36, writeFile as writeFile27 } from "node:fs/promises";
+import { join as join72 } from "node:path";
 import { promisify as promisify44 } from "node:util";
 function quoteArg4(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -193945,8 +194120,8 @@ function parseScopeEntries(section) {
 async function appendAutoWidenedScopeToPrompt(params) {
   const { store, taskId, files } = params;
   if (files.length === 0) return [];
-  const promptPath = join71(store.getTaskDir(taskId), "PROMPT.md");
-  const prompt = await readFile35(promptPath, "utf-8");
+  const promptPath = join72(store.getTaskDir(taskId), "PROMPT.md");
+  const prompt = await readFile36(promptPath, "utf-8");
   const { before, section, after } = splitPromptSections(prompt);
   const existing = parseScopeEntries(section);
   const toAdd = files.filter((file) => !existing.has(file));
@@ -194102,7 +194277,7 @@ import * as childProcess4 from "node:child_process";
 import { promisify as promisify45 } from "node:util";
 import { existsSync as existsSync58, readFileSync as readFileSync21, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
 import { createHash as createHash20 } from "node:crypto";
-import { join as join72, resolve as resolve36 } from "node:path";
+import { join as join73, resolve as resolve36 } from "node:path";
 import { hostname as hostname2 } from "node:os";
 import { Type as Type4 } from "typebox";
 function mergerCommitEnv() {
@@ -194415,7 +194590,7 @@ async function runDeterministicVerification(store, rootDir, taskId, testCommand,
   const deterministicVerificationMessage = "Running deterministic merge verification" + (hasTestCommand ? ` (test${testSourceDisplayLabel}: ${normalizedTestCommand})` : "") + (hasBuildCommand ? ` (build${buildSource === "inferred" ? " [inferred]" : ""}: ${normalizedBuildCommand})` : "");
   await store.logEntry(taskId, deterministicVerificationMessage);
   await store.appendAgentLog(taskId, deterministicVerificationMessage, "status", void 0, "merger");
-  const bootstrapScriptPath = join72(rootDir, "scripts/ensure-test-artifacts.mjs");
+  const bootstrapScriptPath = join73(rootDir, "scripts/ensure-test-artifacts.mjs");
   if (hasTestCommand || hasBuildCommand) {
     if (!existsSync58(bootstrapScriptPath)) {
       const bootstrapMissingMessage = `${taskId}: [verification:bootstrap] script missing at scripts/ensure-test-artifacts.mjs \u2014 skipping preamble`;
@@ -194914,7 +195089,7 @@ async function stashTreesEqual(rootDir, aSha, bSha) {
 }
 function writeActiveMergerStatus(rootDir, taskId) {
   try {
-    const statusPath = join72(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
+    const statusPath = join73(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
     const payload = {
       taskId,
       pid: process.pid,
@@ -194943,7 +195118,7 @@ function clearActiveMergerStatus(statusPath, taskId) {
 }
 function readActiveMergerStatus(rootDir) {
   try {
-    const statusPath = join72(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
+    const statusPath = join73(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
     if (!existsSync58(statusPath)) return null;
     const raw = readFileSync21(statusPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -195516,7 +195691,7 @@ async function findFilesWithConflictMarkers(rootDir, files) {
   const stillConflicted = [];
   for (const file of files) {
     try {
-      const fullPath = join72(rootDir, file);
+      const fullPath = join73(rootDir, file);
       if (!existsSync58(fullPath)) continue;
       const { stdout } = await execAsync29(
         `git grep -l -e "^<<<<<<< " -e "^=======$" -e "^>>>>>>> " --no-index -- ${quoteArg3(fullPath)}`,
@@ -195543,7 +195718,7 @@ async function tryRecoverHardFailApply(params) {
     if (!patchText.trim()) {
       mergerLog.warn(`${taskId}: autostash ${sha.slice(0, 7)} produced empty patch; cannot 3-way recover`);
     } else {
-      const patchPath = join72(rootDir, ".git", `fusion-autostash-${sha.slice(0, 7)}.patch`);
+      const patchPath = join73(rootDir, ".git", `fusion-autostash-${sha.slice(0, 7)}.patch`);
       writeFileSync9(patchPath, patchText, "utf-8");
       try {
         await execAsync29(`git apply --3way --whitespace=nowarn ${quoteArg3(patchPath)}`, { cwd: rootDir });
@@ -197031,13 +197206,13 @@ async function isCherryPickInProgress(rootDir) {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const cherryPickHeadPath = join72(rootDir, cherryPickHeadPathOut.trim());
+    const cherryPickHeadPath = join73(rootDir, cherryPickHeadPathOut.trim());
     if (existsSync58(cherryPickHeadPath)) return true;
     const { stdout: sequencerPathOut } = await execAsync29("git rev-parse --git-path sequencer", {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const sequencerPath = join72(rootDir, sequencerPathOut.trim());
+    const sequencerPath = join73(rootDir, sequencerPathOut.trim());
     return existsSync58(sequencerPath);
   } catch {
     return false;
@@ -202080,7 +202255,7 @@ import { promisify as promisify46 } from "node:util";
 import { setImmediate as setImmediateCb2 } from "node:timers";
 import { existsSync as existsSync59, mkdirSync as mkdirSync10, readdirSync as readdirSync10, readFileSync as readFileSync22, realpathSync as realpathSync7, rmSync as rmSync8, statSync as statSync10, writeFileSync as writeFileSync10 } from "node:fs";
 import { tmpdir as tmpdir7 } from "node:os";
-import { isAbsolute as isAbsolute14, join as join73, relative as relative13, resolve as resolve37 } from "node:path";
+import { isAbsolute as isAbsolute14, join as join74, relative as relative13, resolve as resolve37 } from "node:path";
 function resolveRepoLocalAiMergeRoot(rootDir, settings) {
   return resolveAiMergeRootPath(rootDir, settings);
 }
@@ -202113,9 +202288,9 @@ async function preserveWorktreeChanges(repoDir, worktreePath, taskId) {
       return null;
     }
     const diff = (await execAsync30("git diff HEAD --binary", { cwd: worktreePath, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 })).stdout;
-    const recoveryDir = join73(repoDir, ".fusion", "recovery");
+    const recoveryDir = join74(repoDir, ".fusion", "recovery");
     mkdirSync10(recoveryDir, { recursive: true });
-    const patchPath = join73(recoveryDir, `${taskId.toLowerCase()}-${formatRecoveryTimestamp()}.patch`);
+    const patchPath = join74(recoveryDir, `${taskId.toLowerCase()}-${formatRecoveryTimestamp()}.patch`);
     writeFileSync10(patchPath, diff, "utf-8");
     return patchPath;
   } catch (error3) {
@@ -202252,7 +202427,7 @@ function isNoTaskDoneFailure2(task) {
 function hasStepProgress2(task) {
   return task.steps.some((step) => step.status !== "pending");
 }
-var log28, worktreeMetadataReconcileLog, execAsync30, yieldEventLoop2, DONE_TASK_INTEGRITY_SWEEP_LIMIT, BOARD_STALL_NOTIFICATION_COOLDOWN_MS, DB_CORRUPTION_NOTIFICATION_COOLDOWN_MS, PHANTOM_EXECUTOR_BINDING_AGE_MULTIPLIER, MAX_NO_PROGRESS_RESUME_ATTEMPTS, APPROVED_TRIAGE_RECOVERY_GRACE_MS, STARVED_REFINEMENT_RECOVERY_GRACE_MS, STARVED_PEER_PROGRESS_THRESHOLD, STARVED_REFINEMENT_ESCALATION_COOLDOWN_MS, ORPHANED_EXECUTION_RECOVERY_GRACE_MS, LEAKED_WORKTREE_SLOT_GRACE_MS, NON_TERMINAL_STEP_STATUSES2, STRANDED_COMPLETED_TODO_ACTIVE_STATUSES, GHOST_REVIEW_PRESERVED_STATUSES, ORPHANED_WITH_WORKTREE_GRACE_MS, MAX_TASK_DONE_RETRIES, RECONCILE_SCOPE_OVERRIDE_MERGE_ACTIVE_STATUS_SET, MAX_STARVATION_DROPS, DEADLOCK_RECOVERY_COOLDOWN_MS, DEFAULT_STALE_MERGING_FANOUT_MIN_AGE_MS, DEFAULT_UNBACKED_MERGING_FANOUT_GRACE_MS, DURABLE_ERROR_RECOVERY_BASE_COOLDOWN_MS, DURABLE_ERROR_RECOVERY_MAX_COOLDOWN_MS, RUNNING_ON_INACTIVE_TASK_STALE_RUN_MS, SelfHealingManager;
+var log28, worktreeMetadataReconcileLog, execAsync30, yieldEventLoop2, DONE_TASK_INTEGRITY_SWEEP_LIMIT, BOARD_STALL_NOTIFICATION_COOLDOWN_MS, DB_CORRUPTION_NOTIFICATION_COOLDOWN_MS, PHANTOM_EXECUTOR_BINDING_AGE_MULTIPLIER, MAX_NO_PROGRESS_RESUME_ATTEMPTS, PRE_EXECUTION_WORKTREE_MAX_IDLE_MS, APPROVED_TRIAGE_RECOVERY_GRACE_MS, STARVED_REFINEMENT_RECOVERY_GRACE_MS, STARVED_PEER_PROGRESS_THRESHOLD, STARVED_REFINEMENT_ESCALATION_COOLDOWN_MS, ORPHANED_EXECUTION_RECOVERY_GRACE_MS, LEAKED_WORKTREE_SLOT_GRACE_MS, NON_TERMINAL_STEP_STATUSES2, STRANDED_COMPLETED_TODO_ACTIVE_STATUSES, GHOST_REVIEW_PRESERVED_STATUSES, ORPHANED_WITH_WORKTREE_GRACE_MS, MAX_TASK_DONE_RETRIES, RECONCILE_SCOPE_OVERRIDE_MERGE_ACTIVE_STATUS_SET, MAX_STARVATION_DROPS, DEADLOCK_RECOVERY_COOLDOWN_MS, DEFAULT_STALE_MERGING_FANOUT_MIN_AGE_MS, DEFAULT_UNBACKED_MERGING_FANOUT_GRACE_MS, DURABLE_ERROR_RECOVERY_BASE_COOLDOWN_MS, DURABLE_ERROR_RECOVERY_MAX_COOLDOWN_MS, RUNNING_ON_INACTIVE_TASK_STALE_RUN_MS, SelfHealingManager;
 var init_self_healing = __esm({
   "../engine/src/self-healing.ts"() {
     "use strict";
@@ -202308,6 +202483,7 @@ var init_self_healing = __esm({
     DB_CORRUPTION_NOTIFICATION_COOLDOWN_MS = 60 * 60 * 1e3;
     PHANTOM_EXECUTOR_BINDING_AGE_MULTIPLIER = 3;
     MAX_NO_PROGRESS_RESUME_ATTEMPTS = 2;
+    PRE_EXECUTION_WORKTREE_MAX_IDLE_MS = 30 * 24 * 60 * 60 * 1e3;
     APPROVED_TRIAGE_RECOVERY_GRACE_MS = 6e4;
     STARVED_REFINEMENT_RECOVERY_GRACE_MS = 10 * 6e4;
     STARVED_PEER_PROGRESS_THRESHOLD = 3;
@@ -203547,6 +203723,35 @@ var init_self_healing = __esm({
         }
         return false;
       }
+      /**
+       * FNXC:WorkflowRecovery 2026-07-25-09:40:
+       * Single shared decision for "is this branch tip's foreign `Fusion-Task-Id`/`Fusion-Task-Lineage` trailer real
+       * evidence of cross-task contamination, or just an inherited start point?"
+       *
+       * A task branch cut from the integration branch points at whatever landed last. When the task has not committed
+       * anything of its own (planning aborted, spec revise, operator move back to `todo`), the branch tip IS that
+       * previous task's commit — a foreign trailer with zero foreign intent. FN-1406 hit exactly this: `fusion/fn-1406`
+       * was cut from `main` at FN-1401's landed commit, planning ended without a commit, and the reclaim sweep logged
+       * `already-merged rejected ... owner=FN-1401 reason=foreign-task-tip` every pass instead of clearing the stale
+       * worktree/branch metadata.
+       *
+       * Merge-base-to-tip diff proof separates the two: no unique diff means the branch carries no task content, so the
+       * foreign trailer is inherited and the caller may treat the row as stale metadata. The one exception is when the
+       * base ALREADY has an explicit commit for this task — then the branch should have been sitting on the task's own
+       * landed commit, and a foreign tip is genuine misbinding worth rejecting.
+       *
+       * Callers: already-merged recovery (`branchTipForeignOwnership`), branch-misbound recovery
+       * (`isBranchTipMisboundToTask`), and the self-owned-branch reclaim sweep's `tip-already-merged` arm. Keeping the
+       * three on one helper is the point — the reclaim arm drifted without the diff proof and that was the bug.
+       */
+      async foreignTipRejection(input) {
+        const { taskId, lineageId, branchTip, baseBranch, ownership } = input;
+        if (ownership.rejectionReason !== "foreign-task" && ownership.rejectionReason !== "foreign-lineage") return null;
+        const hasNoUniqueDiff = await this.branchHasNoUniqueDiff(branchTip, baseBranch).catch(() => false);
+        const baseAlreadyHasCurrentTask = hasNoUniqueDiff ? await this.baseHasExplicitTaskOwnership(taskId, lineageId, baseBranch).catch(() => false) : false;
+        if (hasNoUniqueDiff && !baseAlreadyHasCurrentTask) return null;
+        return ownership.rejectionReason === "foreign-task" ? { reason: "foreign-task-tip", owner: ownership.ownerTaskId } : { reason: "foreign-lineage-tip", owner: ownership.ownerLineageId };
+      }
       async rejectForeignAlreadyMergedCandidate(input) {
         const { task, candidateSha, candidateOwner, taskBranch, baseBranch, reason, phase } = input;
         await this.store.logEntry(
@@ -203588,20 +203793,14 @@ var init_self_healing = __esm({
         }
         const sha = stdout.trim();
         if (!sha) return null;
-        const hasNoUniqueDiff = await this.branchHasNoUniqueDiff(sha, baseBranch).catch(() => false);
         let ownership;
         try {
           ownership = await this.readCommitTaskOwnership(sha, taskId, lineageId);
         } catch {
           return { sha, reason: "ownership-unverifiable" };
         }
-        const baseAlreadyHasCurrentTask = hasNoUniqueDiff ? await this.baseHasExplicitTaskOwnership(taskId, lineageId, baseBranch).catch(() => false) : false;
-        if ((!hasNoUniqueDiff || baseAlreadyHasCurrentTask) && ownership.rejectionReason === "foreign-task") {
-          return { sha, owner: ownership.ownerTaskId, reason: "foreign-task-tip" };
-        }
-        if ((!hasNoUniqueDiff || baseAlreadyHasCurrentTask) && ownership.rejectionReason === "foreign-lineage") {
-          return { sha, owner: ownership.ownerLineageId, reason: "foreign-lineage-tip" };
-        }
+        const rejection = await this.foreignTipRejection({ taskId, lineageId, branchTip: sha, baseBranch, ownership });
+        if (rejection) return { sha, owner: rejection.owner, reason: rejection.reason };
         return null;
       }
       async resolveSelfHealingMergeTarget(task, settings, phase) {
@@ -203948,6 +204147,8 @@ var init_self_healing = __esm({
               { name: "reconcile-workspace-partial-lands", fn: () => this.reconcileWorkspacePartialLands() },
               { name: "reclaim-phantom-workspace-land-leases", fn: () => this.reclaimPhantomWorkspaceLandLeases() },
               { name: "reconcile-orphaned-workspace-worktrees", fn: () => this.reconcileOrphanedWorkspaceWorktrees() },
+              // FNXC:PlanningEvacuation 2026-07-25-23:00: reclaim worktrees acquired at planning time by cards that never executed.
+              { name: "reconcile-pre-execution-worktrees", fn: () => this.reconcilePreExecutionWorktrees() },
               { name: "recover-merged-review", fn: () => this.recoverMergedReviewTasks() },
               { name: "recover-already-merged-review", fn: () => this.recoverAlreadyMergedReviewTasks() },
               { name: "recover-post-done-noncontinuable-wedge", fn: () => this.recoverPostDoneNonContinuableWedge() },
@@ -204815,14 +205016,21 @@ var init_self_healing = __esm({
                 if (!ownership) {
                   continue;
                 }
-                if (ownership?.rejectionReason === "foreign-task" || ownership?.rejectionReason === "foreign-lineage") {
+                const foreignRejection = await this.foreignTipRejection({
+                  taskId: task.id,
+                  lineageId: task.lineageId,
+                  branchTip: inspection.tipSha,
+                  baseBranch: inspection.integrationRef,
+                  ownership
+                });
+                if (foreignRejection) {
                   await this.rejectForeignAlreadyMergedCandidate({
                     task,
                     candidateSha: inspection.tipSha,
-                    candidateOwner: ownership.rejectionReason === "foreign-task" ? ownership.ownerTaskId : ownership.ownerLineageId,
+                    candidateOwner: foreignRejection.owner,
                     taskBranch: branchName,
                     baseBranch: inspection.integrationRef,
-                    reason: ownership.rejectionReason === "foreign-task" ? "foreign-task-tip" : "foreign-lineage-tip",
+                    reason: foreignRejection.reason,
                     phase: "tip-already-merged"
                   });
                   continue;
@@ -208762,7 +208970,7 @@ var init_self_healing = __esm({
               const unrecoverableRepos = [];
               for (const repoRel of repoKeys) {
                 const entry = workspaceWorktrees[repoRel];
-                const repoRootDir = join73(this.options.rootDir, repoRel);
+                const repoRootDir = join74(this.options.rootDir, repoRel);
                 let integrationBranch;
                 try {
                   integrationBranch = await resolveIntegrationBranch(
@@ -208974,6 +209182,58 @@ var init_self_healing = __esm({
           return 0;
         }
       }
+      /*
+        FNXC:PlanningEvacuation 2026-07-25-23:00 (pre-execution worktree sweep):
+        Planning acquires the task's own worktree, so cards that never reach execution would accumulate
+        worktrees on disk: withdrawn to an intake column, archived from a planner lane, or simply parked.
+        This sweep reclaims them.
+      
+        Candidates are addressed from task ROWS (never a directory walk — AGENTS.md forbids unbounded temp
+        scans): tasks holding `worktree` that sit in a non-executing column and carry no execution
+        timestamp. `todo` is deliberately EXCLUDED: a planned card waiting for a WIP slot legitimately
+        keeps its worktree, and churning it would just force a re-acquire minutes later. Every real safety
+        decision (live session, clean branch, execution evidence) belongs to
+        `TaskExecutor.releasePreExecutionWorktree`, so this sweep cannot diverge from the event-driven path
+        that runs on the move itself.
+        */
+      async reconcilePreExecutionWorktrees() {
+        try {
+          const release2 = this.options.releasePreExecutionWorktree;
+          if (!release2) return 0;
+          const settings = await this.store.getSettings();
+          if (settings.globalPause || settings.enginePaused) return 0;
+          const now = Date.now();
+          const parked = await this.store.listTasks({ slim: true });
+          const candidates = parked.filter((task) => {
+            if (!task.worktree || task.deletedAt) return false;
+            if (task.firstExecutionAt || task.executionStartedAt) return false;
+            if (task.column === "todo" || task.column === "in-progress" || task.column === "in-review" || task.column === "done") return false;
+            if (task.paused || task.userPaused) return false;
+            if (task.status != null) return false;
+            if (task.blockedBy || task.overlapBlockedBy || task.nextRecoveryAt) return false;
+            const lastTouchedMs = Math.max(
+              Date.parse(task.columnMovedAt ?? "") || 0,
+              Date.parse(task.updatedAt ?? "") || 0
+            );
+            if (!lastTouchedMs) return false;
+            return now - lastTouchedMs >= PRE_EXECUTION_WORKTREE_MAX_IDLE_MS;
+          });
+          if (candidates.length === 0) return 0;
+          let released = 0;
+          for (const task of candidates) {
+            try {
+              if (await release2(task.id, `parked pre-execution in '${task.column}'`)) released++;
+            } catch (err) {
+              log28.warn(`reconcilePreExecutionWorktrees: release failed for ${task.id}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+          }
+          if (released > 0) log28.log(`reconcilePreExecutionWorktrees: released ${released} pre-execution worktree(s)`);
+          return released;
+        } catch (err) {
+          log28.error(`reconcilePreExecutionWorktrees sweep failed: ${err instanceof Error ? err.message : String(err)}`);
+          return 0;
+        }
+      }
       /*
       FNXC:Workspace 2026-06-22-09:30 (Phase D U1, KTD4 — per-repo worktree cleanup from STORED paths):
       For done/dead workspace tasks, remove each recorded per-repo worktree. The paths are ADDRESSABLE
@@ -209004,7 +209264,7 @@ var init_self_healing = __esm({
               if ((this.orphanWorktreeRemovalFailures.get(worktreePath) ?? 0) >= MAX_STARVATION_DROPS) {
                 continue;
               }
-              const repoRootDir = join73(this.options.rootDir, repoRel);
+              const repoRootDir = join74(this.options.rootDir, repoRel);
               let success = false;
               let reason = "removed";
               try {
@@ -209925,7 +210185,7 @@ var init_self_healing = __esm({
         if (testWorkerRoot) {
           try {
             for (const entry of readdirSync10(testWorkerRoot)) {
-              if (entry.startsWith("redir-")) roots.push(join73(testWorkerRoot, entry));
+              if (entry.startsWith("redir-")) roots.push(join74(testWorkerRoot, entry));
             }
           } catch {
           }
@@ -209939,7 +210199,7 @@ var init_self_healing = __esm({
           } catch {
             continue;
           }
-          for (const entry of entries) paths2.push(join73(root, entry));
+          for (const entry of entries) paths2.push(join74(root, entry));
         }
         return paths2;
       }
@@ -210175,14 +210435,10 @@ var init_self_healing = __esm({
           maxBuffer: 1024 * 1024
         });
         const branchTip = tipOut.trim();
-        const hasNoUniqueDiff = await this.branchHasNoUniqueDiff(branchTip, baseBranch).catch(() => false);
         const ownership = await this.readCommitTaskOwnership(branchTip, taskId, lineageId);
-        const baseAlreadyHasCurrentTask = hasNoUniqueDiff ? await this.baseHasExplicitTaskOwnership(taskId, lineageId, baseBranch).catch(() => false) : false;
-        if ((!hasNoUniqueDiff || baseAlreadyHasCurrentTask) && ownership.rejectionReason === "foreign-task") {
-          return { misbound: false, branchTip, landed: null, rejection: { reason: "foreign-task-tip", owner: ownership.ownerTaskId } };
-        }
-        if ((!hasNoUniqueDiff || baseAlreadyHasCurrentTask) && ownership.rejectionReason === "foreign-lineage") {
-          return { misbound: false, branchTip, landed: null, rejection: { reason: "foreign-lineage-tip", owner: ownership.ownerLineageId } };
+        const rejection = await this.foreignTipRejection({ taskId, lineageId, branchTip, baseBranch, ownership });
+        if (rejection) {
+          return { misbound: false, branchTip, landed: null, rejection };
         }
         const hasTaskId = ownership.ownerTaskId === taskId;
         const hasLineage = lineageId ? ownership.ownerLineageId === lineageId : false;
@@ -211844,7 +212100,7 @@ var init_self_healing = __esm({
           let processedMarkers = 0;
           for (const task of candidates) {
             try {
-              const promptPath = join73(this.options.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+              const promptPath = join74(this.options.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
               if (!existsSync59(promptPath)) {
                 continue;
               }
@@ -212231,7 +212487,7 @@ var init_self_healing = __esm({
         if (!existsSync59(worktreesDir)) return 0;
         let dirs;
         try {
-          dirs = readdirSync10(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join73(worktreesDir, e.name));
+          dirs = readdirSync10(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join74(worktreesDir, e.name));
         } catch (err) {
           log28.warn(`Failed to read .worktrees/ for unregistered orphan reap: ${err instanceof Error ? err.message : String(err)}`);
           return 0;
@@ -212301,7 +212557,7 @@ var init_self_healing = __esm({
             }
             if (entries.length === 0) continue;
             for (const entry of entries) {
-              const path10 = join73(tempRoot, entry);
+              const path10 = join74(tempRoot, entry);
               let canonicalPath = path10;
               let cleanupReason = "stale";
               try {
@@ -212539,8 +212795,8 @@ var init_self_healing = __esm({
 // ../engine/src/triage.ts
 import { Type as Type5 } from "@earendil-works/pi-ai";
 import { exec as exec33 } from "node:child_process";
-import { readFile as readFile36, writeFile as writeFile28, rm as rm9 } from "node:fs/promises";
-import { join as join74 } from "node:path";
+import { readFile as readFile37, writeFile as writeFile28, rm as rm9 } from "node:fs/promises";
+import { join as join75 } from "node:path";
 import { promisify as promisify47 } from "node:util";
 function inlineTaskListFallback(lines, opts = {}) {
   const maxChars = Math.max(1, Math.floor(opts.maxChars ?? MAX_TASK_LIST_TEXT_CHARS));
@@ -212591,10 +212847,10 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
   if (!attachments || attachments.length === 0) {
     return { attachmentContents, imageContents };
   }
-  const { readFile: readFile46 } = await import("node:fs/promises");
-  const { join: join108 } = await import("node:path");
+  const { readFile: readFile47 } = await import("node:fs/promises");
+  const { join: join109 } = await import("node:path");
   for (const att of attachments) {
-    const filePath = join108(
+    const filePath = join109(
       rootDir,
       ".fusion",
       "tasks",
@@ -212604,7 +212860,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
     );
     try {
       if (IMAGE_MIME_TYPES.has(att.mimeType)) {
-        const data = await readFile46(filePath);
+        const data = await readFile47(filePath);
         const detectedMimeType = detectImageMimeFromBytes(data);
         const imageMimeType = detectedMimeType ?? att.mimeType;
         if (detectedMimeType && detectedMimeType !== att.mimeType) {
@@ -212621,7 +212877,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
           text: null
         });
       } else {
-        const data = await readFile46(filePath, "utf-8");
+        const data = await readFile47(filePath, "utf-8");
         const text2 = data.length > TEXT_INLINE_LIMIT ? data.slice(0, TEXT_INLINE_LIMIT) + "\n... (truncated at 50KB)" : data;
         attachmentContents.push({
           originalName: att.originalName,
@@ -212862,6 +213118,7 @@ var init_triage = __esm({
     init_prompt_layers();
     init_fallback_model_observer();
     init_logger3();
+    init_plan_artifact_writeback();
     init_mcp_resolution();
     init_usage_limit_detector();
     init_transient_error_detector();
@@ -212972,6 +213229,33 @@ var init_triage = __esm({
           if (this.processing.has(task.id) || this.hasLivePlanningWork(task.id)) return;
           this.requestImmediatePoll();
         };
+        this.taskEvacuatedFromPlanningHandler = (task) => {
+          if (!task?.id) return;
+          if (typeof task.column !== "string") return;
+          if (task.column === "todo" || task.column === "triage" || task.column === "in-progress") return;
+          if (this.activeSubagentSessions.has(task.id)) {
+            this.disposeSubagentsForTask(task.id, `task moved to ${task.column}`);
+          }
+          const session = this.activeSessions.get(task.id);
+          if (!session) return;
+          planLog.log(`task moved out of planning to '${task.column}' \u2014 terminating triage session for ${task.id}`);
+          this.pauseAborted.add(task.id);
+          this.options.stuckTaskDetector?.untrackTask(task.id);
+          const sessionWithAbort = session;
+          if (typeof sessionWithAbort.abort === "function") {
+            void sessionWithAbort.abort().catch((err) => {
+              planLog.warn(`Failed to abort triage session for ${task.id}: ${err}`);
+            });
+          }
+          this.recordTriageSessionTokenUsageSoon(task.id, session, { agentId: task.assignedAgentId ?? "triage" });
+          session.dispose();
+          this.activeSessions.delete(task.id);
+          if (task.status === "planning") {
+            void Promise.resolve(this.store.updateTask(task.id, { status: null })).catch((err) => {
+              planLog.warn(`${task.id}: failed to clear planning status after evacuation: ${err instanceof Error ? err.message : String(err)}`);
+            });
+          }
+        };
       }
       running = false;
       polling = false;
@@ -213030,6 +213314,8 @@ var init_triage = __esm({
       taskPausedHandler;
       /** FNXC:CodingIdeasWorkflow 2026-07-25-11:20: store-event wake for planning-eligible columns. */
       taskColumnWakeHandler;
+      /** FNXC:PlanningEvacuation 2026-07-25-23:00: stops planning when a card leaves the planner lanes. */
+      taskEvacuatedFromPlanningHandler;
       _approvalRequestStore;
       /**
        * @param store — Task store instance (also used to listen for `settings:updated` events)
@@ -213138,6 +213424,9 @@ var init_triage = __esm({
           this.store.on("task:updated", this.taskColumnWakeHandler);
           this.store.on("task:created", this.taskColumnWakeHandler);
         }
+        if (this.taskEvacuatedFromPlanningHandler && typeof this.store.on === "function") {
+          this.store.on("task:updated", this.taskEvacuatedFromPlanningHandler);
+        }
         this.clearStaleSpecifyingStatuses().catch((err) => {
           planLog.error("Failed to clear stale planning statuses:", err);
         });
@@ -213185,6 +213474,9 @@ var init_triage = __esm({
           this.store.off("task:updated", this.taskColumnWakeHandler);
           this.store.off("task:created", this.taskColumnWakeHandler);
         }
+        if (this.taskEvacuatedFromPlanningHandler && typeof this.store.off === "function") {
+          this.store.off("task:updated", this.taskEvacuatedFromPlanningHandler);
+        }
         this.abortAndDisposeActiveSessions("engine stop");
         planLog.log("Processor stopped");
       }
@@ -213383,8 +213675,8 @@ var init_triage = __esm({
         }
         const settings = await mergeEffectiveSettings(this.store, task, await this.store.getSettings());
         const approvalRequired = resolvePlanApprovalRequired(settings);
-        const promptPath = join74(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
-        const written = await readFile36(promptPath, "utf-8").catch((err) => {
+        const promptPath = join75(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+        const written = await readFile37(promptPath, "utf-8").catch((err) => {
           const msg = err instanceof Error ? err.message : String(err);
           planLog.warn(`${task.id}: failed to read PROMPT.md during planning recovery (${promptPath}): ${msg}`);
           return "";
@@ -213422,8 +213714,8 @@ var init_triage = __esm({
         return true;
       }
       async readNonEmptyPromptDraft(taskId, context) {
-        const promptPath = join74(this.rootDir, ".fusion", "tasks", taskId, "PROMPT.md");
-        const written = await readFile36(promptPath, "utf-8").catch((err) => {
+        const promptPath = join75(this.rootDir, ".fusion", "tasks", taskId, "PROMPT.md");
+        const written = await readFile37(promptPath, "utf-8").catch((err) => {
           const msg = err instanceof Error ? err.message : String(err);
           planLog.warn(`${taskId}: failed to read PROMPT.md during ${context} (${promptPath}): ${msg}`);
           return "";
@@ -213587,8 +213879,8 @@ var init_triage = __esm({
             continue;
           }
           try {
-            const promptPath = join74(this.rootDir, ".fusion", "tasks", todoTask.id, "PROMPT.md");
-            const content = await readFile36(promptPath, "utf-8");
+            const promptPath = join75(this.rootDir, ".fusion", "tasks", todoTask.id, "PROMPT.md");
+            const content = await readFile37(promptPath, "utf-8");
             if (isUnplannedSeedPrompt(content, todoTask.id, todoTask.title, todoTask.description)) {
               eligibleTodoTasks.push(todoTask);
             }
@@ -213799,7 +214091,7 @@ var init_triage = __esm({
           const detail = await this.store.getTask(task.id);
           const currentTask = detail ?? task;
           const settings = await mergeEffectiveSettings(this.store, currentTask, await this.store.getSettings());
-          const promptPath = `.fusion/tasks/${task.id}/PROMPT.md`;
+          const promptPath = relativePromptPath(task.id);
           const isFast = task.executionMode === "fast";
           const leanPlanning = settings.leanPlanning === true || isFast;
           const agentWork = async () => {
@@ -213976,11 +214268,15 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
               planningModel.modelId,
               assignedAgent?.runtimeConfig
             ) : { provider: void 0, modelId: void 0 };
+            const planningCwd = await this.options.acquirePlanningWorktree?.(task.id).catch(() => null) || this.rootDir;
+            if (planningCwd !== this.rootDir) {
+              await this.store.logEntry(task.id, `Planning session running in task worktree ${planningCwd}`).catch(() => void 0);
+            }
             const { session } = await createResolvedAgentSession({
               sessionPurpose: "triage",
               runtimeHint: triageRuntimeHint,
               pluginRunner: this.options.pluginRunner,
-              cwd: this.rootDir,
+              cwd: planningCwd,
               systemPrompt: triageSystemPromptFinal,
               systemPromptLayers: triageLayers,
               tools: "coding",
@@ -214131,8 +214427,22 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
                 }
                 return;
               }
-              const written = await readFile36(
-                join74(this.rootDir, promptPath),
+              const planPersistence = await persistPlanArtifact({
+                store: this.store,
+                taskId: task.id,
+                rootDir: this.rootDir,
+                planningCwd,
+                author: "triage",
+                logger: { log: (m2) => planLog.log(m2), warn: (m2) => planLog.warn(m2) }
+              });
+              if (planPersistence.outcome === "recovered") {
+                await this.store.logEntry(
+                  task.id,
+                  "Recovered the plan written inside the task worktree into the project .fusion folder"
+                ).catch(() => void 0);
+              }
+              const written = await readFile37(
+                join75(this.rootDir, promptPath),
                 "utf-8"
               ).catch((err) => {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -214749,7 +215059,7 @@ Remove or replace these ids and call fn_task_create again.`
           if (isNearDuplicateCanonicalInactive(canonicalTask ?? void 0)) {
             if (canClearInactiveMarker) {
               if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
-                await rm9(join74(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+                await rm9(join75(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
               })) return;
               await this.updatePlanningStateIfStillCurrent(task, { paused: false, pausedReason: null, status: null });
             }
@@ -214760,7 +215070,7 @@ Remove or replace these ids and call fn_task_create again.`
           if (resolution === "prompt" && keepAcknowledged) {
             if (canClearInactiveMarker) {
               if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
-                await rm9(join74(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+                await rm9(join75(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
               })) return;
               await this.updatePlanningStateIfStillCurrent(task, {
                 paused: false,
@@ -214801,7 +215111,7 @@ Remove or replace these ids and call fn_task_create again.`
             return;
           }
           if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
-            await rm9(join74(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+            await rm9(join75(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
           })) return;
           if (!await this.updatePlanningStateIfStillCurrent(task, {
             paused: false,
@@ -214866,7 +215176,7 @@ Remove or replace these ids and call fn_task_create again.`
           let nextPrompt = applyOriginalDescription(written, originalDescription);
           nextPrompt = applyFrontendUxCriteria(nextPrompt, parsedFileScope);
           if (nextPrompt !== written) {
-            const promptPath = join74(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+            const promptPath = join75(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
             try {
               if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
                 await writeFile28(promptPath, nextPrompt, "utf-8");
@@ -214878,6 +215188,10 @@ Remove or replace these ids and call fn_task_create again.`
             }
           }
         }
+        await mirrorPlanToProjectDb(this.store, task.id, written, {
+          author: "triage",
+          logger: { warn: (m2) => planLog.warn(m2) }
+        });
         let taskIntentSignature = {
           routePaths: [],
           filePaths: [],
@@ -215124,10 +215438,10 @@ Remove or replace these ids and call fn_task_create again.`
 });
 
 // ../engine/src/review-artifacts/feature-video.ts
-import { access as access9, mkdtemp as mkdtemp2, readFile as readFile37, rm as rm10 } from "node:fs/promises";
+import { access as access9, mkdtemp as mkdtemp2, readFile as readFile38, rm as rm10 } from "node:fs/promises";
 import { constants as constants2 } from "node:fs";
 import { tmpdir as tmpdir8 } from "node:os";
-import { join as join75 } from "node:path";
+import { join as join76 } from "node:path";
 function shouldGenerateReviewArtifacts(task, settings) {
   return isReviewArtifactGenerationEligible(settings, task.prompt);
 }
@@ -215153,7 +215467,7 @@ async function generateFeatureVideo(options) {
   let browser;
   let context;
   try {
-    recordingDir = await mkdtemp2(join75(tmpdir8(), "fusion-feature-video-"));
+    recordingDir = await mkdtemp2(join76(tmpdir8(), "fusion-feature-video-"));
     try {
       browser = await client.launch({ executablePath, headless: true });
     } catch {
@@ -215171,7 +215485,7 @@ async function generateFeatureVideo(options) {
     await (options.sleep ?? defaultSleep)(Math.min(Math.max(options.durationMs ?? DEFAULT_DURATION_MS, 0), MAX_DURATION_MS));
     await context.close();
     context = void 0;
-    const data = await readFile37(await video.path());
+    const data = await readFile38(await video.path());
     if (data.byteLength > (options.maxBytes ?? DEFAULT_MAX_BYTES2)) {
       return { status: "failed", reason: "size-cap-exceeded" };
     }
@@ -215320,16 +215634,16 @@ async function persistBranchState(persistence, state) {
     );
   }
 }
-function resolveJoinConfig(join108) {
-  const rawMode = join108.config?.mode;
+function resolveJoinConfig(join109) {
+  const rawMode = join109.config?.mode;
   let mode = "all";
   if (rawMode === "all" || rawMode === "any") mode = rawMode;
   else if (rawMode && typeof rawMode === "object" && "quorum" in rawMode) {
     const n = rawMode.quorum;
     if (typeof n === "number" && Number.isInteger(n) && n > 0) mode = { quorum: n };
-    else throw new WorkflowIrError(`join '${join108.id}' quorum must be a positive integer`);
+    else throw new WorkflowIrError(`join '${join109.id}' quorum must be a positive integer`);
   }
-  const rawFail = join108.config?.onBranchFailure;
+  const rawFail = join109.config?.onBranchFailure;
   const onBranchFailure = rawFail === "collect" ? "collect" : "fail-fast";
   return { mode, onBranchFailure };
 }
@@ -215345,9 +215659,9 @@ async function runSplitJoin(split, env) {
   if (branchEdges.length === 0) {
     throw new WorkflowIrError(`split '${split.id}' has no traversable branches`);
   }
-  const join108 = findMatchingJoin(branchEdges[0].to, env);
-  if (!join108) throw new WorkflowIrError(`split '${split.id}' has no reachable matching join`);
-  const joinConfig = resolveJoinConfig(env.nodeMap.get(join108));
+  const join109 = findMatchingJoin(branchEdges[0].to, env);
+  if (!join109) throw new WorkflowIrError(`split '${split.id}' has no reachable matching join`);
+  const joinConfig = resolveJoinConfig(env.nodeMap.get(join109));
   const controller = new AbortController();
   const branchCount = branchEdges.length;
   const required2 = requiredCompletions(joinConfig.mode, branchCount);
@@ -215383,7 +215697,7 @@ async function runSplitJoin(split, env) {
   };
   const branchPromises = branchEdges.map((edge) => {
     const branchId = edge.to;
-    return walkBranch(branchId, join108, env, controller.signal, visitedNodeIds).then((result2) => {
+    return walkBranch(branchId, join109, env, controller.signal, visitedNodeIds).then((result2) => {
       branchOutcomes.push({ branchId, outcome: result2.outcome, nodeId: result2.lastNodeId });
       if (result2.outcome === "success") succeeded += 1;
       else failed += 1;
@@ -215401,7 +215715,7 @@ async function runSplitJoin(split, env) {
   });
   const outcome = await joinReached;
   await Promise.allSettled(branchPromises);
-  return { joinNodeId: join108, outcome, branchOutcomes, visitedNodeIds };
+  return { joinNodeId: join109, outcome, branchOutcomes, visitedNodeIds };
 }
 async function walkBranch(startNodeId, joinId, env, signal, visitedNodeIds) {
   let currentId = startNodeId;
@@ -216441,12 +216755,13 @@ function recoverPassedPlanReviewFromLatestLog(task) {
     completedAt: latest.timestamp
   };
 }
-var PLAN_REVIEW_PROVIDER_FAILURE_HOLD_VALUE, PLAN_REVIEW_LEASE_HELD_VALUE, WORKFLOW_INTERRUPTED_NODE_ID_CONTEXT_KEY, WORKFLOW_INTERRUPTED_NODE_ABORT_KIND_CONTEXT_KEY, WORKFLOW_OPTIONAL_GROUP_CONTEXT_KEY, WORKFLOW_NODE_ENGINE_PAUSE_ABORT_KIND, WORKFLOW_DRIFT_PARK_CONTEXT_KEY, WorkflowGraphSuspended, MERGE_REGION_KINDS, WorkflowGraphExecutor;
+var PLAN_REVIEW_PROVIDER_FAILURE_HOLD_VALUE, PLAN_REVIEW_LEASE_HELD_VALUE, SESSION_CONTENTION_HOLD_VALUE, WORKFLOW_INTERRUPTED_NODE_ID_CONTEXT_KEY, WORKFLOW_INTERRUPTED_NODE_ABORT_KIND_CONTEXT_KEY, WORKFLOW_OPTIONAL_GROUP_CONTEXT_KEY, WORKFLOW_NODE_ENGINE_PAUSE_ABORT_KIND, WORKFLOW_DRIFT_PARK_CONTEXT_KEY, WorkflowGraphSuspended, MERGE_REGION_KINDS, WorkflowGraphExecutor;
 var init_workflow_graph_executor = __esm({
   "../engine/src/workflow-graph-executor.ts"() {
     "use strict";
     init_src2();
     init_transient_error_detector();
+    init_transient_error_patterns();
     init_required_workflow_artifacts();
     init_workflow_node_handlers();
     init_workflow_graph_branches();
@@ -216455,6 +216770,7 @@ var init_workflow_graph_executor = __esm({
     init_workflow_node_execution_needs();
     PLAN_REVIEW_PROVIDER_FAILURE_HOLD_VALUE = "plan-review-provider-failure-hold";
     PLAN_REVIEW_LEASE_HELD_VALUE = "plan-review-lease-held";
+    SESSION_CONTENTION_HOLD_VALUE = "session-contention-hold";
     WORKFLOW_INTERRUPTED_NODE_ID_CONTEXT_KEY = "workflow:interruptedNodeId";
     WORKFLOW_INTERRUPTED_NODE_ABORT_KIND_CONTEXT_KEY = "workflow:interruptedNodeAbortKind";
     WORKFLOW_OPTIONAL_GROUP_CONTEXT_KEY = "workflow:optionalGroupActive";
@@ -216774,6 +217090,15 @@ var init_workflow_graph_executor = __esm({
             };
             context[`node:${node.id}:outcome`] = result3.outcome;
             if (result3.value !== void 0) context[`node:${node.id}:value`] = result3.value;
+            const sessionContentionFailure = stepStatus === "failed" && (verdictRaw === SESSION_CONTENTION_HOLD_VALUE || isSessionContentionError(stepOutput ?? stepNotes ?? ""));
+            if (sessionContentionFailure) {
+              this.deps.logTaskEntry?.(
+                `${logPrefix} ${groupName} is waiting on another task to release its session path \u2014 holding in place`
+              );
+              context[`node:${node.id}:outcome`] = "failure";
+              context[`node:${node.id}:value`] = SESSION_CONTENTION_HOLD_VALUE;
+              return { outcome: "failure", value: SESSION_CONTENTION_HOLD_VALUE };
+            }
             const nonPlanDefectPlanReviewFailure = node.id === PLAN_REVIEW_GROUP_ID && stepStatus === "failed" && (isRequiredArtifactReadFailedValue(verdictRaw) || isNonPlanDefectPlanReviewFailure({
               verdict,
               errorMessage: stepOutput ?? stepNotes,
@@ -217157,6 +217482,7 @@ var init_workflow_graph_executor = __esm({
           } catch (error3) {
             if (signal?.aborted) return this.withEnginePauseAbortContext(node, { outcome: "failure", value: "aborted" });
             lastError = error3;
+            if (isSessionContentionError(error3 instanceof Error ? error3.message : String(error3))) break;
           }
         }
         if (signal?.aborted) {
@@ -217175,11 +217501,13 @@ var init_workflow_graph_executor = __esm({
           }
           return degraded;
         }
+        const lastErrorText = lastError instanceof Error ? lastError.message : String(lastError);
         const failureResult = {
           outcome: "failure",
-          value: "exception",
+          // FNXC:SessionContention 2026-07-25-21:30: contention is a retryable hold, not an exception.
+          value: isSessionContentionError(lastErrorText) ? SESSION_CONTENTION_HOLD_VALUE : "exception",
           contextPatch: {
-            [`node:${node.id}:error`]: lastError instanceof Error ? lastError.message : String(lastError)
+            [`node:${node.id}:error`]: lastErrorText
           }
         };
         if (recordProgress && this.shouldRecordNodeProgress(node)) {
@@ -218803,7 +219131,7 @@ var init_workspace_paths = __esm({
 
 // ../engine/src/cli-agent/hook-scripts.ts
 import { mkdir as mkdir28, rm as rm11, writeFile as writeFile29 } from "node:fs/promises";
-import { join as join76 } from "node:path";
+import { join as join77 } from "node:path";
 function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -218875,8 +219203,8 @@ exit 0
 async function writeSessionHookScripts(opts) {
   const { sessionId, token, endpointUrl, dir } = opts;
   await mkdir28(dir, { recursive: true, mode: 448 });
-  const hookScriptPath = join76(dir, HOOK_SCRIPT_NAMES.hook);
-  const notifyScriptPath = join76(dir, HOOK_SCRIPT_NAMES.notify);
+  const hookScriptPath = join77(dir, HOOK_SCRIPT_NAMES.hook);
+  const notifyScriptPath = join77(dir, HOOK_SCRIPT_NAMES.notify);
   await writeFile29(hookScriptPath, buildHookScriptContent({ sessionId, token, endpointUrl }), {
     mode: 448
   });
@@ -219035,7 +219363,7 @@ var init_autonomy = __esm({
 // ../engine/src/cli-agent/task-session.ts
 import { mkdtemp as mkdtemp3, rm as rm12 } from "node:fs/promises";
 import { tmpdir as tmpdir9 } from "node:os";
-import { join as join77 } from "node:path";
+import { join as join78 } from "node:path";
 function launchCliTaskSession(opts) {
   return CliTaskSession.launch(opts);
 }
@@ -219101,9 +219429,9 @@ var init_task_session = __esm({
           isApproved: opts.isAutonomyApproved ?? (() => false)
         });
         const root = opts.hookDirRoot ?? tmpdir9();
-        const hookDir = await mkdtemp3(join77(root, "fusion-cli-hooks-"));
-        const hookScriptPath = join77(hookDir, HOOK_SCRIPT_NAMES.hook);
-        const settingsPath = join77(hookDir, "settings.json");
+        const hookDir = await mkdtemp3(join78(root, "fusion-cli-hooks-"));
+        const hookScriptPath = join78(hookDir, HOOK_SCRIPT_NAMES.hook);
+        const settingsPath = join78(hookDir, "settings.json");
         const cliAgentSettings = opts.config.cliAgentSettings ?? null;
         const operatorEnvAdditions = (cliAgentSettings?.envAdditions ?? []).filter(
           (k2) => !/^FUSION_/i.test(k2)
@@ -219345,7 +219673,7 @@ var init_task_session = __esm({
 // ../engine/src/pty-native.ts
 import * as fs7 from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
-import { join as join78, dirname as dirname33 } from "node:path";
+import { join as join79, dirname as dirname33 } from "node:path";
 function getNativePrebuildName() {
   const platform4 = process.platform === "darwin" ? "darwin" : process.platform === "linux" ? "linux" : process.platform === "win32" ? "win32" : "unknown";
   const arch = process.arch === "arm64" ? "arm64" : process.arch === "x64" ? "x64" : "unknown";
@@ -219355,12 +219683,12 @@ function findInstalledNodePtyNativeDir() {
   try {
     const packageJsonPath = require4.resolve("node-pty/package.json");
     const pkgRoot = dirname33(packageJsonPath);
-    const releaseDir = join78(pkgRoot, "build", "Release");
-    if (fs7.existsSync(join78(releaseDir, "pty.node"))) {
+    const releaseDir = join79(pkgRoot, "build", "Release");
+    if (fs7.existsSync(join79(releaseDir, "pty.node"))) {
       return releaseDir;
     }
-    const prebuildDir = join78(pkgRoot, "prebuilds", getNativePrebuildName());
-    if (fs7.existsSync(join78(prebuildDir, "pty.node"))) {
+    const prebuildDir = join79(pkgRoot, "prebuilds", getNativePrebuildName());
+    if (fs7.existsSync(join79(prebuildDir, "pty.node"))) {
       return prebuildDir;
     }
     return null;
@@ -219371,14 +219699,14 @@ function findInstalledNodePtyNativeDir() {
 function findStagedNativeDir() {
   const prebuildName = getNativePrebuildName();
   if (process.env.FUSION_RUNTIME_DIR) {
-    const envPath = join78(process.env.FUSION_RUNTIME_DIR, prebuildName);
-    if (fs7.existsSync(join78(envPath, "pty.node"))) {
+    const envPath = join79(process.env.FUSION_RUNTIME_DIR, prebuildName);
+    if (fs7.existsSync(join79(envPath, "pty.node"))) {
       return envPath;
     }
   }
   const execDir = dirname33(process.execPath);
-  const nextToBinary = join78(execDir, "runtime", prebuildName);
-  if (fs7.existsSync(join78(nextToBinary, "pty.node"))) {
+  const nextToBinary = join79(execDir, "runtime", prebuildName);
+  if (fs7.existsSync(join79(nextToBinary, "pty.node"))) {
     return nextToBinary;
   }
   return null;
@@ -219401,8 +219729,8 @@ function ensureNodePtyNativePermissions() {
     candidateDirs.add(installedNativeDir);
   }
   for (const nativeDir of candidateDirs) {
-    const helperPath = join78(nativeDir, "spawn-helper");
-    const nativeModulePath = join78(nativeDir, "pty.node");
+    const helperPath = join79(nativeDir, "spawn-helper");
+    const nativeModulePath = join79(nativeDir, "pty.node");
     try {
       fs7.chmodSync(helperPath, 493);
     } catch {
@@ -219432,7 +219760,7 @@ async function loadPtyModule() {
         process.env.NODE_PTY_SPAWN_HELPER_DIR = nativeDir;
       }
       process.env.FUSION_NATIVE_ASSETS_PATH = nativeDir;
-      const nativePath = join78(nativeDir, "pty.node");
+      const nativePath = join79(nativeDir, "pty.node");
       if (fs7.existsSync(nativePath)) {
         try {
           const nativeModule = { exports: {} };
@@ -220971,7 +221299,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 { isAbsolute as isAbsolute16, join as join79, relative as relative14 } from "node:path";
+import { isAbsolute as isAbsolute16, join as join80, relative as relative14 } from "node:path";
 import { Type as Type6 } from "@earendil-works/pi-ai";
 function shellSplit(input) {
   const tokens = [];
@@ -221086,7 +221414,7 @@ function findWorkspacePackageDir(rootDir, packageName) {
   for (const candidate of candidates) {
     if (!candidate) continue;
     try {
-      const pkg = JSON.parse(readFileSync23(join79(rootDir, candidate, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync23(join80(rootDir, candidate, "package.json"), "utf8"));
       if (pkg.name === packageName) {
         packageDirCache.set(cacheKey, candidate);
         return candidate;
@@ -221101,7 +221429,7 @@ function findWorkspacePackageDir(rootDir, packageName) {
   while (queue.length > 0) {
     const current = queue.shift();
     if (!current) break;
-    const abs = join79(rootDir, current.dir);
+    const abs = join80(rootDir, current.dir);
     let entries;
     try {
       entries = readdirSync11(abs, { withFileTypes: true });
@@ -221111,9 +221439,9 @@ function findWorkspacePackageDir(rootDir, packageName) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name === "node_modules" || entry.name === "dist") continue;
-      const child = join79(current.dir, entry.name);
+      const child = join80(current.dir, entry.name);
       try {
-        const pkg = JSON.parse(readFileSync23(join79(rootDir, child, "package.json"), "utf8"));
+        const pkg = JSON.parse(readFileSync23(join80(rootDir, child, "package.json"), "utf8"));
         if (pkg.name === packageName) {
           packageDirCache.set(cacheKey, child);
           return child;
@@ -221133,7 +221461,7 @@ function toPackageRelativeFilter(token, rootDir, packageDir) {
     return normalized.slice(normalizedPackageDir.length + 1);
   }
   if (isAbsolute16(token)) {
-    const rel = relative14(join79(rootDir, packageDir), token).replace(/\\/g, "/");
+    const rel = relative14(join80(rootDir, packageDir), token).replace(/\\/g, "/");
     if (!rel.startsWith("../") && rel !== "..") return rel;
   }
   return token;
@@ -221390,7 +221718,7 @@ function createRunVerificationTool(opts) {
       if (params.cwd && isAbsolute16(params.cwd)) {
         resolvedCwd = params.cwd;
       } else if (params.cwd) {
-        resolvedCwd = join79(worktreePath, params.cwd);
+        resolvedCwd = join80(worktreePath, params.cwd);
       } else {
         resolvedCwd = worktreePath;
       }
@@ -221423,7 +221751,7 @@ function createRunVerificationTool(opts) {
         warnings.push(...normalized.warnings);
       }
       if (effectiveCommand.trimStart().startsWith("pnpm --filter")) {
-        const modulesYaml = join79(rootDir, "node_modules", ".modules.yaml");
+        const modulesYaml = join80(rootDir, "node_modules", ".modules.yaml");
         if (!existsSync64(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.`;
@@ -221768,9 +222096,9 @@ var init_pseudo_pause = __esm({
 import { exec as exec38, execFile as execFile26, execSync as execSync7 } from "node:child_process";
 import { promisify as promisify53 } from "node:util";
 import { setImmediate as setImmediateCb3 } from "node:timers";
-import { basename as basename19, delimiter as delimiter2, isAbsolute as isAbsolute18, join as join80, relative as relative16, resolve as resolvePath3 } from "node:path";
+import { basename as basename19, delimiter as delimiter2, isAbsolute as isAbsolute18, join as join81, relative as relative16, resolve as resolvePath3 } from "node:path";
 import { existsSync as existsSync65, lstatSync as lstatSync3, realpathSync as realpathSync9 } from "node:fs";
-import { readFile as readFile38, rm as rm13, writeFile as writeFile30 } from "node:fs/promises";
+import { readFile as readFile39, rm as rm13, writeFile as writeFile30 } from "node:fs/promises";
 import { Type as Type7 } from "@earendil-works/pi-ai";
 import { SessionManager as SessionManager2 } from "@earendil-works/pi-coding-agent";
 function mergeAdditionalSkillPaths2(...pathGroups) {
@@ -221784,7 +222112,7 @@ function isWorkflowStepSkillDiscoverable(skillName, additionalSkillPaths, ceSkil
     return false;
   }
   return (additionalSkillPaths ?? []).some(
-    (skillPath) => basename19(skillPath) === bareSkillName && existsSync65(join80(skillPath, "SKILL.md")) || existsSync65(join80(skillPath, bareSkillName, "SKILL.md"))
+    (skillPath) => basename19(skillPath) === bareSkillName && existsSync65(join81(skillPath, "SKILL.md")) || existsSync65(join81(skillPath, bareSkillName, "SKILL.md"))
   );
 }
 function getPromptSection(prompt, heading) {
@@ -222093,7 +222421,7 @@ function normalizeWorktreePath(pathValue) {
 }
 async function extractPersistedSessionWorktreePath(sessionFile, rootDir, settings) {
   try {
-    const content = await readFile38(sessionFile, "utf-8");
+    const content = await readFile39(sessionFile, "utf-8");
     const matches = content.match(buildSessionWorktreePathRegex(rootDir, settings)) ?? [];
     if (matches.length === 0) return null;
     const normalizedCounts = /* @__PURE__ */ new Map();
@@ -222507,7 +222835,7 @@ function preservePreExecutionWorkflowStepResults(task) {
     }
   ];
 }
-var execAsync35, execFileAsync19, WORKFLOW_THINKING_LEVEL_SET, yieldEventLoop3, tokenCacheMetricsLog, OPTIONAL_STEP_REVISION_KEY_MARKER2, STEP_STATUSES, MAX_WORKFLOW_STEP_RETRIES, MAX_TASK_DONE_SESSION_RETRIES, MAX_TASK_DONE_REQUEUE_RETRIES, MAX_TRANSIENT_GRAPH_RESUME_RETRIES, TRANSIENT_GRAPH_RESUME_RETRY_BACKOFF_MS, COMPLETED_TASK_WATCHDOG_MS, WORKFLOW_RERUN_WATCHDOG_MS, LOOP_COMPACTION_TIMEOUT_MS, TASK_DONE_REFUSAL_SUFFIX, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS, NonRetryableWorktreeError, taskUpdateParams, taskAddDepParams, spawnAgentParams, USER_QUESTION_TOOL_NAMES, FUSION_WORKFLOW_STEP_CONVENTIONS_PREAMBLE, EXECUTOR_SYSTEM_PROMPT, TaskExecutor;
+var execAsync35, execFileAsync19, WORKFLOW_THINKING_LEVEL_SET, yieldEventLoop3, tokenCacheMetricsLog, OPTIONAL_STEP_REVISION_KEY_MARKER2, STEP_STATUSES, MAX_WORKFLOW_STEP_RETRIES, MAX_TASK_DONE_SESSION_RETRIES, MAX_TASK_DONE_REQUEUE_RETRIES, MAX_TRANSIENT_GRAPH_RESUME_RETRIES, TRANSIENT_GRAPH_RESUME_RETRY_BACKOFF_MS, MAX_SESSION_CONTENTION_HOLD_RETRIES, SESSION_CONTENTION_HOLD_BACKOFF_MS, SESSION_CONTENTION_HOLD_MAX_BACKOFF_MS, COMPLETED_TASK_WATCHDOG_MS, WORKFLOW_RERUN_WATCHDOG_MS, LOOP_COMPACTION_TIMEOUT_MS, TASK_DONE_REFUSAL_SUFFIX, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS, NonRetryableWorktreeError, taskUpdateParams, taskAddDepParams, spawnAgentParams, USER_QUESTION_TOOL_NAMES, FUSION_WORKFLOW_STEP_CONVENTIONS_PREAMBLE, EXECUTOR_SYSTEM_PROMPT, TaskExecutor;
 var init_executor = __esm({
   "../engine/src/executor.ts"() {
     "use strict";
@@ -222620,6 +222948,9 @@ var init_executor = __esm({
     MAX_TASK_DONE_REQUEUE_RETRIES = 3;
     MAX_TRANSIENT_GRAPH_RESUME_RETRIES = 2;
     TRANSIENT_GRAPH_RESUME_RETRY_BACKOFF_MS = process.env.VITEST || process.env.NODE_ENV === "test" ? 0 : 1e3;
+    MAX_SESSION_CONTENTION_HOLD_RETRIES = 10;
+    SESSION_CONTENTION_HOLD_BACKOFF_MS = process.env.VITEST || process.env.NODE_ENV === "test" ? 0 : 5e3;
+    SESSION_CONTENTION_HOLD_MAX_BACKOFF_MS = 6e4;
     COMPLETED_TASK_WATCHDOG_MS = 6e4;
     WORKFLOW_RERUN_WATCHDOG_MS = 15e3;
     LOOP_COMPACTION_TIMEOUT_MS = 6e4;
@@ -222980,6 +223311,15 @@ The tool prevents your session from being killed by the inactivity watchdog duri
                 }
               })
             );
+          } else if ((from === "todo" || from === "triage") && to2 !== "in-progress" && to2 !== "in-review" && to2 !== "done") {
+            this.trackTaskDisposal(
+              task.id,
+              this.awaitAbortInFlightTaskWork(task.id, `task moved out of planning to ${to2}`, {
+                userCanceled: source === "user"
+              }).then(async () => {
+                await this.releasePreExecutionWorktree(task.id, `moved to ${to2}`);
+              })
+            );
           } else if (from === "in-progress") {
             if (this.workflowLifecycleMovesInFlight.has(task.id) && this.graphRouting.has(task.id)) {
               executorLog.log(
@@ -223569,15 +223909,63 @@ The tool prevents your session from being killed by the inactivity watchdog duri
       getActiveWorktreePaths() consumers that cd into a path are unaffected; only the registry key changes.
       Non-workspace tasks (unique worktree path != rootDir) are returned unchanged.
       */
+      /*
+      FNXC:PlanReviewWorktree 2026-07-25-20:40 (concurrent root-rooted step sessions — single-repo collision):
+      The task-scoped key must apply to the shared repo root in EVERY project mode, not only workspace mode.
+      Read-only graph nodes that need no worktree (Plan Review is the canonical one — it reviews the
+      store-injected PROMPT.md, see FNXC:PlanReviewSpecInjection) run rooted at `this.rootDir`, and a todo
+      task has no worktree of its own. With the bare root as the registry key, two tasks reaching Plan Review
+      at the same time collided: the second failed with "active-session path <root> is held by task <other>;
+      task <self> may not overwrite it", which surfaced as a Plan Review provider failure, burned the
+      in-place retry budget against a hold that retrying can never clear, and left the task parked
+      (reported: FN-1398 holding /home/ubuntu/dev/freemap-svelte while FN-1403 planned).
+      Path-exclusivity on the shared root is not what keeps these sessions correct: write-capable nodes are
+      refused at the root outright (no-worktree-for-write-node above), real per-sub-repo exclusivity is the
+      workspace-repo-acquire lease, and every isPathActive consumer guards removable WORKTREE paths — the
+      root is never one. Liveness still works because the synthetic key stays in the registry under the task.
+      */
       sessionRegistryPath(taskId, worktreePath) {
-        if (this.workspaceConfig && worktreePath === this.rootDir) {
+        if (worktreePath === this.rootDir) {
           return `${worktreePath}#session:${taskId}`;
         }
         return worktreePath;
       }
+      /*
+      FNXC:SessionContention 2026-07-25-21:30 (contention prevention at the registration seam):
+      Every executor session registration goes through `acquireActiveSessionPath` instead of the raw
+      `registerPath`, so a LEAKED entry owned by a task with no live session surface in this process is
+      RECLAIMED rather than throwing at the newcomer. That closes the second contention class (a dead
+      holder can never release, so waiting on it is waiting forever). A genuinely live holder still throws
+      the typed error — that case is real serialization, and callers classify it as a retryable contention
+      hold (SESSION_CONTENTION_HOLD_VALUE), never as a provider/model failure.
+      The probe reports LIVE on any uncertainty: an unknown holder with a fresh entry is treated as live by
+      the staleness floor, so the reclaim only ever fires on proven-dead, aged entries.
+      */
+      acquireSessionRegistryPath(taskId, registryPath, kind, ownerKey) {
+        const outcome = acquireActiveSessionPath(activeSessionRegistry, registryPath, { taskId, kind, ownerKey }, {
+          holderLiveProbe: (holderTaskId) => this.hasLiveTaskSessionSurface(holderTaskId) || executingTaskLock.has(holderTaskId)
+        });
+        if (outcome.action === "contended") {
+          throw new ActiveSessionPathHeldByForeignTaskError(registryPath, outcome.holderTaskId, taskId);
+        }
+        if (outcome.action === "reclaimed-stale-foreign") {
+          executorLog.warn(
+            `${taskId}: reclaimed a stale active-session entry on ${registryPath} from dead task ${outcome.holderTaskId} (idle ${outcome.ageMs}ms)`
+          );
+          void this.store.recordRunAuditEvent?.({
+            taskId,
+            agentId: "executor",
+            runId: generateSyntheticRunId("session-path-reclaim", taskId),
+            domain: "database",
+            mutationType: "session:reclaim-stale-foreign-path",
+            target: taskId,
+            metadata: { taskId, holderTaskId: outcome.holderTaskId, kind, ageMs: outcome.ageMs }
+          })?.catch?.(() => void 0);
+        }
+      }
       setActiveSession(taskId, sessionState, worktreePath) {
         this.activeSessions.set(taskId, sessionState);
-        activeSessionRegistry.registerPath(this.sessionRegistryPath(taskId, worktreePath), { taskId, kind: "executor", ownerKey: taskId });
+        this.acquireSessionRegistryPath(taskId, this.sessionRegistryPath(taskId, worktreePath), "executor", taskId);
       }
       markGraphExecuteSelfRequeued(taskId) {
         if (this.graphRouting.has(taskId)) {
@@ -223595,7 +223983,7 @@ The tool prevents your session from being killed by the inactivity watchdog duri
       setActiveStepExecutor(taskId, stepExecutor, worktreePath, seenSteeringIds = /* @__PURE__ */ new Set()) {
         this.activeStepExecutors.set(taskId, stepExecutor);
         this.activeStepExecutorSeenSteeringIds.set(taskId, seenSteeringIds);
-        activeSessionRegistry.registerPath(this.sessionRegistryPath(taskId, worktreePath), { taskId, kind: "step-session", ownerKey: `${taskId}#step-session` });
+        this.acquireSessionRegistryPath(taskId, this.sessionRegistryPath(taskId, worktreePath), "step-session", `${taskId}#step-session`);
       }
       deleteActiveStepExecutor(taskId, worktreePath) {
         this.activeStepExecutors.delete(taskId);
@@ -223609,7 +223997,7 @@ The tool prevents your session from being killed by the inactivity watchdog duri
       setActiveWorkflowStepSession(taskId, session, worktreePath, seenSteeringIds = /* @__PURE__ */ new Set()) {
         this.activeWorkflowStepSessions.set(taskId, session);
         this.activeWorkflowStepSessionSeenSteeringIds.set(taskId, seenSteeringIds);
-        activeSessionRegistry.registerPath(this.sessionRegistryPath(taskId, worktreePath), { taskId, kind: "workflow-step", ownerKey: `${taskId}#workflow-step` });
+        this.acquireSessionRegistryPath(taskId, this.sessionRegistryPath(taskId, worktreePath), "workflow-step", `${taskId}#workflow-step`);
       }
       deleteActiveWorkflowStepSession(taskId, worktreePath) {
         this.activeWorkflowStepSessions.delete(taskId);
@@ -225481,7 +225869,7 @@ ${info.feedback}`, revisionKey),
           const authoritativeAgentLayer = this.store.getAsyncLayer();
           if (!this.authoritativeAssignedAgentStore || authoritativeAgentLayer && !this.authoritativeAssignedAgentStore.backendMode) {
             this.authoritativeAssignedAgentStore = new AgentStore({
-              rootDir: join80(this.rootDir, ".fusion"),
+              rootDir: join81(this.rootDir, ".fusion"),
               taskStore: this.store,
               ...authoritativeAgentLayer ? { asyncLayer: authoritativeAgentLayer } : {}
             });
@@ -227928,6 +228316,87 @@ ${info.feedback}`, revisionKey),
           this.unregisterConfiguredCommandController(task.id, commandAbortController);
         }
       }
+      /*
+      FNXC:NodeWorktreeIsolation 2026-07-25-22:10 (planning acquires the task worktree):
+      Public seam for the planning/triage lane. Specification runs a CODING-tool session; pointing it at
+      the shared main checkout meant every planning agent had write tools in the operator's tree and every
+      concurrent planner shared one path. Acquire the task's own worktree up front and let the whole
+      lifecycle — planning, Plan Review, implementation, code review — reuse that single worktree.
+      Returns null (caller falls back to the root, unchanged behavior) when the project is a workspace, or
+      when acquisition fails: planning must never be blocked by a worktree problem.
+      */
+      /*
+      FNXC:PlanningEvacuation 2026-07-25-23:00 (pre-execution worktree release):
+      Planning now acquires a worktree, so a card that never reaches execution — withdrawn to Ideas,
+      archived from a planner lane, or parked pre-execution — would otherwise hold one forever. Release
+      it. Safety conditions, all required:
+       - the task never executed (`firstExecutionAt`/`executionStartedAt` unset): execution evidence means
+         the worktree may hold real work, and only the normal merge/archive lifecycle may remove it;
+       - no live session registered on the path (the same isPathActive guard the other sweeps use);
+       - the branch carries no commits beyond its base — planning writes its spec to the task store, not
+         the worktree, so a clean branch means there is genuinely nothing to lose.
+      Metadata (`worktree`/`branch`) is cleared with it, so a later promotion re-acquires cleanly.
+      Fail-soft throughout: a cleanup problem must never block the lifecycle move that triggered it.
+      */
+      async releasePreExecutionWorktree(taskId, reason) {
+        try {
+          const live = await this.store.getTask(taskId);
+          if (!live?.worktree) return false;
+          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 (await this.preExecutionWorktreeHasWork(live.worktree)) {
+              executorLog.log(`${taskId}: keeping pre-execution worktree ${live.worktree} \u2014 it carries commits or uncommitted changes`);
+              return false;
+            }
+            const settings = await this.store.getSettings();
+            await removeWorktree({
+              rootDir: this.rootDir,
+              worktreePath: live.worktree,
+              settings,
+              taskId,
+              reason: RemovalReason.SelfHealingReclaim
+            });
+          }
+          this.activeWorktrees.get(taskId)?.delete(live.worktree);
+          await this.store.updateTask(taskId, { worktree: null, branch: null, baseCommitSha: null, sessionFile: null }, this.getRunContextFor(taskId));
+          await this.store.logEntry(taskId, `Released the pre-execution worktree (${reason}) \u2014 it will be re-acquired when planning or execution resumes`, void 0, this.getRunContextFor(taskId)).catch(() => void 0);
+          executorLog.log(`${taskId}: released pre-execution worktree ${live.worktree} (${reason})`);
+          return true;
+        } catch (error3) {
+          executorLog.warn(`${taskId}: could not release the pre-execution worktree: ${formatError(error3).message}`);
+          return false;
+        }
+      }
+      /** True when a pre-execution worktree holds commits past its base or any uncommitted change. */
+      async preExecutionWorktreeHasWork(worktreePath) {
+        try {
+          const { stdout: dirty } = await execFileAsync19("git", ["status", "--porcelain"], { cwd: worktreePath, timeout: 3e4 });
+          if (dirty.trim()) return true;
+          const { stdout: ahead } = await execFileAsync19("git", ["log", "--oneline", "@{upstream}..HEAD"], { cwd: worktreePath, timeout: 3e4 }).catch(async () => await execFileAsync19("git", ["log", "--oneline", "-1", "HEAD", "--not", "--remotes", "--branches=main", "--branches=master"], { cwd: worktreePath, timeout: 3e4 }));
+          return Boolean(ahead.trim());
+        } catch {
+          return true;
+        }
+      }
+      async ensureTaskWorktreeForPlanning(taskId) {
+        try {
+          if (this.workspaceConfig === void 0) {
+            this.workspaceConfig = await loadWorkspaceConfig(this.rootDir);
+          }
+          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;
+          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");
+          return acquired.worktree || null;
+        } catch (error3) {
+          executorLog.warn(`${taskId}: could not acquire a planning worktree \u2014 planning falls back to the repo root: ${formatError(error3)}`);
+          return null;
+        }
+      }
       async prepareGraphNodeExecution(node, nodeTask, settings, requirement) {
         if (!requirement.requiresWorktree) return;
         const live = await this.store.getTask(nodeTask.id);
@@ -228054,22 +228523,29 @@ ${info.feedback}`, revisionKey),
           optionalGroupId,
           reviewerInlineFixes: settings.reviewerInlineFixes
         });
-        const executionTarget = writeCapable ? await this.store.getTask(live.id) : live;
-        if (writeCapable && !executionTarget.worktree && !this.workspaceConfig) {
-          return { outcome: "failure", value: "no-worktree-for-write-node" };
-        }
+        let executionTarget = writeCapable ? await this.store.getTask(live.id) : live;
         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";
-        let worktreePath = executionTarget.worktree || this.rootDir;
-        if (isPlanReviewNode && !writeCapable && executionTarget.worktree && !existsSync65(executionTarget.worktree)) {
-          await this.store.logEntry(
-            live.id,
-            `Plan Review worktree ${executionTarget.worktree} is missing on disk \u2014 running the reviewer from the repo root (spec is store-injected)`,
-            void 0,
-            this.getRunContextFor(live.id)
-          );
-          worktreePath = this.rootDir;
+        if (!this.workspaceConfig) {
+          const recordedWorktreeMissing = Boolean(executionTarget.worktree) && !existsSync65(executionTarget.worktree);
+          const shouldAcquire = !executionTarget.worktree || recordedWorktreeMissing && isPlanReviewNode;
+          if (shouldAcquire) {
+            if (recordedWorktreeMissing) {
+              await this.store.logEntry(
+                live.id,
+                `Plan Review worktree ${executionTarget.worktree} is missing on disk \u2014 re-acquiring a task worktree instead of running in the shared checkout`,
+                void 0,
+                this.getRunContextFor(live.id)
+              );
+            }
+            const acquisitionTask = recordedWorktreeMissing ? { ...executionTarget, worktree: void 0, sessionFile: void 0 } : executionTarget;
+            executionTarget = await this.ensureGraphCustomNodeWorktree(acquisitionTask, settings, node.id);
+          }
+        }
+        if (writeCapable && !executionTarget.worktree && !this.workspaceConfig) {
+          return { outcome: "failure", value: "no-worktree-for-write-node" };
         }
+        const worktreePath = executionTarget.worktree || this.rootDir;
         let prompt = typeof cfg.prompt === "string" ? cfg.prompt : "";
         let modelProvider = typeof cfg.modelProvider === "string" && cfg.modelProvider.trim() ? cfg.modelProvider : void 0;
         let modelId = typeof cfg.modelId === "string" && cfg.modelId.trim() ? cfg.modelId : void 0;
@@ -228366,6 +228842,77 @@ ${prompt}`;
         const latestAction = live.log.at(-1)?.action;
         return latestAction === "Resumed after engine restart" || latestAction === "Resuming execution after unpause";
       }
+      /*
+      FNXC:SessionContention 2026-07-25-21:30:
+      Two ways in, because contention must never slip through to a park:
+       - the typed failure value the graph now publishes (SESSION_CONTENTION_HOLD_VALUE), and
+       - a message-shape fallback over the run's `:error` context patches, so contention arriving from a
+         path that has not been taught the typed value is still recognized.
+      */
+      graphFailureErrorTexts(result2) {
+        if (!result2.context) return [];
+        const texts = [];
+        for (const [key, value] of Object.entries(result2.context)) {
+          if (key.endsWith(":error") && typeof value === "string" && value.trim()) texts.push(value);
+        }
+        return texts;
+      }
+      isSessionContentionGraphFailure(result2) {
+        if (this.graphFailureValue(result2) === SESSION_CONTENTION_HOLD_VALUE) return true;
+        return this.graphFailureErrorTexts(result2).some((text2) => isSessionContentionError(text2));
+      }
+      /*
+      FNXC:SessionContention 2026-07-25-21:30 (self-recovering wait — the task is never parked):
+      Retry the graph in place on an exponential backoff while the holder finishes. The counter is
+      IN-MEMORY on purpose: it needs no schema change, and an engine restart resetting it is the desired
+      behavior (a restart also drops the in-process registry, so the contention is gone anyway).
+      When the ladder is exhausted the task is left cleanly dispatchable — status/error cleared, progress
+      untouched — so ordinary scheduling picks it up later with a fresh budget. There is no terminal branch
+      here by design: lease contention always ends (the holder finishes, or self-healing sweeps it), so
+      parking the task would only require a human to press Retry on a condition that fixed itself.
+      */
+      sessionContentionHoldAttempts = /* @__PURE__ */ new Map();
+      clearSessionContentionHold(taskId) {
+        this.sessionContentionHoldAttempts.delete(taskId);
+      }
+      async holdForSessionContention(task, live, result2) {
+        const detail = this.graphFailureErrorTexts(result2).find((text2) => isSessionContentionError(text2));
+        const priorAttempts = this.sessionContentionHoldAttempts.get(task.id) ?? 0;
+        const attempt = priorAttempts + 1;
+        if (attempt > MAX_SESSION_CONTENTION_HOLD_RETRIES) {
+          this.clearSessionContentionHold(task.id);
+          const message2 = `Still waiting on another task to release a shared session path after ${MAX_SESSION_CONTENTION_HOLD_RETRIES} attempts \u2014 leaving the task queued for normal re-dispatch (not a failure)${detail ? `: ${detail}` : ""}`;
+          executorLog.warn(`${task.id}: ${message2}`);
+          await this.store.logEntry(task.id, message2, void 0, this.getRunContextFor(task.id));
+          if (live.status != null || live.error != null) {
+            await this.store.updateTask(task.id, { status: null, error: null }, this.getRunContextFor(task.id));
+          }
+          return;
+        }
+        this.sessionContentionHoldAttempts.set(task.id, attempt);
+        const message = `Waiting on another task to release a shared session path \u2014 retrying in place (${attempt}/${MAX_SESSION_CONTENTION_HOLD_RETRIES})${detail ? `: ${detail}` : ""}`;
+        executorLog.warn(`${task.id}: ${message}`);
+        await this.store.logEntry(task.id, message, void 0, this.getRunContextFor(task.id));
+        if (live.status != null || live.error != null) {
+          await this.store.updateTask(task.id, { status: null, error: null }, this.getRunContextFor(task.id));
+        }
+        const delayMs = SESSION_CONTENTION_HOLD_BACKOFF_MS === 0 ? 0 : Math.min(SESSION_CONTENTION_HOLD_MAX_BACKOFF_MS, SESSION_CONTENTION_HOLD_BACKOFF_MS * 2 ** (attempt - 1));
+        const scheduleRetry = () => {
+          void (async () => {
+            try {
+              const resume = await this.store.getTask(task.id);
+              if (!resume || resume.deletedAt || resume.paused || resume.userPaused) {
+                this.clearSessionContentionHold(task.id);
+                return;
+              }
+              await this.execute(resume);
+            } catch (err) {
+              executorLog.error(`Failed session-contention retry for ${task.id}:`, err);
+            }
+          })();
+        };
+        setTimeout(scheduleRetry, delayMs).unref?.();
+      }
       graphFailureValue(result2) {
         const failedNode = result2.visitedNodeIds[result2.visitedNodeIds.length - 1];
         if (!failedNode || !result2.context) return void 0;
@@ -228957,6 +229504,11 @@ Graph value: ${failureValue}` : ""}`, budget.key),
             await this.persistTokenUsage(task.id);
             return;
           }
+          if (this.isSessionContentionGraphFailure(result2)) {
+            await this.holdForSessionContention(task, live, result2);
+            await this.persistTokenUsage(task.id);
+            return;
+          }
           if (await this.routeUnusableWorktreeGraphFailureToRecovery(task, live, result2)) {
             await this.persistTokenUsage(task.id);
             return;
@@ -229777,7 +230329,7 @@ Graph value: ${failureValue}` : ""}`, budget.key),
         const activeMergeStatuses = /* @__PURE__ */ new Set(["merging", "merging-pr", "merging-fix"]);
         const isActiveTask = activeColumns.has(task.column) || activeMergeStatuses.has(task.status ?? "");
         if (!isActiveTask) {
-          const tasksDir = join80(this.store.getFusionDir(), "tasks");
+          const tasksDir = join81(this.store.getFusionDir(), "tasks");
           const promptPath = getPromptPath(tasksDir, task.id);
           const staleness = await evaluateSpecStaleness({ settings, promptPath, task });
           if (staleness.isStale) {
@@ -233638,10 +234190,10 @@ Please fix the issues so the verification can pass on the next attempt.`,
        * The section is replaced entirely to avoid accumulation of old feedback.
        */
       async injectWorkflowStepFailureInstructions(task, failureFeedback, stepName, retry) {
-        const promptPath = join80(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
+        const promptPath = join81(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
         let content;
         try {
-          content = await readFile38(promptPath, "utf-8");
+          content = await readFile39(promptPath, "utf-8");
         } catch {
           executorLog.warn(`${task.id}: PROMPT.md not found at ${promptPath}, skipping workflow failure injection`);
           return;
@@ -240180,7 +240732,7 @@ 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 realpathSync10, rmSync as rmSync9, statSync as statSync13 } from "node:fs";
 import { rm as rm14 } from "node:fs/promises";
 import { tmpdir as tmpdir10 } from "node:os";
-import { isAbsolute as isAbsolute19, join as join81, relative as relative17 } from "node:path";
+import { isAbsolute as isAbsolute19, join as join82, relative as relative17 } from "node:path";
 import { promisify as promisify56 } from "node:util";
 async function git4(args, cwd, opts = {}) {
   const { stdout } = await execFileAsync20("git", args, {
@@ -240211,7 +240763,7 @@ function isBenignAbsentWorktreeError(err) {
   return /is not a working tree|No such file or directory|spawn\s+.*\bENOENT\b/i.test(description);
 }
 function ensureAiMergeRootIgnored(projectRootDir, settings) {
-  const excludePath = join81(projectRootDir, ".git", "info", "exclude");
+  const excludePath = join82(projectRootDir, ".git", "info", "exclude");
   if (!existsSync66(excludePath)) return;
   try {
     const current = readFileSync24(excludePath, "utf-8");
@@ -240243,7 +240795,7 @@ function getAiMergeTempSearchRoots(projectRootDir, settings) {
   if (testWorkerRoot) {
     try {
       for (const entry of readdirSync12(testWorkerRoot)) {
-        if (entry.startsWith("redir-")) roots.push(join81(testWorkerRoot, entry));
+        if (entry.startsWith("redir-")) roots.push(join82(testWorkerRoot, entry));
       }
     } catch {
     }
@@ -240266,7 +240818,7 @@ async function pruneExistingAiMergeWorktrees(taskId, projectRootDir, audit, log3
       continue;
     }
     for (const entry of entries) {
-      const candidatePath = join81(tempRoot, entry);
+      const candidatePath = join82(tempRoot, entry);
       let canonicalPath = candidatePath;
       try {
         canonicalPath = realpathSync10(candidatePath);
@@ -240689,7 +241241,7 @@ import { promisify as promisify57 } from "node:util";
 import { realpathSync as realpathSync11, readdirSync as readdirSync13 } from "node:fs";
 import { mkdtemp as mkdtemp4 } from "node:fs/promises";
 import { tmpdir as tmpdir11 } from "node:os";
-import { join as join82 } from "node:path";
+import { join as join83 } from "node:path";
 async function git5(args, cwd, opts = {}) {
   const { stdout } = await execFileAsync21("git", args, {
     cwd,
@@ -240761,7 +241313,7 @@ function listAiMergeWorktreeCandidates(taskId, projectRootDir, settings) {
   if (testWorkerRoot) {
     try {
       for (const entry of readdirSync13(testWorkerRoot)) {
-        if (entry.startsWith("redir-")) roots.push(join82(testWorkerRoot, entry));
+        if (entry.startsWith("redir-")) roots.push(join83(testWorkerRoot, entry));
       }
     } catch {
     }
@@ -240774,7 +241326,7 @@ function listAiMergeWorktreeCandidates(taskId, projectRootDir, settings) {
     } catch {
       continue;
     }
-    for (const entry of entries) candidates.push(join82(root, entry));
+    for (const entry of entries) candidates.push(join83(root, entry));
   }
   return candidates;
 }
@@ -241108,7 +241660,7 @@ async function landOneRepo(repoRootDir, branch, integrationBranch, ctx) {
       registeredMergePaths.add(pathToRegister);
     };
     try {
-      mergeRoot = await mkdtemp4(join82(resolveAiMergeRoot(repoRootDir, settings), `fusion-ai-merge-${taskId.toLowerCase()}-`));
+      mergeRoot = await mkdtemp4(join83(resolveAiMergeRoot(repoRootDir, settings), `fusion-ai-merge-${taskId.toLowerCase()}-`));
       registerMergeRoot(mergeRoot);
       await git5(["worktree", "add", "--detach", mergeRoot, tipSha], repoRootDir);
       worktreeAdded = true;
@@ -241604,7 +242156,7 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
     for (const repoRel of repoKeys) {
       throwIfAborted2(options.signal, taskId);
       const entry = workspaceWorktrees[repoRel];
-      const repoRootDir = join82(workspaceRootDir, repoRel);
+      const repoRootDir = join83(workspaceRootDir, repoRel);
       let integrationBranch;
       try {
         integrationBranch = await resolveIntegrationBranch(
@@ -241921,7 +242473,7 @@ async function pushAfterMergeToRemote(input) {
   let worktreeAdded = false;
   const registeredPaths = /* @__PURE__ */ new Set();
   try {
-    pushRoot = await mkdtemp4(join82(resolveAiMergeRoot(projectRootDir, settings), `fusion-ai-merge-push-${taskId.toLowerCase()}-`));
+    pushRoot = await mkdtemp4(join83(resolveAiMergeRoot(projectRootDir, settings), `fusion-ai-merge-push-${taskId.toLowerCase()}-`));
     for (const p2 of [pushRoot]) {
       activeSessionRegistry.registerPath(p2, { taskId, kind: "ai-merge", ownerKey: `ai-merge-push:${taskId}` });
       registeredPaths.add(p2);
@@ -242228,7 +242780,7 @@ var init_merger_ai = __esm({
 
 // ../engine/src/task-revert.ts
 import { exec as exec41 } from "node:child_process";
-import { join as join83 } from "node:path";
+import { join as join84 } from "node:path";
 import { promisify as promisify58 } from "node:util";
 function quoteShellArg7(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -242678,7 +243230,7 @@ async function resolveWorkspaceTaskRevertCommits(task, opts) {
   const result2 = {};
   for (const repoRel of repoKeys) {
     const entry = workspaceWorktrees[repoRel];
-    const repoRootDir = join83(opts.workspaceRootDir, repoRel);
+    const repoRootDir = join84(opts.workspaceRootDir, repoRel);
     const landedSha = workspaceLandedShas[repoRel] ?? entry?.landedSha;
     if (landedSha && !entry?.baseCommitSha) {
       result2[repoRel] = { commits: [landedSha], source: "squash" };
@@ -242745,7 +243297,7 @@ async function revertWorkspaceTask(opts) {
   });
   const contexts = [];
   for (const repoRel of repoKeys) {
-    const repoRootDir = join83(workspaceRootDir, repoRel);
+    const repoRootDir = join84(workspaceRootDir, repoRel);
     let integrationBranch;
     try {
       integrationBranch = await resolveIntegrationBranch(repoRootDir, { ...opts.settings, integrationBranch: void 0, baseBranch: void 0 });
@@ -242870,7 +243422,7 @@ async function prepareWorkspaceRevertPrBranches(opts) {
   });
   const contexts = [];
   for (const repoRel of repoKeys) {
-    const repoRootDir = join83(workspaceRootDir, repoRel);
+    const repoRootDir = join84(workspaceRootDir, repoRel);
     let integrationBranch;
     try {
       integrationBranch = await resolveIntegrationBranch(repoRootDir, { ...opts.settings, integrationBranch: void 0, baseBranch: void 0 });
@@ -243211,7 +243763,7 @@ async function readOptionalTextFile(filePath) {
 }
 async function discoverMcpServers(opts) {
   const homeDir = opts.homeDir ?? process.env.HOME ?? process.env.USERPROFILE ?? osHomedir();
-  const readFile46 = opts.readFile ?? readOptionalTextFile;
+  const readFile47 = opts.readFile ?? readOptionalTextFile;
   const sources = getMcpDiscoverySources({
     homeDir,
     platform: osPlatform(),
@@ -243222,7 +243774,7 @@ async function discoverMcpServers(opts) {
   for (const source of sources) {
     let contents;
     try {
-      contents = await readFile46(source.path);
+      contents = await readFile47(source.path);
     } catch (error3) {
       errors.push(`${source.label}: ${error3 instanceof Error ? error3.message : String(error3)}`);
       continue;
@@ -243772,7 +244324,7 @@ var agent_reflection_exports = {};
 __export(agent_reflection_exports, {
   AgentReflectionService: () => AgentReflectionService
 });
-import { readFile as readFile39 } from "node:fs/promises";
+import { readFile as readFile40 } from "node:fs/promises";
 import { isAbsolute as isAbsolute20, resolve as resolve38 } from "node:path";
 var reflectionLog, REFLECTION_SYSTEM_PROMPT, DEFAULT_OUTCOME_LIMIT, AgentReflectionService;
 var init_agent_reflection = __esm({
@@ -244331,7 +244883,7 @@ Rules:
         if (agent.instructionsPath?.trim()) {
           const resolvedPath = isAbsolute20(agent.instructionsPath) ? agent.instructionsPath : resolve38(this.rootDir, agent.instructionsPath);
           try {
-            const content = await readFile39(resolvedPath, "utf-8");
+            const content = await readFile40(resolvedPath, "utf-8");
             if (content.trim()) {
               pieces.push(content.trim());
             }
@@ -246439,7 +246991,7 @@ 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 { dirname as dirname34, join as join84, relative as relative18, resolve as resolve39, sep as sep11 } from "node:path";
+import { dirname as dirname34, join as join85, relative as relative18, resolve as resolve39, sep as sep11 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 function defaultReadText(path10) {
   try {
@@ -246468,7 +247020,7 @@ function discoverOverseerWatchdogFiles(options) {
     };
     if (agentDir) {
       for (const name2 of WATCHDOG_FILENAMES) {
-        tryAdd(join84(agentDir, name2), "user", 999);
+        tryAdd(join85(agentDir, name2), "user", 999);
       }
     }
     let current = cwd;
@@ -246476,9 +247028,9 @@ function discoverOverseerWatchdogFiles(options) {
     for (let hop = 0; hop < 64; hop++) {
       const depth = relative18(cwd, current) === "" ? 0 : relative18(cwd, current).split(sep11).filter(Boolean).length;
       for (const name2 of WATCHDOG_FILENAMES) {
-        tryAdd(join84(current, name2), "project", depth);
-        tryAdd(join84(current, ".fusion", name2), "project", depth);
-        tryAdd(join84(current, ".omp", name2), "project", depth);
+        tryAdd(join85(current, name2), "project", depth);
+        tryAdd(join85(current, ".fusion", name2), "project", depth);
+        tryAdd(join85(current, ".omp", name2), "project", depth);
       }
       if (current === stopAt) break;
       const parent = dirname34(current);
@@ -253709,6 +254261,9 @@ var init_in_process_runtime = __esm({
               usageLimitPauser: this.usageLimitPauser,
               agentStore: this.agentStore,
               pluginRunner: this.pluginRunner,
+              // FNXC:NodeWorktreeIsolation 2026-07-25-22:10: planning acquires (or reuses) the task's own
+              // worktree through the executor's acquisition path, so no lane runs in the shared checkout.
+              acquirePlanningWorktree: (taskId) => this.executor.ensureTaskWorktreeForPlanning(taskId),
               onSpecifyStart: (t) => {
                 this.recordActivity();
                 runtimeLog.log(`Specifying ${t.id}...`);
@@ -253797,6 +254352,8 @@ var init_in_process_runtime = __esm({
             getExecutingTaskIds: () => this.executor?.getExecutingTaskIds() ?? /* @__PURE__ */ new Set(),
             clearPhantomExecutorBinding: (taskId, options) => this.executor?.clearPhantomExecutorBinding(taskId, options),
             listWorktreeHolders: () => this.executor?.listWorktreeHolders() ?? [],
+            // FNXC:PlanningEvacuation 2026-07-25-23:00: the executor owns the release safety conditions.
+            releasePreExecutionWorktree: (taskId, reason) => this.executor?.releasePreExecutionWorktree(taskId, reason) ?? Promise.resolve(false),
             recoverApprovedTriageTask: (task) => this.triageProcessor?.recoverApprovedTask(task) ?? Promise.resolve(false),
             getPlanningTaskIds: () => this.triageProcessor?.getPlanningTaskIds() ?? /* @__PURE__ */ new Set(),
             // FNXC:TaskTiming 2026-08-01-12:00: orphan planning recovery must defer
@@ -254776,7 +255333,7 @@ __export(child_process_runtime_exports, {
 import { EventEmitter as EventEmitter28 } from "node:events";
 import { fork } from "node:child_process";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { dirname as dirname35, join as join85 } from "node:path";
+import { dirname as dirname35, join as join86 } from "node:path";
 var HealthMonitor, ChildProcessRuntime;
 var init_child_process_runtime = __esm({
   "../engine/src/runtimes/child-process-runtime.ts"() {
@@ -254938,7 +255495,7 @@ var init_child_process_runtime = __esm({
         const isCompiled = !import.meta.url.endsWith(".ts");
         const currentDir = dirname35(fileURLToPath4(import.meta.url));
         const workerFile = isCompiled ? "child-process-worker.js" : "child-process-worker.ts";
-        return join85(currentDir, workerFile);
+        return join86(currentDir, workerFile);
       }
       /**
        * Set up event forwarding from IPC host to runtime listeners.
@@ -261205,7 +261762,7 @@ import { mkdirSync as mkdirSync12 } from "node:fs";
 import { access as access10, unlink as unlink10, writeFile as writeFile32 } from "node:fs/promises";
 import net2 from "node:net";
 import { platform as platform3, tmpdir as tmpdir12 } from "node:os";
-import { join as join86 } from "node:path";
+import { join as join87 } from "node:path";
 import { createHash as createHash24 } from "node:crypto";
 function projectHash(projectId) {
   return createHash24("sha1").update(projectId).digest("hex").slice(0, 16);
@@ -261215,10 +261772,10 @@ function computeEngineSocketPath(projectId) {
   if (platform3() === "win32") {
     return `\\\\.\\pipe\\fusion-engine-${hash}`;
   }
-  return join86(tmpdir12(), `fusion-engine-${hash}.sock`);
+  return join87(tmpdir12(), `fusion-engine-${hash}.sock`);
 }
 function computeEngineLockFilePath(workingDir) {
-  return join86(workingDir, ".fusion", "engine.lock");
+  return join87(workingDir, ".fusion", "engine.lock");
 }
 async function ensureLockTargetExists(lockPath) {
   try {
@@ -261228,7 +261785,7 @@ async function ensureLockTargetExists(lockPath) {
   }
 }
 async function acquireLockfile(workingDir, onCompromised) {
-  const dir = join86(workingDir, ".fusion");
+  const dir = join87(workingDir, ".fusion");
   mkdirSync12(dir, { recursive: true });
   const path10 = computeEngineLockFilePath(workingDir);
   await ensureLockTargetExists(path10);
@@ -266904,7 +267461,7 @@ var init_issue_image_attachments = __esm({
 import { exec as exec45 } from "node:child_process";
 import { mkdtemp as mkdtemp6, rm as rm15 } from "node:fs/promises";
 import { tmpdir as tmpdir13 } from "node:os";
-import { join as join87 } from "node:path";
+import { join as join88 } from "node:path";
 import { promisify as promisify65 } from "node:util";
 function resolveCommentAuthor(input) {
   const login = input.login || "unknown";
@@ -268073,8 +268630,8 @@ var init_github = __esm({
               { timeout: 3e4, maxBuffer: 10 * 1024 * 1024 }
             );
             const mergeBase = mergeBaseStdout.trim();
-            const indexDir = await mkdtemp6(join87(tmpdir13(), "fn-pr-conflict-"));
-            const indexPath = join87(indexDir, "index");
+            const indexDir = await mkdtemp6(join88(tmpdir13(), "fn-pr-conflict-"));
+            const indexPath = join88(indexDir, "index");
             const gitEnv = { ...process.env, GIT_INDEX_FILE: indexPath };
             try {
               await execAsync40(`git -C ${quoteGitArg(opts.repoRoot)} read-tree -m ${quoteGitArg(mergeBase)} ${quoteGitArg(baseRef)} ${quoteGitArg(headRef)}`, {
@@ -271661,8 +272218,8 @@ var init_knowledge_index_refresh = __esm({
 // ../dashboard/src/pr-metadata-generator.ts
 import { promisify as promisify66 } from "node:util";
 import { exec as execCb } from "node:child_process";
-import { access as access11, readFile as readFile40 } from "node:fs/promises";
-import { join as join88 } from "node:path";
+import { access as access11, readFile as readFile41 } from "node:fs/promises";
+import { join as join89 } from "node:path";
 function buildFallbackPrMetadata(task) {
   return {
     title: task.title ?? task.id,
@@ -271862,14 +272419,14 @@ async function generatePrMetadata(input) {
     ]), combinedSignal);
     let promptContent = "";
     try {
-      const promptPath = join88(repoRoot, ".fusion", "tasks", task.id, "PROMPT.md");
-      promptContent = (await raceWithAbort(readFile40(promptPath, "utf8"), combinedSignal)).trim();
+      const promptPath = join89(repoRoot, ".fusion", "tasks", task.id, "PROMPT.md");
+      promptContent = (await raceWithAbort(readFile41(promptPath, "utf8"), combinedSignal)).trim();
     } catch {
       promptContent = "";
     }
-    const templatePath = join88(repoRoot, ".github", "pull_request_template.md");
+    const templatePath = join89(repoRoot, ".github", "pull_request_template.md");
     const templateExists = await raceWithAbort(access11(templatePath).then(() => true).catch(() => false), combinedSignal);
-    const template = templateExists ? await raceWithAbort(readFile40(templatePath, "utf8"), combinedSignal) : "";
+    const template = templateExists ? await raceWithAbort(readFile41(templatePath, "utf8"), combinedSignal) : "";
     const model = resolveTitleSummarizerSettingsModel(settings);
     const systemPrompt = [PR_METADATA_SYSTEM_PROMPT];
     const titleGuidance = settings.prTitlePromptInstructions?.trim();
@@ -279522,12 +280079,12 @@ import {
   unlinkSync as unlinkSync4
 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
-import { basename as basename21, dirname as dirname36, join as join89, resolve as resolve40 } from "node:path";
+import { basename as basename21, dirname as dirname36, join as join90, resolve as resolve40 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function resolveHermesHome(profile) {
-  const base = process.env.HERMES_HOME ?? join89(homedir12(), ".hermes");
+  const base = process.env.HERMES_HOME ?? join90(homedir12(), ".hermes");
   if (!profile || profile === "default") return base;
-  return join89(base, "profiles", profile);
+  return join90(base, "profiles", profile);
 }
 function getFusionSkillSourceCandidates(moduleUrl = import.meta.url) {
   const here = fileURLToPath5(moduleUrl);
@@ -279542,13 +280099,13 @@ function getFusionSkillSourceCandidates(moduleUrl = import.meta.url) {
 function resolveBundledFusionSkillSource() {
   const candidates = getFusionSkillSourceCandidates();
   for (const candidate of candidates) {
-    if (existsSync69(join89(candidate, "SKILL.md"))) return candidate;
+    if (existsSync69(join90(candidate, "SKILL.md"))) return candidate;
   }
   return null;
 }
 function installFusionSkillIntoHermesHome(options = {}) {
   const sourceDir = options.sourceDir ?? resolveBundledFusionSkillSource();
-  const targetDir = join89(resolveHermesHome(options.profile), "skills", FUSION_SKILL_NAME);
+  const targetDir = join90(resolveHermesHome(options.profile), "skills", FUSION_SKILL_NAME);
   if (!sourceDir) {
     return {
       outcome: "warning",
@@ -279637,7 +280194,7 @@ function isBrokenSymlink(path10) {
   }
 }
 function looksLikePriorFusionInstall(path10) {
-  const skillMd = join89(path10, "SKILL.md");
+  const skillMd = join90(path10, "SKILL.md");
   if (!existsSync69(skillMd)) return false;
   try {
     const body = readFileSync26(skillMd, "utf-8");
@@ -279649,7 +280206,7 @@ function looksLikePriorFusionInstall(path10) {
 function looksLikeFusionSkillTarget(path10) {
   if (!path10) return false;
   if (basename21(path10).toLowerCase() === FUSION_SKILL_NAME) return true;
-  return existsSync69(join89(path10, "SKILL.md"));
+  return existsSync69(join90(path10, "SKILL.md"));
 }
 var FUSION_SKILL_NAME;
 var init_fusion_skill_install = __esm({
@@ -279830,7 +280387,7 @@ var init_src8 = __esm({
 // ../../plugins/fusion-plugin-openclaw-runtime/src/pi-module.ts
 import { spawn as spawn13 } from "node:child_process";
 import { randomUUID as randomUUID50 } from "node:crypto";
-import { readFile as readFile42 } from "node:fs/promises";
+import { readFile as readFile43 } from "node:fs/promises";
 function asString2(v2) {
   return typeof v2 === "string" && v2.trim() !== "" ? v2.trim() : void 0;
 }
@@ -279901,7 +280458,7 @@ function createCliSession(opts) {
   };
 }
 async function configureOpenClawMcpServer(opts) {
-  const serverValue = await readFile42(opts.serverConfigPath, "utf-8");
+  const serverValue = await readFile43(opts.serverConfigPath, "utf-8");
   await new Promise((resolve53, reject) => {
     const child = spawn13(opts.binaryPath, ["--no-color", "--profile", opts.profile, "mcp", "set", opts.serverName, serverValue], {
       stdio: ["ignore", "pipe", "pipe"]
@@ -280045,7 +280602,7 @@ var init_pi_module = __esm({
 // ../../plugins/fusion-plugin-openclaw-runtime/src/mcp-config.ts
 import { writeFileSync as writeFileSync13 } from "node:fs";
 import { tmpdir as tmpdir14 } from "node:os";
-import { join as join90 } from "node:path";
+import { join as join91 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { dirname as dirname37 } from "node:path";
 function toolsToMcpToolDefs(tools) {
@@ -280058,16 +280615,16 @@ function toolsToMcpToolDefs(tools) {
 }
 function writeOpenClawMcpBridgeFiles(toolDefs, cacheKey) {
   const suffix = cacheKey ? `${process.pid}-${cacheKey}` : `${process.pid}`;
-  const schemaPath = join90(tmpdir14(), `openclaw-runtime-mcp-schemas-${suffix}.json`);
+  const schemaPath = join91(tmpdir14(), `openclaw-runtime-mcp-schemas-${suffix}.json`);
   writeFileSync13(schemaPath, JSON.stringify(toolDefs));
   const __filename = fileURLToPath6(import.meta.url);
   const __dirname3 = dirname37(__filename);
-  const serverPath = join90(__dirname3, "mcp-schema-server.cjs");
+  const serverPath = join91(__dirname3, "mcp-schema-server.cjs");
   const serverConfig = {
     command: "node",
     args: [serverPath, schemaPath]
   };
-  const serverConfigPath = join90(tmpdir14(), `openclaw-runtime-mcp-server-${suffix}.json`);
+  const serverConfigPath = join91(tmpdir14(), `openclaw-runtime-mcp-server-${suffix}.json`);
   writeFileSync13(serverConfigPath, JSON.stringify(serverConfig));
   return {
     schemaPath,
@@ -280835,9 +281392,9 @@ var init_cli_spawn3 = __esm({
 });
 
 // ../../plugins/fusion-plugin-grok-runtime/src/probe.ts
-import { readFile as readFile43 } from "node:fs/promises";
+import { readFile as readFile44 } from "node:fs/promises";
 import { homedir as homedir13 } from "node:os";
-import { join as join91 } from "node:path";
+import { join as join92 } from "node:path";
 function buildCandidates2(binaryPath) {
   const configuredBinaryPath = binaryPath?.trim() || void 0;
   const ordered = configuredBinaryPath ? [configuredBinaryPath, ...CANDIDATES3] : [...CANDIDATES3];
@@ -280854,10 +281411,10 @@ async function probeGrokApiKeyPresence() {
   if (typeof envKey === "string" && envKey.trim().length > 0) {
     return { detected: true };
   }
-  const settingsPath = join91(homedir13(), ".grok", "user-settings.json");
+  const settingsPath = join92(homedir13(), ".grok", "user-settings.json");
   let raw;
   try {
-    raw = await readFile43(settingsPath, "utf-8");
+    raw = await readFile44(settingsPath, "utf-8");
   } catch {
     return { detected: false, reason: "No Grok API key detected by Fusion (GROK_API_KEY unset, ~/.grok/user-settings.json not found); the CLI will use its own credentials." };
   }
@@ -281006,7 +281563,7 @@ var init_provider2 = __esm({
 
 // ../../plugins/fusion-plugin-grok-runtime/src/acp/cli-spawn.ts
 import { existsSync as existsSync70 } from "node:fs";
-import { dirname as dirname38, isAbsolute as isAbsolute22, join as join92, resolve as resolve41 } from "node:path";
+import { dirname as dirname38, isAbsolute as isAbsolute22, join as join93, resolve as resolve41 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function asTrimmedString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
@@ -281024,7 +281581,7 @@ function pluginRootDir() {
 }
 function bundledClaudeBridgeBinPath(pluginRoot = pluginRootDir()) {
   const extension = process.platform === "win32" ? ".cmd" : "";
-  return join92(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY}${extension}`);
+  return join93(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY}${extension}`);
 }
 function resolveBundledClaudeBridgeBinary(options = {}) {
   const root = options.pluginRoot ?? pluginRootDir();
@@ -282387,10 +282944,10 @@ import {
 } from "node:fs";
 import { createRequire as createRequire8 } from "node:module";
 import { tmpdir as tmpdir15 } from "node:os";
-import { basename as basename23, dirname as dirname40, join as join94, resolve as resolve43 } from "node:path";
+import { basename as basename23, dirname as dirname40, join as join95, resolve as resolve43 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function isSkillDir(dir) {
-  return existsSync71(join94(dir, "SKILL.md"));
+  return existsSync71(join95(dir, "SKILL.md"));
 }
 function pushUnique(out, candidate) {
   if (!candidate) return;
@@ -282398,8 +282955,8 @@ function pushUnique(out, candidate) {
   if (!out.includes(resolved)) out.push(resolved);
 }
 function pushSkillLayoutsAtRoot(out, root) {
-  pushUnique(out, join94(root, "skill", FUSION_SKILL_NAME2));
-  pushUnique(out, join94(root, "packages", "cli", "skill", FUSION_SKILL_NAME2));
+  pushUnique(out, join95(root, "skill", FUSION_SKILL_NAME2));
+  pushUnique(out, join95(root, "packages", "cli", "skill", FUSION_SKILL_NAME2));
 }
 function walkAncestorSkillCandidates(out, startDir, maxParents = 8) {
   let dir = startDir;
@@ -282414,7 +282971,7 @@ function pushPackageRequireCandidates(out, from) {
   try {
     const require5 = createRequire8(from);
     const pkgJson = require5.resolve("@runfusion/fusion/package.json");
-    pushUnique(out, join94(dirname40(pkgJson), "skill", FUSION_SKILL_NAME2));
+    pushUnique(out, join95(dirname40(pkgJson), "skill", FUSION_SKILL_NAME2));
   } catch {
   }
 }
@@ -282482,21 +283039,21 @@ function collectSkillsFromRoot(root, out) {
     return;
   }
   for (const entry of entries) {
-    const child = join94(root, entry);
+    const child = join95(root, entry);
     if (isSkillDir(child)) {
       out.set(entry, child);
     }
   }
 }
 function stageGrokSessionSkills(options = {}) {
-  const pluginDir = mkdtempSync3(join94(tmpdir15(), "fusion-grok-plugin-"));
-  const skillsDir = join94(pluginDir, "skills");
+  const pluginDir = mkdtempSync3(join95(tmpdir15(), "fusion-grok-plugin-"));
+  const skillsDir = join95(pluginDir, "skills");
   mkdirSync14(skillsDir, { recursive: true });
   const installed = /* @__PURE__ */ new Map();
   const includeFusion = options.includeFusionSkill !== false;
   if (includeFusion) {
     const fusionSource = resolveBundledFusionSkillSource2();
-    if (fusionSource && installSkillDir(fusionSource, join94(skillsDir, FUSION_SKILL_NAME2))) {
+    if (fusionSource && installSkillDir(fusionSource, join95(skillsDir, FUSION_SKILL_NAME2))) {
       installed.set(FUSION_SKILL_NAME2, fusionSource);
     }
   }
@@ -282506,15 +283063,15 @@ function stageGrokSessionSkills(options = {}) {
   }
   for (const [name2, source] of installed) {
     if (name2 === FUSION_SKILL_NAME2 && includeFusion) continue;
-    installSkillDir(source, join94(skillsDir, name2));
+    installSkillDir(source, join95(skillsDir, name2));
   }
   for (const [name2, source] of installed) {
-    if (!existsSync71(join94(skillsDir, name2))) {
-      installSkillDir(source, join94(skillsDir, name2));
+    if (!existsSync71(join95(skillsDir, name2))) {
+      installSkillDir(source, join95(skillsDir, name2));
     }
   }
   writeFileSync14(
-    join94(pluginDir, "plugin.json"),
+    join95(pluginDir, "plugin.json"),
     JSON.stringify(
       {
         name: "fusion-session-skills",
@@ -282580,7 +283137,7 @@ var init_skill_loader = __esm({
 import { createServer as createServer2 } from "node:http";
 import { existsSync as existsSync72, writeFileSync as writeFileSync15 } from "node:fs";
 import { tmpdir as tmpdir16 } from "node:os";
-import { dirname as dirname41, join as join95 } from "node:path";
+import { dirname as dirname41, join as join96 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 import { randomUUID as randomUUID52 } from "node:crypto";
 function toolsToMcpToolDefs2(tools) {
@@ -282592,7 +283149,7 @@ function toolsToMcpToolDefs2(tools) {
   }));
 }
 function fusionToolsMcpServerPath() {
-  return join95(dirname41(fileURLToPath9(import.meta.url)), "mcp-schema-server.cjs");
+  return join96(dirname41(fileURLToPath9(import.meta.url)), "mcp-schema-server.cjs");
 }
 function missingMcpSchemaServerError(serverPath) {
   const error3 = new Error(`Fusion MCP schema server is missing: ${serverPath}`);
@@ -282633,7 +283190,7 @@ async function startFusionToolBridge(tools) {
       byName.set(tool.name, tool);
     }
   }
-  const schemaPath = join95(tmpdir16(), `fusion-grok-mcp-schemas-${process.pid}-${randomUUID52()}.json`);
+  const schemaPath = join96(tmpdir16(), `fusion-grok-mcp-schemas-${process.pid}-${randomUUID52()}.json`);
   writeFileSync15(schemaPath, JSON.stringify(defs));
   const server = createServer2(async (req, res) => {
     if (req.method !== "POST" || req.url !== "/tool-call") {
@@ -283066,7 +283623,7 @@ var init_src11 = __esm({
 
 // ../../plugins/fusion-plugin-claude-runtime/src/acp/cli-spawn.ts
 import { existsSync as existsSync73 } from "node:fs";
-import { dirname as dirname42, isAbsolute as isAbsolute23, join as join96, resolve as resolve44 } from "node:path";
+import { dirname as dirname42, isAbsolute as isAbsolute23, join as join97, resolve as resolve44 } from "node:path";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
 function asTrimmedString2(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
@@ -283084,7 +283641,7 @@ function pluginRootDir2() {
 }
 function bundledClaudeBridgeBinPath2(pluginRoot = pluginRootDir2()) {
   const extension = process.platform === "win32" ? ".cmd" : "";
-  return join96(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY2}${extension}`);
+  return join97(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY2}${extension}`);
 }
 function resolveBundledClaudeBridgeBinary2(options = {}) {
   const root = options.pluginRoot ?? pluginRootDir2();
@@ -284324,14 +284881,14 @@ 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 { basename as basename25, dirname as dirname44, isAbsolute as isAbsolute24, join as join98, resolve as resolve46 } from "node:path";
+import { basename as basename25, dirname as dirname44, isAbsolute as isAbsolute24, join as join99, resolve as resolve46 } from "node:path";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 function pluginRootDir3() {
   const moduleDir = dirname44(fileURLToPath11(import.meta.url));
   return ["src", "dist"].includes(basename25(moduleDir)) ? resolve46(moduleDir, "..") : moduleDir;
 }
 function bundledClaudeBridgeBinPath3(pluginRoot = pluginRootDir3()) {
-  return join98(pluginRoot, "bridge", `${CLAUDE_CODE_CLI_ACP_BINARY3}${process.platform === "win32" ? ".cmd" : ""}`);
+  return join99(pluginRoot, "bridge", `${CLAUDE_CODE_CLI_ACP_BINARY3}${process.platform === "win32" ? ".cmd" : ""}`);
 }
 function resolveBundledClaudeBridgeBinary3(options = {}) {
   const candidate = bundledClaudeBridgeBinPath3(options.pluginRoot ?? pluginRootDir3());
@@ -284508,10 +285065,10 @@ import {
 } from "node:fs";
 import { createRequire as createRequire9 } from "node:module";
 import { tmpdir as tmpdir17 } from "node:os";
-import { basename as basename26, dirname as dirname45, join as join99, resolve as resolve47 } from "node:path";
+import { basename as basename26, dirname as dirname45, join as join100, resolve as resolve47 } from "node:path";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
 function isSkillDir2(dir) {
-  return existsSync75(join99(dir, "SKILL.md"));
+  return existsSync75(join100(dir, "SKILL.md"));
 }
 function pushUnique2(out, candidate) {
   if (!candidate) return;
@@ -284519,8 +285076,8 @@ function pushUnique2(out, candidate) {
   if (!out.includes(resolved)) out.push(resolved);
 }
 function pushSkillLayoutsAtRoot2(out, root) {
-  pushUnique2(out, join99(root, "skill", FUSION_SKILL_NAME3));
-  pushUnique2(out, join99(root, "packages", "cli", "skill", FUSION_SKILL_NAME3));
+  pushUnique2(out, join100(root, "skill", FUSION_SKILL_NAME3));
+  pushUnique2(out, join100(root, "packages", "cli", "skill", FUSION_SKILL_NAME3));
 }
 function walkAncestorSkillCandidates2(out, startDir, maxParents = 8) {
   let dir = startDir;
@@ -284535,7 +285092,7 @@ function pushPackageRequireCandidates2(out, from) {
   try {
     const require5 = createRequire9(from);
     const pkgJson = require5.resolve("@runfusion/fusion/package.json");
-    pushUnique2(out, join99(dirname45(pkgJson), "skill", FUSION_SKILL_NAME3));
+    pushUnique2(out, join100(dirname45(pkgJson), "skill", FUSION_SKILL_NAME3));
   } catch {
   }
 }
@@ -284603,21 +285160,21 @@ function collectSkillsFromRoot2(root, out) {
     return;
   }
   for (const entry of entries) {
-    const child = join99(root, entry);
+    const child = join100(root, entry);
     if (isSkillDir2(child)) {
       out.set(entry, child);
     }
   }
 }
 function stageClaudeSessionSkills(options = {}) {
-  const pluginDir = mkdtempSync4(join99(tmpdir17(), "fusion-claude-plugin-"));
-  const skillsDir = join99(pluginDir, "skills");
+  const pluginDir = mkdtempSync4(join100(tmpdir17(), "fusion-claude-plugin-"));
+  const skillsDir = join100(pluginDir, "skills");
   mkdirSync15(skillsDir, { recursive: true });
   const installed = /* @__PURE__ */ new Map();
   const includeFusion = options.includeFusionSkill !== false;
   if (includeFusion) {
     const fusionSource = resolveBundledFusionSkillSource3();
-    if (fusionSource && installSkillDir2(fusionSource, join99(skillsDir, FUSION_SKILL_NAME3))) {
+    if (fusionSource && installSkillDir2(fusionSource, join100(skillsDir, FUSION_SKILL_NAME3))) {
       installed.set(FUSION_SKILL_NAME3, fusionSource);
     }
   }
@@ -284627,15 +285184,15 @@ function stageClaudeSessionSkills(options = {}) {
   }
   for (const [name2, source] of installed) {
     if (name2 === FUSION_SKILL_NAME3 && includeFusion) continue;
-    installSkillDir2(source, join99(skillsDir, name2));
+    installSkillDir2(source, join100(skillsDir, name2));
   }
   for (const [name2, source] of installed) {
-    if (!existsSync75(join99(skillsDir, name2))) {
-      installSkillDir2(source, join99(skillsDir, name2));
+    if (!existsSync75(join100(skillsDir, name2))) {
+      installSkillDir2(source, join100(skillsDir, name2));
     }
   }
   writeFileSync16(
-    join99(pluginDir, "plugin.json"),
+    join100(pluginDir, "plugin.json"),
     JSON.stringify(
       {
         name: "fusion-session-skills",
@@ -284701,7 +285258,7 @@ var init_skill_loader2 = __esm({
 import { createServer as createServer3 } from "node:http";
 import { existsSync as existsSync76, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
 import { tmpdir as tmpdir18 } from "node:os";
-import { dirname as dirname46, join as join100 } from "node:path";
+import { dirname as dirname46, join as join101 } from "node:path";
 import { fileURLToPath as fileURLToPath13 } from "node:url";
 import { randomBytes as randomBytes7, randomUUID as randomUUID53 } from "node:crypto";
 function toolsToMcpToolDefs3(tools) {
@@ -284713,7 +285270,7 @@ function toolsToMcpToolDefs3(tools) {
   }));
 }
 function fusionToolsMcpServerPath2() {
-  return join100(dirname46(fileURLToPath13(import.meta.url)), "mcp-schema-server.cjs");
+  return join101(dirname46(fileURLToPath13(import.meta.url)), "mcp-schema-server.cjs");
 }
 function missingMcpSchemaServerError2(serverPath) {
   const error3 = new Error(`Fusion MCP schema server is missing: ${serverPath}`);
@@ -284754,7 +285311,7 @@ async function startFusionToolBridge2(tools, options = {}) {
       byName.set(tool.name, tool);
     }
   }
-  const schemaPath = join100(tmpdir18(), `fusion-claude-mcp-schemas-${process.pid}-${randomUUID53()}.json`);
+  const schemaPath = join101(tmpdir18(), `fusion-claude-mcp-schemas-${process.pid}-${randomUUID53()}.json`);
   writeFileSync17(schemaPath, JSON.stringify(defs));
   const capabilityToken = randomBytes7(32).toString("base64url");
   const server = createServer3(async (req, res) => {
@@ -285558,7 +286115,7 @@ var init_provider6 = __esm({
 
 // ../../plugins/fusion-plugin-omp-runtime/src/acp/cli-spawn.ts
 import { existsSync as existsSync77 } from "node:fs";
-import { dirname as dirname47, isAbsolute as isAbsolute25, join as join101, resolve as resolve48 } from "node:path";
+import { dirname as dirname47, isAbsolute as isAbsolute25, join as join102, resolve as resolve48 } from "node:path";
 import { fileURLToPath as fileURLToPath14 } from "node:url";
 function asTrimmedString3(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
@@ -285576,7 +286133,7 @@ function pluginRootDir4() {
 }
 function bundledClaudeBridgeBinPath4(pluginRoot = pluginRootDir4()) {
   const extension = process.platform === "win32" ? ".cmd" : "";
-  return join101(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY4}${extension}`);
+  return join102(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY4}${extension}`);
 }
 function resolveBundledClaudeBridgeBinary4(options = {}) {
   const root = options.pluginRoot ?? pluginRootDir4();
@@ -286894,7 +287451,7 @@ var init_mcp_forwarding3 = __esm({
 import { createServer as createServer4 } from "node:http";
 import { existsSync as existsSync78, unlinkSync as unlinkSync5, writeFileSync as writeFileSync18 } from "node:fs";
 import { tmpdir as tmpdir19 } from "node:os";
-import { dirname as dirname49, join as join103 } from "node:path";
+import { dirname as dirname49, join as join104 } from "node:path";
 import { fileURLToPath as fileURLToPath15 } from "node:url";
 import { randomUUID as randomUUID54 } from "node:crypto";
 function toolsToMcpToolDefs4(tools) {
@@ -286911,12 +287468,12 @@ function fusionToolsMcpServerPath3() {
   const here = dirname49(fileURLToPath15(import.meta.url));
   const candidates = [
     // Packaged CLI / same-dir as bundled.js or tool-bridge source.
-    join103(here, "mcp-schema-server.cjs"),
+    join104(here, "mcp-schema-server.cjs"),
     // Source layout when running from dist/ that still has ../src assets.
-    join103(here, "src", "mcp-schema-server.cjs"),
-    join103(here, "..", "src", "mcp-schema-server.cjs"),
+    join104(here, "src", "mcp-schema-server.cjs"),
+    join104(here, "..", "src", "mcp-schema-server.cjs"),
     // Monorepo plugin root relative to src/ or dist/plugins/.../bundled.js.
-    join103(here, "..", "mcp-schema-server.cjs")
+    join104(here, "..", "mcp-schema-server.cjs")
   ];
   for (const candidate of candidates) {
     if (existsSync78(candidate)) return candidate;
@@ -286953,7 +287510,7 @@ async function startFusionToolBridge3(tools) {
       byName.set(tool.name, tool);
     }
   }
-  const schemaPath = join103(tmpdir19(), `fusion-omp-mcp-schemas-${process.pid}-${randomUUID54()}.json`);
+  const schemaPath = join104(tmpdir19(), `fusion-omp-mcp-schemas-${process.pid}-${randomUUID54()}.json`);
   writeFileSync18(schemaPath, JSON.stringify(defs));
   const server = createServer4(async (req, res) => {
     if (req.method !== "POST" || req.url !== "/tool-call") {
@@ -288675,8 +289232,8 @@ var init_types5 = __esm({
 
 // ../dashboard/src/stt/model-manager.ts
 import { createHash as createHash25, randomUUID as randomUUID56 } from "node:crypto";
-import { mkdir as mkdir31, open as open4, readFile as readFile44, readdir as readdir11, rename as rename10, rm as rm18, stat as stat12, writeFile as writeFile34 } from "node:fs/promises";
-import { join as join104, relative as relative19, resolve as resolve50, sep as sep15 } from "node:path";
+import { mkdir as mkdir31, open as open4, readFile as readFile45, readdir as readdir11, rename as rename10, rm as rm18, stat as stat12, writeFile as writeFile34 } from "node:fs/promises";
+import { join as join105, relative as relative19, resolve as resolve50, sep as sep15 } from "node:path";
 function parseSafeTarListing(listing) {
   for (const line2 of listing.split("\n").filter(Boolean)) {
     const type = line2[0];
@@ -288691,8 +289248,8 @@ function parseSafeTarListing(listing) {
 function createVoiceModelManager(options = {}) {
   const asset = options.asset ?? PARAKEET_V3_ASSET;
   let configuredCacheDir = options.cacheDir;
-  const cacheDir = () => configuredCacheDir ??= join104(resolveGlobalDir(), "models", "parakeet-v3");
-  const finalDir = () => join104(cacheDir(), "model");
+  const cacheDir = () => configuredCacheDir ??= join105(resolveGlobalDir(), "models", "parakeet-v3");
+  const finalDir = () => join105(cacheDir(), "model");
   let state = { status: "not-installed" };
   let generation = 0;
   let cleanupBarrier = Promise.resolve();
@@ -288755,8 +289312,8 @@ function createVoiceModelManager(options = {}) {
       if (!current(g2, signal)) return state;
       await mkdir31(cacheDir(), { recursive: true });
       if (!current(g2, signal)) return state;
-      partial2 = join104(cacheDir(), `.partial-${g2}-${randomUUID56()}`);
-      staging = join104(cacheDir(), `.staging-${g2}-${randomUUID56()}`);
+      partial2 = join105(cacheDir(), `.partial-${g2}-${randomUUID56()}`);
+      staging = join105(cacheDir(), `.staging-${g2}-${randomUUID56()}`);
       const file = await open4(partial2, "wx");
       try {
         const response = await (options.fetch ?? globalThis.fetch)(asset.url, { signal });
@@ -288801,10 +289358,10 @@ function createVoiceModelManager(options = {}) {
         }
       }
       if (!current(g2, signal)) return state;
-      await writeFile34(join104(staging, "manifest.json"), JSON.stringify({ filename: asset.filename, sha256: asset.sha256, installedAt: (/* @__PURE__ */ new Date()).toISOString(), expectedFiles: asset.expectedFiles }));
+      await writeFile34(join105(staging, "manifest.json"), JSON.stringify({ filename: asset.filename, sha256: asset.sha256, installedAt: (/* @__PURE__ */ new Date()).toISOString(), expectedFiles: asset.expectedFiles }));
       await options.beforePromote?.(signal);
       if (!current(g2, signal)) return state;
-      const backup = join104(cacheDir(), `.backup-${g2}-${randomUUID56()}`);
+      const backup = join105(cacheDir(), `.backup-${g2}-${randomUUID56()}`);
       let movedPrevious = false;
       try {
         try {
@@ -288884,9 +289441,9 @@ function createVoiceModelManager(options = {}) {
           publish(absent);
           return absent;
         }
-        const manifest = JSON.parse(await readFile44(join104(finalDir(), "manifest.json"), "utf8"));
+        const manifest = JSON.parse(await readFile45(join105(finalDir(), "manifest.json"), "utf8"));
         if (manifest.sha256 !== asset.sha256) throw new Error("stale manifest digest");
-        for (const expected of asset.expectedFiles) if (!await existsFile(join104(finalDir(), expected))) throw new Error("missing expected model file");
+        for (const expected of asset.expectedFiles) if (!await existsFile(join105(finalDir(), expected))) throw new Error("missing expected model file");
         const installed = { status: "installed", checksumVerified: true, installedPath: finalDir() };
         publish(installed);
         return installed;
@@ -288898,7 +289455,7 @@ function createVoiceModelManager(options = {}) {
         try {
           for (const entry of await readdir11(cacheDir())) {
             const own = /^\.(partial|staging|backup)-(\d+)-/.exec(entry);
-            if (own && Number(own[2]) !== active?.generation) await rm18(join104(cacheDir(), entry), { recursive: true, force: true });
+            if (own && Number(own[2]) !== active?.generation) await rm18(join105(cacheDir(), entry), { recursive: true, force: true });
           }
         } catch {
         }
@@ -288920,7 +289477,7 @@ function createVoiceModelManager(options = {}) {
         try {
           for (const entry of await readdir11(cacheDir())) {
             const match = /^\.(partial|staging|backup)-(\d+)-/.exec(entry);
-            if (match && Number(match[2]) <= g2) await rm18(join104(cacheDir(), entry), { recursive: true, force: true });
+            if (match && Number(match[2]) <= g2) await rm18(join105(cacheDir(), entry), { recursive: true, force: true });
           }
         } catch {
         }
@@ -289706,7 +290263,7 @@ var init_provider_health_monitor = __esm({
 
 // ../dashboard/src/server.ts
 import express3 from "express";
-import { join as join105, dirname as dirname50 } from "node:path";
+import { join as join106, dirname as dirname50 } from "node:path";
 import { fileURLToPath as fileURLToPath16 } from "node:url";
 import { WebSocketServer as WebSocketServer2 } from "ws";
 function clearAiSessionCleanupInterval() {
@@ -290410,7 +290967,7 @@ __export(task_exports, {
 });
 import { createInterface as createInterface2 } from "node:readline/promises";
 import { watchFile, unwatchFile, statSync as statSync14, existsSync as existsSync80, readFileSync as readFileSync27 } from "node:fs";
-import { basename as basename29, join as join106 } from "node:path";
+import { basename as basename29, join as join107 } from "node:path";
 function columnLabel(column) {
   return COLUMN_LABELS[column] ?? column;
 }
@@ -290768,7 +291325,7 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName,
     }
     console.log(`    Path:   .fusion/tasks/${resolvedTask.id}/`);
     if (attachFiles && attachFiles.length > 0) {
-      const { readFile: readFile46 } = await import("node:fs/promises");
+      const { readFile: readFile47 } = await import("node:fs/promises");
       const { basename: basename31, extname: extname5, resolve: resolve53 } = await import("node:path");
       for (const filePath of attachFiles) {
         const resolvedPath = resolve53(filePath);
@@ -290781,7 +291338,7 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName,
         }
         let content;
         try {
-          content = await readFile46(resolvedPath);
+          content = await readFile47(resolvedPath);
         } catch {
           console.error(`    \u2717 Cannot read file: ${filePath}`);
           continue;
@@ -290952,7 +291509,7 @@ async function runTaskLogs(id, options = {}, projectName) {
   printEntries(filteredEntries);
   if (options.follow) {
     const projectPath = context.projectPath ?? process.cwd();
-    const logPath = join106(projectPath, ".fusion", "tasks", id, "agent.log");
+    const logPath = join107(projectPath, ".fusion", "tasks", id, "agent.log");
     if (!existsSync80(logPath)) {
       console.log(`
   Waiting for log file to be created...`);
@@ -291157,7 +291714,7 @@ async function runTaskMerge(id, projectName) {
   }
 }
 async function runTaskAttach(id, filePath, projectName) {
-  const { readFile: readFile46 } = await import("node:fs/promises");
+  const { readFile: readFile47 } = await import("node:fs/promises");
   const { basename: basename31, extname: extname5 } = await import("node:path");
   const { resolve: resolve53 } = await import("node:path");
   const resolvedPath = resolve53(filePath);
@@ -291171,7 +291728,7 @@ async function runTaskAttach(id, filePath, projectName) {
   }
   let content;
   try {
-    content = await readFile46(resolvedPath);
+    content = await readFile47(resolvedPath);
   } catch {
     console.error(`Cannot read file: ${filePath}`);
     process.exit(1);
@@ -292336,8 +292893,8 @@ init_src15();
 import { randomUUID as randomUUID58 } from "node:crypto";
 import { Type as Type9 } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
-import { resolve as resolve52, relative as relative20, isAbsolute as isAbsolute26, sep as sep16, basename as basename30, extname as extname4, join as join107 } from "node:path";
-import { readFile as readFile45 } from "node:fs/promises";
+import { resolve as resolve52, relative as relative20, isAbsolute as isAbsolute26, sep as sep16, basename as basename30, extname as extname4, join as join108 } from "node:path";
+import { readFile as readFile46 } from "node:fs/promises";
 import { existsSync as existsSync81 } from "node:fs";
 import { spawn as spawn23 } from "node:child_process";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -292418,12 +292975,12 @@ function resolveProjectRoot2(cwd) {
     warnedMissingProjectRootResolver = true;
     console.warn("[fusion-extension] @fusion/core.getProjectRootFromWorktree is unavailable; using filesystem fallback resolution.");
   }
-  if (worktreeProjectRoot && existsSync81(join107(worktreeProjectRoot, ".fusion"))) {
+  if (worktreeProjectRoot && existsSync81(join108(worktreeProjectRoot, ".fusion"))) {
     return worktreeProjectRoot;
   }
   let current = resolve52(cwd);
   while (true) {
-    if (existsSync81(join107(current, ".fusion"))) {
+    if (existsSync81(join108(current, ".fusion"))) {
       return current;
     }
     const parent = resolve52(current, "..");
@@ -292685,7 +293242,7 @@ async function closeCachedStores() {
   }
 }
 function getFusionDir(cwd) {
-  return join107(resolveProjectRoot2(cwd), ".fusion");
+  return join108(resolveProjectRoot2(cwd), ".fusion");
 }
 function requireProjectLayer(store, consumer) {
   const layer = store.getAsyncLayer();
@@ -293467,7 +294024,7 @@ ${renderAgentLogEntries(entries)}` : `${header}
       }
       let content;
       try {
-        content = await readFile45(filePath);
+        content = await readFile46(filePath);
       } catch {
         throw new Error(`Cannot read file: ${params.path}`);
       }