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

package/dist/child-process-worker.js

@@ -5603,7 +5603,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       sql2.raw = raw;
-      function join84(chunks, separator) {
+      function join85(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -5613,7 +5613,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      sql2.join = join84;
+      sql2.join = join85;
       function identifier(value) {
         return new Name(value);
       }
@@ -10261,7 +10261,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((join84) => join84.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join85) => join85.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -11796,7 +11796,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join84) => join84.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join85) => join85.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -11892,10 +11892,10 @@ var init_update = __esm({
               const fromFields = this.getTableLikeFields(this.config.from);
               fields[tableName] = fromFields;
             }
-            for (const join84 of this.config.joins) {
-              const tableName2 = getTableLikeName(join84.table);
-              if (typeof tableName2 === "string" && !is(join84.table, SQL)) {
-                const fromFields = this.getTableLikeFields(join84.table);
+            for (const join85 of this.config.joins) {
+              const tableName2 = getTableLikeName(join85.table);
+              if (typeof tableName2 === "string" && !is(join85.table, SQL)) {
+                const fromFields = this.getTableLikeFields(join85.table);
                 fields[tableName2] = fromFields;
               }
             }
@@ -20499,26 +20499,26 @@ function validateParallelism(nodes2, outgoing, nodesById) {
     }
     const joinsReached = /* @__PURE__ */ new Set();
     for (const edge of branchEdges) {
-      const join85 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
-      if (!join85) {
+      const join86 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
+      if (!join86) {
         throw new WorkflowIrError(`split '${split.id}' has a branch with no reachable matching join`);
       }
-      joinsReached.add(join85);
+      joinsReached.add(join86);
     }
     if (joinsReached.size !== 1) {
       throw new WorkflowIrError(`split '${split.id}' branches converge on more than one join`);
     }
     const joinId = [...joinsReached][0];
-    const join84 = nodesById.get(joinId);
-    const mode = join84.config?.mode;
+    const join85 = nodesById.get(joinId);
+    const mode = join85.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 '${join84.id}' quorum must be a positive integer`);
+        throw new WorkflowIrError(`join '${join85.id}' quorum must be a positive integer`);
       }
       if (n > branchEdges.length) {
         throw new WorkflowIrError(
-          `join '${join84.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
+          `join '${join85.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
         );
       }
     }
@@ -24074,14 +24074,14 @@ async function detectWorkspaceRepos(dir, runner = runGitCommand, timeout = DEFAU
     return [];
   }
   const { stat: stat10 } = await import("node:fs/promises");
-  const { join: join84 } = await import("node:path");
+  const { join: join85 } = 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 = join84(dir, entry);
+    const childDir = join85(dir, entry);
     try {
-      const s3 = await stat10(join84(childDir, ".git"));
+      const s3 = await stat10(join85(childDir, ".git"));
       if (!s3.isDirectory() && !s3.isFile()) continue;
     } catch {
       continue;
@@ -24094,9 +24094,9 @@ async function detectWorkspaceRepos(dir, runner = runGitCommand, timeout = DEFAU
 }
 async function isWorkspaceModeExplicitlyDisabled(projectPath) {
   try {
-    const { readFile: readFile40 } = await import("node:fs/promises");
-    const { join: join84 } = await import("node:path");
-    const raw = await readFile40(join84(projectPath, ".fusion", "config.json"), "utf-8");
+    const { readFile: readFile41 } = await import("node:fs/promises");
+    const { join: join85 } = await import("node:path");
+    const raw = await readFile41(join85(projectPath, ".fusion", "config.json"), "utf-8");
     const config3 = JSON.parse(raw);
     return config3.settings?.workspaceMode === false;
   } catch {
@@ -24104,12 +24104,12 @@ async function isWorkspaceModeExplicitlyDisabled(projectPath) {
   }
 }
 async function setWorkspaceModeInConfig(projectPath, value) {
-  const { readFile: readFile40, writeFile: writeFile31, mkdir: mkdir29 } = await import("node:fs/promises");
-  const { join: join84 } = await import("node:path");
-  const configPath = join84(projectPath, ".fusion", "config.json");
+  const { readFile: readFile41, writeFile: writeFile31, mkdir: mkdir29 } = await import("node:fs/promises");
+  const { join: join85 } = await import("node:path");
+  const configPath = join85(projectPath, ".fusion", "config.json");
   let config3 = {};
   try {
-    config3 = JSON.parse(await readFile40(configPath, "utf-8"));
+    config3 = JSON.parse(await readFile41(configPath, "utf-8"));
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
@@ -24118,7 +24118,7 @@ async function setWorkspaceModeInConfig(projectPath, value) {
   }
   const settings = config3.settings;
   settings.workspaceMode = value;
-  await mkdir29(join84(projectPath, ".fusion"), { recursive: true });
+  await mkdir29(join85(projectPath, ".fusion"), { recursive: true });
   await writeFile31(configPath, JSON.stringify(config3, null, 2), "utf-8");
 }
 function isInRootRelativePath(entry, pathMod) {
@@ -24131,12 +24131,12 @@ function isInRootRelativePath(entry, pathMod) {
   return true;
 }
 async function loadWorkspaceConfig(rootDir) {
-  const { readFile: readFile40 } = await import("node:fs/promises");
+  const { readFile: readFile41 } = await import("node:fs/promises");
   const pathMod = await import("node:path");
-  const { join: join84 } = pathMod;
-  const configPath = join84(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME);
+  const { join: join85 } = pathMod;
+  const configPath = join85(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME);
   try {
-    const raw = await readFile40(configPath, "utf-8");
+    const raw = await readFile41(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;
@@ -24150,11 +24150,11 @@ async function loadWorkspaceConfig(rootDir) {
 }
 async function saveWorkspaceConfig(rootDir, config3) {
   const { mkdir: mkdir29, writeFile: writeFile31 } = await import("node:fs/promises");
-  const { join: join84 } = await import("node:path");
-  const fusionDir = join84(rootDir, ".fusion");
+  const { join: join85 } = await import("node:path");
+  const fusionDir = join85(rootDir, ".fusion");
   await mkdir29(fusionDir, { recursive: true });
   await writeFile31(
-    join84(fusionDir, WORKSPACE_CONFIG_FILENAME),
+    join85(fusionDir, WORKSPACE_CONFIG_FILENAME),
     JSON.stringify(config3, null, 2),
     "utf-8"
   );
@@ -38983,11 +38983,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 join84 = fk.childColumns.map((column, index2) => `child.${quoteIdentifier(column)} IS NOT DISTINCT FROM parent.${quoteIdentifier(fk.parentColumns[index2])}`).join(" AND ");
+      const join85 = 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 ${join84}
+        JOIN ${relationName({ schema: fk.parentSchema, table: fk.parentTable })} parent ON ${join85}
         JOIN fusion_rekey_conflict_candidates parent_candidate
           ON parent_candidate.schema_name = ${quoteLiteral(fk.parentSchema)}
          AND parent_candidate.table_name = ${quoteLiteral(fk.parentTable)}
@@ -49824,8 +49824,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static async parseFile(filePath) {
-        const { readFile: readFile40 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
-        const data = await readFile40(filePath, "utf8");
+        const { readFile: readFile41 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
+        const data = await readFile41(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -132897,6 +132897,23 @@ var init_worktrunk_installer = __esm({
 });
 
 // ../engine/src/active-session-registry.ts
+function acquireActiveSessionPath(registry3, path5, registration, options = {}) {
+  const existing = registry3.lookupByPath(path5);
+  if (!existing || existing.taskId === registration.taskId) {
+    registry3.registerPath(path5, 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, path5) ?? true;
+  if (holderIsLive || ageMs < minIdleMs) {
+    return { action: "contended", holderTaskId: existing.taskId, holderKind: existing.kind, ageMs };
+  }
+  registry3.unregisterPath(path5);
+  registry3.registerPath(path5, registration);
+  return { action: "reclaimed-stale-foreign", holderTaskId: existing.taskId, ageMs };
+}
 function reconcileSelfOwnedActiveSessionForRemoval(registry3, worktreePath, requestingTaskId, liveBindingProbe, options = {}) {
   const record2 = registry3.lookupByPath(worktreePath);
   if (!record2) {
@@ -136283,10 +136300,10 @@ async function runHoldReleaseSweep(store, deps) {
   }
   return result;
 }
-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;
   }
@@ -136328,7 +136345,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);
@@ -136339,17 +136356,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 (error2) {
+        schedulerLog.warn(
+          `Force-promote for ${task.id} could not clear replan status: ${error2 instanceof Error ? error2.message : String(error2)}`
+        );
+      }
+    }
+    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);
@@ -137273,8 +137323,8 @@ var require_graceful_fs = __commonJS({
       fs10.createReadStream = createReadStream;
       fs10.createWriteStream = createWriteStream;
       var fs$readFile = fs10.readFile;
-      fs10.readFile = readFile40;
-      function readFile40(path5, options, cb) {
+      fs10.readFile = readFile41;
+      function readFile41(path5, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path5, options, cb);
@@ -162576,6 +162626,12 @@ var init_usage_limit_detector = __esm({
 });
 
 // ../engine/src/transient-error-patterns.ts
+function isSessionContentionError(errorMessage) {
+  if (!errorMessage || typeof errorMessage !== "string") {
+    return false;
+  }
+  return SESSION_CONTENTION_PATTERNS.some((pattern) => pattern.test(errorMessage));
+}
 function isTransientError(errorMessage) {
   if (!errorMessage || typeof errorMessage !== "string") {
     return false;
@@ -162583,6 +162639,9 @@ function isTransientError(errorMessage) {
   if (isTransientAuthCredentialError(errorMessage)) {
     return true;
   }
+  if (isSessionContentionError(errorMessage)) {
+    return true;
+  }
   return TRANSIENT_ERROR_PATTERNS.some((pattern) => pattern.test(errorMessage));
 }
 function isTransientAuthCredentialError(errorMessage) {
@@ -162594,7 +162653,7 @@ function isTransientAuthCredentialError(errorMessage) {
   }
   return TRANSIENT_AUTH_CREDENTIAL_ROTATION_PATTERN.test(errorMessage);
 }
-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";
@@ -162655,6 +162714,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;
   }
@@ -162663,6 +162730,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 errorMessage = input.errorMessage?.trim();
@@ -169753,6 +169823,86 @@ var init_research_step_runner = __esm({
   }
 });
 
+// ../engine/src/plan-artifact-writeback.ts
+import { readFile as readFile33 } from "node:fs/promises";
+import { join as join66 } from "node:path";
+function relativePromptPath(taskId) {
+  return `.fusion/tasks/${taskId}/PROMPT.md`;
+}
+async function readIfPresent(path5) {
+  try {
+    return await readFile33(path5, "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(join66(rootDir, relPath));
+  if (planningCwd === rootDir) {
+    return { outcome: "not-worktree", content: rootContent ?? void 0 };
+  }
+  const worktreeContent = await readIfPresent(join66(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 (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    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 (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    options.logger?.warn?.(`${taskId}: failed to mirror the plan into the project database: ${message}`);
+    return false;
+  }
+}
+async function persistPlanArtifact(options) {
+  const result = await reconcileWorktreePlanArtifact(options);
+  const mirrored = result.content ? await mirrorPlanToProjectDb(options.store, options.taskId, result.content, {
+    author: options.author,
+    logger: options.logger
+  }) : false;
+  return { ...result, 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;
@@ -170780,9 +170930,9 @@ function assertInRootRepoRelPath(repoRelPath, sep12, isAbsolute22, 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: join84, isAbsolute: isAbsolute22, normalize: normalize8, sep: sep12 } = await import("node:path");
+  const { join: join85, isAbsolute: isAbsolute22, normalize: normalize8, sep: sep12 } = await import("node:path");
   assertInRootRepoRelPath(repoRelPath, sep12, isAbsolute22, normalize8);
-  const repoAbsPath = join84(workspaceRootDir, repoRelPath);
+  const repoAbsPath = join85(workspaceRootDir, repoRelPath);
   const existing = task.workspaceWorktrees?.[repoRelPath];
   if (existing) {
     let live = existsSync52(existing.worktreePath);
@@ -170971,11 +171121,11 @@ var init_worktree_acquisition = __esm({
 });
 
 // ../engine/src/agent-tools.ts
-import { appendFile as appendFile3, mkdir as mkdir26, readFile as readFile33, readdir as readdir9, realpath, stat as stat9, writeFile as writeFile25 } from "node:fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir26, readFile as readFile34, readdir as readdir9, realpath, stat as stat9, writeFile as writeFile25 } from "node:fs/promises";
 import { existsSync as existsSync53 } from "node:fs";
 import { createHash as createHash16, randomUUID as randomUUID45 } from "node:crypto";
 import { tmpdir as tmpdir6 } from "node:os";
-import { extname as extname3, isAbsolute as isAbsolute13, join as join66, relative as relative11, resolve as resolve32, sep as sep9 } from "node:path";
+import { extname as extname3, isAbsolute as isAbsolute13, join as join67, 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";
@@ -170987,16 +171137,16 @@ function agentDreamsDisplayPath(agentId) {
   return `${AGENT_MEMORY_ROOT3}/${sanitizeAgentMemoryId(agentId)}/${AGENT_DREAMS_FILENAME2}`;
 }
 function agentMemoryDirectory(rootDir, agentId) {
-  return join66(rootDir, AGENT_MEMORY_ROOT3, sanitizeAgentMemoryId(agentId));
+  return join67(rootDir, AGENT_MEMORY_ROOT3, sanitizeAgentMemoryId(agentId));
 }
 function agentMemoryFilePath(rootDir, agentId) {
-  return join66(agentMemoryDirectory(rootDir, agentId), AGENT_MEMORY_FILENAME2);
+  return join67(agentMemoryDirectory(rootDir, agentId), AGENT_MEMORY_FILENAME2);
 }
 function agentDreamsFilePath(rootDir, agentId) {
-  return join66(agentMemoryDirectory(rootDir, agentId), AGENT_DREAMS_FILENAME2);
+  return join67(agentMemoryDirectory(rootDir, agentId), AGENT_DREAMS_FILENAME2);
 }
 function agentDailyFilePath(rootDir, agentId, date5 = /* @__PURE__ */ new Date()) {
-  return join66(agentMemoryDirectory(rootDir, agentId), `${date5.toISOString().slice(0, 10)}.md`);
+  return join67(agentMemoryDirectory(rootDir, agentId), `${date5.toISOString().slice(0, 10)}.md`);
 }
 async function readAgentMemoryWorkspaceLongTerm(rootDir, agentId) {
   const safeRoot = typeof rootDir === "string" ? rootDir.trim() : "";
@@ -171010,7 +171160,7 @@ async function readAgentMemoryWorkspaceLongTerm(rootDir, agentId) {
     if (!fileStat.isFile()) {
       return "";
     }
-    const content = await readFile33(filePath, "utf-8");
+    const content = await readFile34(filePath, "utf-8");
     return typeof content === "string" ? content.trim() : "";
   } catch {
     return "";
@@ -171089,7 +171239,7 @@ async function listAgentMemoryFiles2(rootDir, agentMemory) {
   }
   for (const entry of entries) {
     if (!DAILY_AGENT_MEMORY_RE2.test(entry)) continue;
-    const absPath = join66(dir, entry);
+    const absPath = join67(dir, entry);
     const fileStat = await stat9(absPath);
     if (fileStat.isFile()) {
       files.push({
@@ -171112,7 +171262,7 @@ async function searchAgentMemoryFile(rootDir, agentMemory, query, limit) {
   }
   const results = [];
   for (const file of await listAgentMemoryFiles2(rootDir, agentMemory)) {
-    const content = await readFile33(file.absPath, "utf-8");
+    const content = await readFile34(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();
@@ -171258,7 +171408,7 @@ function resolveAgentMemoryPath(rootDir, agentId, path5) {
     return null;
   }
   return {
-    absPath: join66(agentMemoryDirectory(rootDir, agentId), filename),
+    absPath: join67(agentMemoryDirectory(rootDir, agentId), filename),
     displayPath: `${prefix}${filename}`
   };
 }
@@ -171268,7 +171418,7 @@ async function getAgentMemoryWindow(rootDir, agentMemory, path5, startLine = 1,
     return null;
   }
   await syncAgentMemoryFile(rootDir, agentMemory);
-  const content = await readFile33(resolved.absPath, "utf-8");
+  const content = await readFile34(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));
@@ -171918,6 +172068,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: {}
@@ -172132,7 +172285,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 readFile33(canonicalPath);
+  const data = await readFile34(canonicalPath);
   if (params.type === "image") {
     if (!mimeType.startsWith("image/")) {
       throw new Error(`image artifacts require an image/* mimeType, got ${mimeType}.`);
@@ -172475,25 +172628,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
@@ -174676,6 +174837,7 @@ var init_agent_tools = __esm({
     init_provider_registry();
     init_research_step_runner();
     init_logger();
+    init_plan_artifact_writeback();
     init_web_fetch();
     init_agent_action_gate();
     init_message_delivery();
@@ -174855,6 +175017,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({
@@ -175239,8 +175414,8 @@ var init_agent_tools = __esm({
 });
 
 // ../engine/src/agent-memory-index.ts
-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 clampUtf8(input, maxBytes) {
   if (Buffer.byteLength(input, "utf8") <= maxBytes) return input;
   let out = "";
@@ -175272,7 +175447,7 @@ function parseHeadings(content) {
 }
 async function buildFileSection(sectionHeader, displayPath, fsPath) {
   try {
-    const content = await readFile34(fsPath, "utf-8");
+    const content = await readFile35(fsPath, "utf-8");
     const headings = parseHeadings(content);
     const lines = [sectionHeader, `- ${displayPath}`];
     for (const entry of headings) {
@@ -175288,9 +175463,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 = join67(rootDir, ".fusion", "agent-memory", safeAgentId, "MEMORY.md");
+  const agentFsPath = join68(rootDir, ".fusion", "agent-memory", safeAgentId, "MEMORY.md");
   const projectDisplayPath = ".fusion/memory/MEMORY.md";
-  const projectFsPath = join67(rootDir, ".fusion", "memory", "MEMORY.md");
+  const projectFsPath = join68(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)
@@ -175309,7 +175484,7 @@ var init_agent_memory_index = __esm({
 });
 
 // ../engine/src/agent-instructions.ts
-import { readFile as readFile35, writeFile as writeFile26, mkdir as mkdir27, access as access8 } from "node:fs/promises";
+import { readFile as readFile36, writeFile as writeFile26, mkdir as mkdir27, access as access8 } from "node:fs/promises";
 import { isAbsolute as isAbsolute14, resolve as resolve33, relative as relative12, normalize as normalize7, sep as sep10, dirname as dirname28 } from "node:path";
 function trimAndClamp(value, maxLength, label, agentId) {
   const trimmed = value.trim();
@@ -175370,7 +175545,7 @@ async function resolveAgentHeartbeatProcedure(agent, rootDir) {
     return null;
   }
   try {
-    const content = await readFile35(filePath, "utf-8");
+    const content = await readFile36(filePath, "utf-8");
     const normalized = trimAndClamp(
       content,
       MAX_INSTRUCTIONS_TEXT_LENGTH2,
@@ -175496,7 +175671,7 @@ async function resolveAgentInstructions(agent, rootDir, ratingSummary, inclusion
     const filePath = resolveValidatedInstructionsPath(agent.instructionsPath, rootDir, agent.id);
     if (filePath) {
       try {
-        const content = await readFile35(filePath, "utf-8");
+        const content = await readFile36(filePath, "utf-8");
         const normalizedContent = trimAndClamp(
           content,
           MAX_INSTRUCTIONS_TEXT_LENGTH2,
@@ -177329,10 +177504,10 @@ var init_verification_utils = __esm({
 import { exec as exec19 } from "node:child_process";
 import { createHash as createHash17 } from "node:crypto";
 import { existsSync as existsSync54, 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 promisify24 } from "node:util";
 function hasInstallState(rootDir) {
-  return existsSync54(join68(rootDir, "node_modules")) || existsSync54(join68(rootDir, ".pnp.cjs"));
+  return existsSync54(join69(rootDir, "node_modules")) || existsSync54(join69(rootDir, ".pnp.cjs"));
 }
 function getConfiguredWorktreeInitCommand(settings) {
   const trimmed = settings?.worktreeInitCommand?.trim();
@@ -177341,17 +177516,17 @@ function getConfiguredWorktreeInitCommand(settings) {
 function getDependencySyncCommand(rootDir, settings) {
   const configuredCommand = getConfiguredWorktreeInitCommand(settings);
   if (configuredCommand) return configuredCommand;
-  if (existsSync54(join68(rootDir, "pnpm-lock.yaml"))) return "pnpm install --frozen-lockfile";
-  if (existsSync54(join68(rootDir, "package-lock.json"))) return "npm install";
-  if (existsSync54(join68(rootDir, "yarn.lock"))) return "yarn install --frozen-lockfile";
-  if (existsSync54(join68(rootDir, "bun.lock")) || existsSync54(join68(rootDir, "bun.lockb"))) {
+  if (existsSync54(join69(rootDir, "pnpm-lock.yaml"))) return "pnpm install --frozen-lockfile";
+  if (existsSync54(join69(rootDir, "package-lock.json"))) return "npm install";
+  if (existsSync54(join69(rootDir, "yarn.lock"))) return "yarn install --frozen-lockfile";
+  if (existsSync54(join69(rootDir, "bun.lock")) || existsSync54(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 (existsSync54(p2)) {
       try {
         return createHash17("sha256").update(readFileSync18(p2)).digest("hex");
@@ -177364,7 +177539,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;
@@ -177372,7 +177547,7 @@ function readInstallMarker(rootDir) {
 }
 function writeInstallMarker(rootDir, hash) {
   try {
-    writeFileSync7(join68(rootDir, INSTALL_MARKER_RELPATH), hash);
+    writeFileSync7(join69(rootDir, INSTALL_MARKER_RELPATH), hash);
   } catch {
   }
 }
@@ -177463,7 +177638,7 @@ var init_merge_dependency_sync = __esm({
   "../engine/src/merge-dependency-sync.ts"() {
     "use strict";
     execAsync17 = promisify24(exec19);
-    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;
   }
@@ -178084,7 +178259,7 @@ var init_merger_glob = __esm({
 
 // ../engine/src/merger-workspace-test-commands.ts
 import { existsSync as existsSync55, 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 execSync3 } from "node:child_process";
 function quoteArg(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
@@ -178115,14 +178290,14 @@ function resolveWorkspacePackageRoots(rootDir, globs) {
   for (const glob of globs) {
     const starIdx = glob.indexOf("*");
     if (starIdx === -1) {
-      const candidate = join69(rootDir, glob);
-      if (existsSync55(join69(candidate, "package.json"))) {
+      const candidate = join70(rootDir, glob);
+      if (existsSync55(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);
@@ -178131,8 +178306,8 @@ function resolveWorkspacePackageRoots(rootDir, globs) {
     }
     for (const entry of entries) {
       const relPath = `${prefix.replace(/\/$/, "")}/${entry}`;
-      const absPath = join69(rootDir, relPath);
-      if (existsSync55(join69(absPath, "package.json"))) {
+      const absPath = join70(rootDir, relPath);
+      if (existsSync55(join70(absPath, "package.json"))) {
         roots.push(relPath);
       }
     }
@@ -178155,7 +178330,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) {
@@ -178172,7 +178347,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 [];
   }
@@ -178183,7 +178358,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");
@@ -178221,7 +178396,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;
   }
@@ -178263,7 +178438,7 @@ function deriveFileScopedPnpmTestCommand(rootDir, baseBranch, branch) {
     ];
     for (const candidate of candidates) {
       const normalized = candidate.startsWith("./") ? candidate.slice(2) : candidate;
-      if (existsSync55(join69(rootDir, normalized))) {
+      if (existsSync55(join70(rootDir, normalized))) {
         resolvedTests.add(normalized);
       }
     }
@@ -178291,7 +178466,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 {
@@ -178335,8 +178510,8 @@ function inferDefaultTestCommand(rootDir, explicitTestCommand, explicitBuildComm
     };
   }
   const buildSource = explicitBuildCommand?.trim() ? "explicit" : void 0;
-  if (existsSync55(join69(rootDir, "pnpm-lock.yaml"))) {
-    if (existsSync55(join69(rootDir, "pnpm-workspace.yaml"))) {
+  if (existsSync55(join70(rootDir, "pnpm-lock.yaml"))) {
+    if (existsSync55(join70(rootDir, "pnpm-workspace.yaml"))) {
       if (baseBranch?.trim() && branch?.trim()) {
         try {
           const scoped = deriveScopedPnpmTestCommand(rootDir, baseBranch.trim(), branch.trim());
@@ -178355,13 +178530,13 @@ function inferDefaultTestCommand(rootDir, explicitTestCommand, explicitBuildComm
     }
     return { command: "pnpm test", testSource: "inferred", buildSource };
   }
-  if (existsSync55(join69(rootDir, "yarn.lock"))) {
+  if (existsSync55(join70(rootDir, "yarn.lock"))) {
     return { command: "yarn test", testSource: "inferred", buildSource };
   }
-  if (existsSync55(join69(rootDir, "bun.lock")) || existsSync55(join69(rootDir, "bun.lockb"))) {
+  if (existsSync55(join70(rootDir, "bun.lock")) || existsSync55(join70(rootDir, "bun.lockb"))) {
     return { command: "bun test", testSource: "inferred", buildSource };
   }
-  if (existsSync55(join69(rootDir, "package-lock.json"))) {
+  if (existsSync55(join70(rootDir, "package-lock.json"))) {
     return { command: "npm test", testSource: "inferred", buildSource };
   }
   return null;
@@ -181353,7 +181528,7 @@ var init_merger_ref_update_advance = __esm({
 import { execFile as execFile21, spawn as spawn7 } from "node:child_process";
 import { promisify as promisify39 } from "node:util";
 import { copyFileSync, existsSync as existsSync56, 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 tmpdir7 } from "node:os";
 async function runGit4(args, cwd, timeoutMs) {
   const result = await execFileAsync14("git", ["-c", "core.quotePath=false", ...args], {
@@ -181439,9 +181614,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(tmpdir7(), "fusion-worktree-sync-"));
-  const patchPath = join70(stageDir, "edits.patch");
-  const untrackedDir = join70(stageDir, "untracked");
+  const stageDir = mkdtempSync2(join71(tmpdir7(), "fusion-worktree-sync-"));
+  const patchPath = join71(stageDir, "edits.patch");
+  const untrackedDir = join71(stageDir, "untracked");
   let preserveStageDir = false;
   try {
     mkdirSync9(untrackedDir, { recursive: true });
@@ -181461,8 +181636,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);
@@ -181525,13 +181700,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 (!existsSync56(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);
@@ -181600,8 +181775,8 @@ var init_worktree_ref_sync = __esm({
 
 // ../engine/src/merger-scope-auto-widen.ts
 import { exec as exec28 } from "node:child_process";
-import { readFile as readFile36, writeFile as writeFile27 } from "node:fs/promises";
-import { join as join71 } from "node:path";
+import { readFile as readFile37, writeFile as writeFile27 } from "node:fs/promises";
+import { join as join72 } from "node:path";
 import { promisify as promisify40 } from "node:util";
 function quoteArg4(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -181740,8 +181915,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 readFile36(promptPath, "utf-8");
+  const promptPath = join72(store.getTaskDir(taskId), "PROMPT.md");
+  const prompt = await readFile37(promptPath, "utf-8");
   const { before, section, after } = splitPromptSections(prompt);
   const existing = parseScopeEntries(section);
   const toAdd = files.filter((file) => !existing.has(file));
@@ -181897,7 +182072,7 @@ import * as childProcess4 from "node:child_process";
 import { promisify as promisify41 } from "node:util";
 import { existsSync as existsSync57, readFileSync as readFileSync21, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
 import { createHash as createHash19 } 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 Type3 } from "typebox";
 function mergerCommitEnv() {
@@ -182210,7 +182385,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 (!existsSync57(bootstrapScriptPath)) {
       const bootstrapMissingMessage = `${taskId}: [verification:bootstrap] script missing at scripts/ensure-test-artifacts.mjs \u2014 skipping preamble`;
@@ -182709,7 +182884,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,
@@ -182738,7 +182913,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 (!existsSync57(statusPath)) return null;
     const raw = readFileSync21(statusPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -183311,7 +183486,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 (!existsSync57(fullPath)) continue;
       const { stdout } = await execAsync27(
         `git grep -l -e "^<<<<<<< " -e "^=======$" -e "^>>>>>>> " --no-index -- ${quoteArg2(fullPath)}`,
@@ -183338,7 +183513,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 execAsync27(`git apply --3way --whitespace=nowarn ${quoteArg2(patchPath)}`, { cwd: rootDir });
@@ -184826,13 +185001,13 @@ async function isCherryPickInProgress(rootDir) {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const cherryPickHeadPath = join72(rootDir, cherryPickHeadPathOut.trim());
+    const cherryPickHeadPath = join73(rootDir, cherryPickHeadPathOut.trim());
     if (existsSync57(cherryPickHeadPath)) return true;
     const { stdout: sequencerPathOut } = await execAsync27("git rev-parse --git-path sequencer", {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const sequencerPath = join72(rootDir, sequencerPathOut.trim());
+    const sequencerPath = join73(rootDir, sequencerPathOut.trim());
     return existsSync57(sequencerPath);
   } catch {
     return false;
@@ -189874,7 +190049,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({
@@ -190433,7 +190608,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());
             }
@@ -191347,7 +191522,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") {
@@ -194147,9 +194322,9 @@ var Scheduler = class {
 import { exec as exec37, execFile as execFile26, execSync as execSync7 } from "node:child_process";
 import { promisify as promisify52 } from "node:util";
 import { setImmediate as setImmediateCb3 } from "node:timers";
-import { basename as basename19, delimiter as delimiter2, isAbsolute as isAbsolute18, join as join78, relative as relative16, resolve as resolvePath3 } from "node:path";
+import { basename as basename19, delimiter as delimiter2, isAbsolute as isAbsolute18, join as join79, 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 readFile37, rm as rm12, writeFile as writeFile29 } from "node:fs/promises";
+import { readFile as readFile38, rm as rm12, writeFile as writeFile29 } from "node:fs/promises";
 init_src2();
 
 // ../engine/src/auto-merge-finalization.ts
@@ -194544,6 +194719,7 @@ init_src2();
 // ../engine/src/workflow-graph-executor.ts
 init_src2();
 init_transient_error_detector();
+init_transient_error_patterns();
 
 // ../engine/src/required-workflow-artifacts.ts
 var REQUIRED_ARTIFACT_MISSING_PREFIX = "required-artifact-missing:";
@@ -194599,16 +194775,16 @@ async function persistBranchState(persistence, state) {
     );
   }
 }
-function resolveJoinConfig(join84) {
-  const rawMode = join84.config?.mode;
+function resolveJoinConfig(join85) {
+  const rawMode = join85.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 '${join84.id}' quorum must be a positive integer`);
+    else throw new WorkflowIrError(`join '${join85.id}' quorum must be a positive integer`);
   }
-  const rawFail = join84.config?.onBranchFailure;
+  const rawFail = join85.config?.onBranchFailure;
   const onBranchFailure = rawFail === "collect" ? "collect" : "fail-fast";
   return { mode, onBranchFailure };
 }
@@ -194624,9 +194800,9 @@ async function runSplitJoin(split, env) {
   if (branchEdges.length === 0) {
     throw new WorkflowIrError(`split '${split.id}' has no traversable branches`);
   }
-  const join84 = findMatchingJoin(branchEdges[0].to, env);
-  if (!join84) throw new WorkflowIrError(`split '${split.id}' has no reachable matching join`);
-  const joinConfig = resolveJoinConfig(env.nodeMap.get(join84));
+  const join85 = findMatchingJoin(branchEdges[0].to, env);
+  if (!join85) throw new WorkflowIrError(`split '${split.id}' has no reachable matching join`);
+  const joinConfig = resolveJoinConfig(env.nodeMap.get(join85));
   const controller = new AbortController();
   const branchCount = branchEdges.length;
   const required2 = requiredCompletions(joinConfig.mode, branchCount);
@@ -194662,7 +194838,7 @@ async function runSplitJoin(split, env) {
   };
   const branchPromises = branchEdges.map((edge) => {
     const branchId = edge.to;
-    return walkBranch(branchId, join84, env, controller.signal, visitedNodeIds).then((result) => {
+    return walkBranch(branchId, join85, env, controller.signal, visitedNodeIds).then((result) => {
       branchOutcomes.push({ branchId, outcome: result.outcome, nodeId: result.lastNodeId });
       if (result.outcome === "success") succeeded += 1;
       else failed += 1;
@@ -194680,7 +194856,7 @@ async function runSplitJoin(split, env) {
   });
   const outcome = await joinReached;
   await Promise.allSettled(branchPromises);
-  return { joinNodeId: join84, outcome, branchOutcomes, visitedNodeIds };
+  return { joinNodeId: join85, outcome, branchOutcomes, visitedNodeIds };
 }
 async function walkBranch(startNodeId, joinId, env, signal, visitedNodeIds) {
   let currentId = startNodeId;
@@ -195622,6 +195798,7 @@ function workflowNodeRequiresWorktree(node, { optionalGroupId, reviewerInlineFix
 // ../engine/src/workflow-graph-executor.ts
 var PLAN_REVIEW_PROVIDER_FAILURE_HOLD_VALUE = "plan-review-provider-failure-hold";
 var PLAN_REVIEW_LEASE_HELD_VALUE = "plan-review-lease-held";
+var SESSION_CONTENTION_HOLD_VALUE = "session-contention-hold";
 var WORKFLOW_INTERRUPTED_NODE_ID_CONTEXT_KEY = "workflow:interruptedNodeId";
 var WORKFLOW_INTERRUPTED_NODE_ABORT_KIND_CONTEXT_KEY = "workflow:interruptedNodeAbortKind";
 var WORKFLOW_OPTIONAL_GROUP_CONTEXT_KEY = "workflow:optionalGroupActive";
@@ -195991,6 +196168,15 @@ var WorkflowGraphExecutor = class {
         };
         context[`node:${node.id}:outcome`] = result2.outcome;
         if (result2.value !== void 0) context[`node:${node.id}:value`] = result2.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,
@@ -196374,6 +196560,7 @@ var WorkflowGraphExecutor = class {
       } catch (error2) {
         if (signal?.aborted) return this.withEnginePauseAbortContext(node, { outcome: "failure", value: "aborted" });
         lastError = error2;
+        if (isSessionContentionError(error2 instanceof Error ? error2.message : String(error2))) break;
       }
     }
     if (signal?.aborted) {
@@ -196392,11 +196579,13 @@ var WorkflowGraphExecutor = class {
       }
       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)) {
@@ -198050,11 +198239,11 @@ init_active_session_registry();
 // ../engine/src/cli-agent/task-session.ts
 import { mkdtemp as mkdtemp3, rm as rm10 } from "node:fs/promises";
 import { tmpdir as tmpdir8 } from "node:os";
-import { join as join74 } from "node:path";
+import { join as join75 } from "node:path";
 
 // ../engine/src/cli-agent/hook-scripts.ts
 import { mkdir as mkdir28, rm as rm9, writeFile as writeFile28 } from "node:fs/promises";
-import { join as join73 } from "node:path";
+import { join as join74 } from "node:path";
 var HOOK_SCRIPT_NAMES = {
   /** Main hook script: POSTs stdin payload (with the hook event name) to the route. */
   hook: "fusion-hook.sh",
@@ -198136,8 +198325,8 @@ exit 0
 async function writeSessionHookScripts(opts) {
   const { sessionId, token, endpointUrl, dir } = opts;
   await mkdir28(dir, { recursive: true, mode: 448 });
-  const hookScriptPath = join73(dir, HOOK_SCRIPT_NAMES.hook);
-  const notifyScriptPath = join73(dir, HOOK_SCRIPT_NAMES.notify);
+  const hookScriptPath = join74(dir, HOOK_SCRIPT_NAMES.hook);
+  const notifyScriptPath = join74(dir, HOOK_SCRIPT_NAMES.notify);
   await writeFile28(hookScriptPath, buildHookScriptContent({ sessionId, token, endpointUrl }), {
     mode: 448
   });
@@ -198313,9 +198502,9 @@ var CliTaskSession = class _CliTaskSession {
       isApproved: opts.isAutonomyApproved ?? (() => false)
     });
     const root = opts.hookDirRoot ?? tmpdir8();
-    const hookDir = await mkdtemp3(join74(root, "fusion-cli-hooks-"));
-    const hookScriptPath = join74(hookDir, HOOK_SCRIPT_NAMES.hook);
-    const settingsPath = join74(hookDir, "settings.json");
+    const hookDir = await mkdtemp3(join75(root, "fusion-cli-hooks-"));
+    const hookScriptPath = join75(hookDir, HOOK_SCRIPT_NAMES.hook);
+    const settingsPath = join75(hookDir, "settings.json");
     const cliAgentSettings = opts.config.cliAgentSettings ?? null;
     const operatorEnvAdditions = (cliAgentSettings?.envAdditions ?? []).filter(
       (k2) => !/^FUSION_/i.test(k2)
@@ -198568,7 +198757,7 @@ function killLiveTaskSessions(taskId, manager, store) {
 // ../engine/src/pty-native.ts
 import * as fs7 from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
-import { join as join75, dirname as dirname33 } from "node:path";
+import { join as join76, dirname as dirname33 } from "node:path";
 var isBunBinary = typeof Bun !== "undefined" && !!Bun.embeddedFiles;
 var ptyModule = null;
 var ptyLoadError = null;
@@ -198582,12 +198771,12 @@ function findInstalledNodePtyNativeDir() {
   try {
     const packageJsonPath = require4.resolve("node-pty/package.json");
     const pkgRoot = dirname33(packageJsonPath);
-    const releaseDir = join75(pkgRoot, "build", "Release");
-    if (fs7.existsSync(join75(releaseDir, "pty.node"))) {
+    const releaseDir = join76(pkgRoot, "build", "Release");
+    if (fs7.existsSync(join76(releaseDir, "pty.node"))) {
       return releaseDir;
     }
-    const prebuildDir = join75(pkgRoot, "prebuilds", getNativePrebuildName());
-    if (fs7.existsSync(join75(prebuildDir, "pty.node"))) {
+    const prebuildDir = join76(pkgRoot, "prebuilds", getNativePrebuildName());
+    if (fs7.existsSync(join76(prebuildDir, "pty.node"))) {
       return prebuildDir;
     }
     return null;
@@ -198598,14 +198787,14 @@ function findInstalledNodePtyNativeDir() {
 function findStagedNativeDir() {
   const prebuildName = getNativePrebuildName();
   if (process.env.FUSION_RUNTIME_DIR) {
-    const envPath = join75(process.env.FUSION_RUNTIME_DIR, prebuildName);
-    if (fs7.existsSync(join75(envPath, "pty.node"))) {
+    const envPath = join76(process.env.FUSION_RUNTIME_DIR, prebuildName);
+    if (fs7.existsSync(join76(envPath, "pty.node"))) {
       return envPath;
     }
   }
   const execDir = dirname33(process.execPath);
-  const nextToBinary = join75(execDir, "runtime", prebuildName);
-  if (fs7.existsSync(join75(nextToBinary, "pty.node"))) {
+  const nextToBinary = join76(execDir, "runtime", prebuildName);
+  if (fs7.existsSync(join76(nextToBinary, "pty.node"))) {
     return nextToBinary;
   }
   return null;
@@ -198628,8 +198817,8 @@ function ensureNodePtyNativePermissions() {
     candidateDirs.add(installedNativeDir);
   }
   for (const nativeDir of candidateDirs) {
-    const helperPath = join75(nativeDir, "spawn-helper");
-    const nativeModulePath = join75(nativeDir, "pty.node");
+    const helperPath = join76(nativeDir, "spawn-helper");
+    const nativeModulePath = join76(nativeDir, "pty.node");
     try {
       fs7.chmodSync(helperPath, 493);
     } catch {
@@ -198659,7 +198848,7 @@ async function loadPtyModule() {
         process.env.NODE_PTY_SPAWN_HELPER_DIR = nativeDir;
       }
       process.env.FUSION_NATIVE_ASSETS_PATH = nativeDir;
-      const nativePath = join75(nativeDir, "pty.node");
+      const nativePath = join76(nativeDir, "pty.node");
       if (fs7.existsSync(nativePath)) {
         try {
           const nativeModule = { exports: {} };
@@ -201779,7 +201968,7 @@ import { promisify as promisify49 } from "node:util";
 import { setImmediate as setImmediateCb2 } from "node:timers";
 import { existsSync as existsSync63, mkdirSync as mkdirSync10, readdirSync as readdirSync10, readFileSync as readFileSync22, realpathSync as realpathSync8, rmSync as rmSync8, statSync as statSync12, writeFileSync as writeFileSync10 } from "node:fs";
 import { tmpdir as tmpdir9 } from "node:os";
-import { isAbsolute as isAbsolute15, join as join76, relative as relative13, resolve as resolve37 } from "node:path";
+import { isAbsolute as isAbsolute15, join as join77, relative as relative13, resolve as resolve37 } from "node:path";
 init_transient_error_detector();
 
 // ../engine/src/auto-claim-snapshot.ts
@@ -207202,9 +207391,9 @@ async function preserveWorktreeChanges(repoDir, worktreePath, taskId) {
       return null;
     }
     const diff = (await execAsync32("git diff HEAD --binary", { cwd: worktreePath, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 })).stdout;
-    const recoveryDir = join76(repoDir, ".fusion", "recovery");
+    const recoveryDir = join77(repoDir, ".fusion", "recovery");
     mkdirSync10(recoveryDir, { recursive: true });
-    const patchPath = join76(recoveryDir, `${taskId.toLowerCase()}-${formatRecoveryTimestamp()}.patch`);
+    const patchPath = join77(recoveryDir, `${taskId.toLowerCase()}-${formatRecoveryTimestamp()}.patch`);
     writeFileSync10(patchPath, diff, "utf-8");
     return patchPath;
   } catch (error2) {
@@ -207212,6 +207401,7 @@ async function preserveWorktreeChanges(repoDir, worktreePath, taskId) {
     return null;
   }
 }
+var PRE_EXECUTION_WORKTREE_MAX_IDLE_MS = 30 * 24 * 60 * 60 * 1e3;
 var APPROVED_TRIAGE_RECOVERY_GRACE_MS = 6e4;
 var STARVED_REFINEMENT_RECOVERY_GRACE_MS = 10 * 6e4;
 var STARVED_PEER_PROGRESS_THRESHOLD = 3;
@@ -208569,6 +208759,35 @@ var SelfHealingManager = class _SelfHealingManager {
     }
     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(
@@ -208610,20 +208829,14 @@ var SelfHealingManager = class _SelfHealingManager {
     }
     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) {
@@ -208970,6 +209183,8 @@ var SelfHealingManager = class _SelfHealingManager {
           { 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() },
@@ -209837,14 +210052,21 @@ var SelfHealingManager = class _SelfHealingManager {
             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;
@@ -213784,7 +214006,7 @@ var SelfHealingManager = class _SelfHealingManager {
           const unrecoverableRepos = [];
           for (const repoRel of repoKeys) {
             const entry = workspaceWorktrees[repoRel];
-            const repoRootDir = join76(this.options.rootDir, repoRel);
+            const repoRootDir = join77(this.options.rootDir, repoRel);
             let integrationBranch;
             try {
               integrationBranch = await resolveIntegrationBranch(
@@ -213996,6 +214218,58 @@ var SelfHealingManager = class _SelfHealingManager {
       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
@@ -214026,7 +214300,7 @@ var SelfHealingManager = class _SelfHealingManager {
           if ((this.orphanWorktreeRemovalFailures.get(worktreePath) ?? 0) >= MAX_STARVATION_DROPS) {
             continue;
           }
-          const repoRootDir = join76(this.options.rootDir, repoRel);
+          const repoRootDir = join77(this.options.rootDir, repoRel);
           let success = false;
           let reason = "removed";
           try {
@@ -214947,7 +215221,7 @@ var SelfHealingManager = class _SelfHealingManager {
     if (testWorkerRoot) {
       try {
         for (const entry of readdirSync10(testWorkerRoot)) {
-          if (entry.startsWith("redir-")) roots.push(join76(testWorkerRoot, entry));
+          if (entry.startsWith("redir-")) roots.push(join77(testWorkerRoot, entry));
         }
       } catch {
       }
@@ -214961,7 +215235,7 @@ var SelfHealingManager = class _SelfHealingManager {
       } catch {
         continue;
       }
-      for (const entry of entries) paths2.push(join76(root, entry));
+      for (const entry of entries) paths2.push(join77(root, entry));
     }
     return paths2;
   }
@@ -215197,14 +215471,10 @@ var SelfHealingManager = class _SelfHealingManager {
       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;
@@ -216866,7 +217136,7 @@ var SelfHealingManager = class _SelfHealingManager {
       let processedMarkers = 0;
       for (const task of candidates) {
         try {
-          const promptPath = join76(this.options.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+          const promptPath = join77(this.options.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
           if (!existsSync63(promptPath)) {
             continue;
           }
@@ -217253,7 +217523,7 @@ var SelfHealingManager = class _SelfHealingManager {
     if (!existsSync63(worktreesDir)) return 0;
     let dirs;
     try {
-      dirs = readdirSync10(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join76(worktreesDir, e.name));
+      dirs = readdirSync10(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join77(worktreesDir, e.name));
     } catch (err) {
       log28.warn(`Failed to read .worktrees/ for unregistered orphan reap: ${err instanceof Error ? err.message : String(err)}`);
       return 0;
@@ -217323,7 +217593,7 @@ var SelfHealingManager = class _SelfHealingManager {
         }
         if (entries.length === 0) continue;
         for (const entry of entries) {
-          const path5 = join76(tempRoot, entry);
+          const path5 = join77(tempRoot, entry);
           let canonicalPath = path5;
           let cleanupReason = "stale";
           try {
@@ -217715,7 +217985,7 @@ init_src2();
 init_logger();
 init_verification_concurrency();
 import { existsSync as existsSync64, readdirSync as readdirSync11, readFileSync as readFileSync23 } from "node:fs";
-import { isAbsolute as isAbsolute16, join as join77, relative as relative14 } from "node:path";
+import { isAbsolute as isAbsolute16, join as join78, relative as relative14 } from "node:path";
 import { Type as Type5 } from "@earendil-works/pi-ai";
 var MAX_OUTPUT_BYTES = 200 * 1024;
 var QUIET_HEARTBEAT_INTERVAL_MS = 6e4;
@@ -217840,7 +218110,7 @@ function findWorkspacePackageDir(rootDir, packageName) {
   for (const candidate of candidates) {
     if (!candidate) continue;
     try {
-      const pkg = JSON.parse(readFileSync23(join77(rootDir, candidate, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync23(join78(rootDir, candidate, "package.json"), "utf8"));
       if (pkg.name === packageName) {
         packageDirCache.set(cacheKey, candidate);
         return candidate;
@@ -217855,7 +218125,7 @@ function findWorkspacePackageDir(rootDir, packageName) {
   while (queue.length > 0) {
     const current = queue.shift();
     if (!current) break;
-    const abs = join77(rootDir, current.dir);
+    const abs = join78(rootDir, current.dir);
     let entries;
     try {
       entries = readdirSync11(abs, { withFileTypes: true });
@@ -217865,9 +218135,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 = join77(current.dir, entry.name);
+      const child = join78(current.dir, entry.name);
       try {
-        const pkg = JSON.parse(readFileSync23(join77(rootDir, child, "package.json"), "utf8"));
+        const pkg = JSON.parse(readFileSync23(join78(rootDir, child, "package.json"), "utf8"));
         if (pkg.name === packageName) {
           packageDirCache.set(cacheKey, child);
           return child;
@@ -217887,7 +218157,7 @@ function toPackageRelativeFilter(token, rootDir, packageDir) {
     return normalized.slice(normalizedPackageDir.length + 1);
   }
   if (isAbsolute16(token)) {
-    const rel = relative14(join77(rootDir, packageDir), token).replace(/\\/g, "/");
+    const rel = relative14(join78(rootDir, packageDir), token).replace(/\\/g, "/");
     if (!rel.startsWith("../") && rel !== "..") return rel;
   }
   return token;
@@ -218175,7 +218445,7 @@ function createRunVerificationTool(opts) {
       if (params.cwd && isAbsolute16(params.cwd)) {
         resolvedCwd = params.cwd;
       } else if (params.cwd) {
-        resolvedCwd = join77(worktreePath, params.cwd);
+        resolvedCwd = join78(worktreePath, params.cwd);
       } else {
         resolvedCwd = worktreePath;
       }
@@ -218208,7 +218478,7 @@ function createRunVerificationTool(opts) {
         warnings.push(...normalized.warnings);
       }
       if (effectiveCommand.trimStart().startsWith("pnpm --filter")) {
-        const modulesYaml = join77(rootDir, "node_modules", ".modules.yaml");
+        const modulesYaml = join78(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.`;
@@ -218498,7 +218768,7 @@ function isWorkflowStepSkillDiscoverable(skillName, additionalSkillPaths, ceSkil
     return false;
   }
   return (additionalSkillPaths ?? []).some(
-    (skillPath) => basename19(skillPath) === bareSkillName && existsSync65(join78(skillPath, "SKILL.md")) || existsSync65(join78(skillPath, bareSkillName, "SKILL.md"))
+    (skillPath) => basename19(skillPath) === bareSkillName && existsSync65(join79(skillPath, "SKILL.md")) || existsSync65(join79(skillPath, bareSkillName, "SKILL.md"))
   );
 }
 var yieldEventLoop3 = () => new Promise((resolve40) => setImmediateCb3(resolve40));
@@ -218601,6 +218871,9 @@ var MAX_TASK_DONE_SESSION_RETRIES = 3;
 var MAX_TASK_DONE_REQUEUE_RETRIES = 3;
 var MAX_TRANSIENT_GRAPH_RESUME_RETRIES = 2;
 var TRANSIENT_GRAPH_RESUME_RETRY_BACKOFF_MS = process.env.VITEST || process.env.NODE_ENV === "test" ? 0 : 1e3;
+var MAX_SESSION_CONTENTION_HOLD_RETRIES = 10;
+var SESSION_CONTENTION_HOLD_BACKOFF_MS = process.env.VITEST || process.env.NODE_ENV === "test" ? 0 : 5e3;
+var SESSION_CONTENTION_HOLD_MAX_BACKOFF_MS = 6e4;
 var COMPLETED_TASK_WATCHDOG_MS = 6e4;
 var WORKFLOW_RERUN_WATCHDOG_MS = 15e3;
 var LOOP_COMPACTION_TIMEOUT_MS = 6e4;
@@ -218823,7 +219096,7 @@ function normalizeWorktreePath(pathValue) {
 }
 async function extractPersistedSessionWorktreePath(sessionFile, rootDir, settings) {
   try {
-    const content = await readFile37(sessionFile, "utf-8");
+    const content = await readFile38(sessionFile, "utf-8");
     const matches = content.match(buildSessionWorktreePathRegex(rootDir, settings)) ?? [];
     if (matches.length === 0) return null;
     const normalizedCounts = /* @__PURE__ */ new Map();
@@ -219340,6 +219613,15 @@ var TaskExecutor = class _TaskExecutor {
             }
           })
         );
+      } 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(
@@ -219929,15 +220211,63 @@ var TaskExecutor = class _TaskExecutor {
   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)) {
@@ -219955,7 +220285,7 @@ var TaskExecutor = class _TaskExecutor {
   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);
@@ -219969,7 +220299,7 @@ var TaskExecutor = class _TaskExecutor {
   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);
@@ -221841,7 +222171,7 @@ ${info.feedback}`, revisionKey),
       const authoritativeAgentLayer = this.store.getAsyncLayer();
       if (!this.authoritativeAssignedAgentStore || authoritativeAgentLayer && !this.authoritativeAssignedAgentStore.backendMode) {
         this.authoritativeAssignedAgentStore = new AgentStore({
-          rootDir: join78(this.rootDir, ".fusion"),
+          rootDir: join79(this.rootDir, ".fusion"),
           taskStore: this.store,
           ...authoritativeAgentLayer ? { asyncLayer: authoritativeAgentLayer } : {}
         });
@@ -224288,6 +224618,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 (error2) {
+      executorLog.warn(`${taskId}: could not release the pre-execution worktree: ${formatError(error2).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 (error2) {
+      executorLog.warn(`${taskId}: could not acquire a planning worktree \u2014 planning falls back to the repo root: ${formatError(error2)}`);
+      return null;
+    }
+  }
   async prepareGraphNodeExecution(node, nodeTask, settings, requirement) {
     if (!requirement.requiresWorktree) return;
     const live = await this.store.getTask(nodeTask.id);
@@ -224414,22 +224825,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;
@@ -224726,6 +225144,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(result) {
+    if (!result.context) return [];
+    const texts = [];
+    for (const [key, value] of Object.entries(result.context)) {
+      if (key.endsWith(":error") && typeof value === "string" && value.trim()) texts.push(value);
+    }
+    return texts;
+  }
+  isSessionContentionGraphFailure(result) {
+    if (this.graphFailureValue(result) === SESSION_CONTENTION_HOLD_VALUE) return true;
+    return this.graphFailureErrorTexts(result).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, result) {
+    const detail = this.graphFailureErrorTexts(result).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(result) {
     const failedNode = result.visitedNodeIds[result.visitedNodeIds.length - 1];
     if (!failedNode || !result.context) return void 0;
@@ -225317,6 +225806,11 @@ Graph value: ${failureValue}` : ""}`, budget.key),
         await this.persistTokenUsage(task.id);
         return;
       }
+      if (this.isSessionContentionGraphFailure(result)) {
+        await this.holdForSessionContention(task, live, result);
+        await this.persistTokenUsage(task.id);
+        return;
+      }
       if (await this.routeUnusableWorktreeGraphFailureToRecovery(task, live, result)) {
         await this.persistTokenUsage(task.id);
         return;
@@ -226137,7 +226631,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 = join78(this.store.getFusionDir(), "tasks");
+      const tasksDir = join79(this.store.getFusionDir(), "tasks");
       const promptPath = getPromptPath(tasksDir, task.id);
       const staleness = await evaluateSpecStaleness({ settings, promptPath, task });
       if (staleness.isStale) {
@@ -229998,10 +230492,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 = join78(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
+    const promptPath = join79(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
     let content;
     try {
-      content = await readFile37(promptPath, "utf-8");
+      content = await readFile38(promptPath, "utf-8");
     } catch {
       executorLog.warn(`${task.id}: PROMPT.md not found at ${promptPath}, skipping workflow failure injection`);
       return;
@@ -241174,7 +241668,7 @@ init_effective_settings();
 
 // ../engine/src/spec-validation/task-document-references.ts
 import { access as access9 } from "node:fs/promises";
-import { join as join79 } from "node:path";
+import { join as join80 } from "node:path";
 var TASK_PATH_REGEX = /\.fusion\/tasks\/[A-Z0-9]+(?:-[A-Z0-9]+)*\/[^\s`'"\]]+/g;
 function normalizePathToken(token) {
   return token.replace(/^[`([{"']+/, "").replace(/[`),.;:!?\]}'"]+$/, "");
@@ -241263,7 +241757,7 @@ async function detectDanglingTaskDocReferences(promptContent, opts) {
   }
   const dangling = [];
   for (const [path5, sections] of references.entries()) {
-    const absPath = join79(opts.rootDir, path5);
+    const absPath = join80(opts.rootDir, path5);
     if (await existsImpl(absPath)) continue;
     dangling.push({ path: path5, sections: Array.from(sections).sort() });
   }
@@ -241286,14 +241780,15 @@ init_agent_logger();
 init_agent_instructions();
 init_fallback_model_observer();
 init_logger();
+init_plan_artifact_writeback();
 init_mcp_resolution();
 init_usage_limit_detector();
 init_transient_error_detector();
 init_rate_limit_retry();
 init_agent_tools();
 import { exec as exec41 } from "node:child_process";
-import { readFile as readFile38, writeFile as writeFile30, rm as rm13 } from "node:fs/promises";
-import { join as join80 } from "node:path";
+import { readFile as readFile39, writeFile as writeFile30, rm as rm13 } from "node:fs/promises";
+import { join as join81 } from "node:path";
 import { promisify as promisify56 } from "node:util";
 
 // ../engine/src/triage-preflight.ts
@@ -241523,6 +242018,33 @@ var TriageProcessor = class _TriageProcessor {
       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;
@@ -241581,6 +242103,8 @@ var TriageProcessor = class _TriageProcessor {
   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)
@@ -241689,6 +242213,9 @@ var TriageProcessor = class _TriageProcessor {
       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);
     });
@@ -241736,6 +242263,9 @@ var TriageProcessor = class _TriageProcessor {
       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");
   }
@@ -241934,8 +242464,8 @@ var TriageProcessor = class _TriageProcessor {
     }
     const settings = await mergeEffectiveSettings(this.store, task, await this.store.getSettings());
     const approvalRequired = resolvePlanApprovalRequired(settings);
-    const promptPath = join80(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
-    const written = await readFile38(promptPath, "utf-8").catch((err) => {
+    const promptPath = join81(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+    const written = await readFile39(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 "";
@@ -241973,8 +242503,8 @@ var TriageProcessor = class _TriageProcessor {
     return true;
   }
   async readNonEmptyPromptDraft(taskId, context) {
-    const promptPath = join80(this.rootDir, ".fusion", "tasks", taskId, "PROMPT.md");
-    const written = await readFile38(promptPath, "utf-8").catch((err) => {
+    const promptPath = join81(this.rootDir, ".fusion", "tasks", taskId, "PROMPT.md");
+    const written = await readFile39(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 "";
@@ -242138,8 +242668,8 @@ var TriageProcessor = class _TriageProcessor {
         continue;
       }
       try {
-        const promptPath = join80(this.rootDir, ".fusion", "tasks", todoTask.id, "PROMPT.md");
-        const content = await readFile38(promptPath, "utf-8");
+        const promptPath = join81(this.rootDir, ".fusion", "tasks", todoTask.id, "PROMPT.md");
+        const content = await readFile39(promptPath, "utf-8");
         if (isUnplannedSeedPrompt(content, todoTask.id, todoTask.title, todoTask.description)) {
           eligibleTodoTasks.push(todoTask);
         }
@@ -242350,7 +242880,7 @@ var TriageProcessor = class _TriageProcessor {
       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 () => {
@@ -242527,11 +243057,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",
@@ -242682,8 +243216,22 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
             }
             return;
           }
-          const written = await readFile38(
-            join80(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 readFile39(
+            join81(this.rootDir, promptPath),
             "utf-8"
           ).catch((err) => {
             const msg = err instanceof Error ? err.message : String(err);
@@ -243300,7 +243848,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 rm13(join80(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+            await rm13(join81(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
           })) return;
           await this.updatePlanningStateIfStillCurrent(task, { paused: false, pausedReason: null, status: null });
         }
@@ -243311,7 +243859,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 rm13(join80(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+            await rm13(join81(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
           })) return;
           await this.updatePlanningStateIfStillCurrent(task, {
             paused: false,
@@ -243352,7 +243900,7 @@ Remove or replace these ids and call fn_task_create again.`
         return;
       }
       if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
-        await rm13(join80(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+        await rm13(join81(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
       })) return;
       if (!await this.updatePlanningStateIfStillCurrent(task, {
         paused: false,
@@ -243417,7 +243965,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 = join80(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+        const promptPath = join81(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
         try {
           if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
             await writeFile30(promptPath, nextPrompt, "utf-8");
@@ -243429,6 +243977,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: [],
@@ -243705,10 +244257,10 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
   if (!attachments || attachments.length === 0) {
     return { attachmentContents, imageContents };
   }
-  const { readFile: readFile40 } = await import("node:fs/promises");
-  const { join: join84 } = await import("node:path");
+  const { readFile: readFile41 } = await import("node:fs/promises");
+  const { join: join85 } = await import("node:path");
   for (const att of attachments) {
-    const filePath = join84(
+    const filePath = join85(
       rootDir,
       ".fusion",
       "tasks",
@@ -243718,7 +244270,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
     );
     try {
       if (IMAGE_MIME_TYPES.has(att.mimeType)) {
-        const data = await readFile40(filePath);
+        const data = await readFile41(filePath);
         const detectedMimeType = detectImageMimeFromBytes(data);
         const imageMimeType = detectedMimeType ?? att.mimeType;
         if (detectedMimeType && detectedMimeType !== att.mimeType) {
@@ -243735,7 +244287,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
           text: null
         });
       } else {
-        const data = await readFile40(filePath, "utf-8");
+        const data = await readFile41(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,
@@ -244963,6 +245515,9 @@ var InProcessRuntime = class extends EventEmitter27 {
           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}...`);
@@ -245051,6 +245606,8 @@ var InProcessRuntime = class extends EventEmitter27 {
         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
@@ -247090,7 +247647,7 @@ function extractAdvisorAssistantText(session) {
 // ../engine/src/overseer-watchdog.ts
 init_logger();
 import { existsSync as existsSync67, readFileSync as readFileSync24 } from "node:fs";
-import { dirname as dirname34, join as join81, relative as relative17, resolve as resolve39, sep as sep11 } from "node:path";
+import { dirname as dirname34, join as join82, relative as relative17, resolve as resolve39, sep as sep11 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 var log32 = createLogger("overseer-watchdog");
 var WATCHDOG_FILENAMES = ["OVERSEER.md", "WATCHDOG.md"];
@@ -247121,7 +247678,7 @@ function discoverOverseerWatchdogFiles(options) {
     };
     if (agentDir) {
       for (const name2 of WATCHDOG_FILENAMES) {
-        tryAdd(join81(agentDir, name2), "user", 999);
+        tryAdd(join82(agentDir, name2), "user", 999);
       }
     }
     let current = cwd;
@@ -247129,9 +247686,9 @@ function discoverOverseerWatchdogFiles(options) {
     for (let hop = 0; hop < 64; hop++) {
       const depth = relative17(cwd, current) === "" ? 0 : relative17(cwd, current).split(sep11).filter(Boolean).length;
       for (const name2 of WATCHDOG_FILENAMES) {
-        tryAdd(join81(current, name2), "project", depth);
-        tryAdd(join81(current, ".fusion", name2), "project", depth);
-        tryAdd(join81(current, ".omp", name2), "project", depth);
+        tryAdd(join82(current, name2), "project", depth);
+        tryAdd(join82(current, ".fusion", name2), "project", depth);
+        tryAdd(join82(current, ".omp", name2), "project", depth);
       }
       if (current === stopAt) break;
       const parent = dirname34(current);
@@ -248096,7 +248653,7 @@ import { promisify as promisify58 } 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 join83 } from "node:path";
+import { join as join84 } from "node:path";
 
 // ../engine/src/overseer-noop-finalize-veto.ts
 init_src2();
@@ -248190,7 +248747,7 @@ import { execFile as execFile28 } from "node:child_process";
 import { appendFileSync as appendFileSync2, existsSync as existsSync68, mkdirSync as mkdirSync11, readdirSync as readdirSync12, readFileSync as readFileSync25, realpathSync as 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 isAbsolute21, join as join82, relative as relative18 } from "node:path";
+import { isAbsolute as isAbsolute21, join as join83, relative as relative18 } from "node:path";
 import { promisify as promisify57 } from "node:util";
 init_worktree_paths();
 var execFileAsync21 = promisify57(execFile28);
@@ -248223,7 +248780,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 = join82(projectRootDir, ".git", "info", "exclude");
+  const excludePath = join83(projectRootDir, ".git", "info", "exclude");
   if (!existsSync68(excludePath)) return;
   try {
     const current = readFileSync25(excludePath, "utf-8");
@@ -248255,7 +248812,7 @@ function getAiMergeTempSearchRoots(projectRootDir, settings) {
   if (testWorkerRoot) {
     try {
       for (const entry of readdirSync12(testWorkerRoot)) {
-        if (entry.startsWith("redir-")) roots.push(join82(testWorkerRoot, entry));
+        if (entry.startsWith("redir-")) roots.push(join83(testWorkerRoot, entry));
       }
     } catch {
     }
@@ -248278,7 +248835,7 @@ async function pruneExistingAiMergeWorktrees(taskId, projectRootDir, audit, log3
       continue;
     }
     for (const entry of entries) {
-      const candidatePath = join82(tempRoot, entry);
+      const candidatePath = join83(tempRoot, entry);
       let canonicalPath = candidatePath;
       try {
         canonicalPath = realpathSync10(candidatePath);
@@ -248754,7 +249311,7 @@ function listAiMergeWorktreeCandidates(taskId, projectRootDir, settings) {
   if (testWorkerRoot) {
     try {
       for (const entry of readdirSync13(testWorkerRoot)) {
-        if (entry.startsWith("redir-")) roots.push(join83(testWorkerRoot, entry));
+        if (entry.startsWith("redir-")) roots.push(join84(testWorkerRoot, entry));
       }
     } catch {
     }
@@ -248767,7 +249324,7 @@ function listAiMergeWorktreeCandidates(taskId, projectRootDir, settings) {
     } catch {
       continue;
     }
-    for (const entry of entries) candidates.push(join83(root, entry));
+    for (const entry of entries) candidates.push(join84(root, entry));
   }
   return candidates;
 }
@@ -249111,7 +249668,7 @@ async function landOneRepo(repoRootDir, branch, integrationBranch, ctx) {
       registeredMergePaths.add(pathToRegister);
     };
     try {
-      mergeRoot = await mkdtemp4(join83(resolveAiMergeRoot(repoRootDir, settings), `fusion-ai-merge-${taskId.toLowerCase()}-`));
+      mergeRoot = await mkdtemp4(join84(resolveAiMergeRoot(repoRootDir, settings), `fusion-ai-merge-${taskId.toLowerCase()}-`));
       registerMergeRoot(mergeRoot);
       await git5(["worktree", "add", "--detach", mergeRoot, tipSha], repoRootDir);
       worktreeAdded = true;
@@ -249628,7 +250185,7 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
     for (const repoRel of repoKeys) {
       throwIfAborted2(options.signal, taskId);
       const entry = workspaceWorktrees[repoRel];
-      const repoRootDir = join83(workspaceRootDir, repoRel);
+      const repoRootDir = join84(workspaceRootDir, repoRel);
       let integrationBranch;
       try {
         integrationBranch = await resolveIntegrationBranch(
@@ -249945,7 +250502,7 @@ async function pushAfterMergeToRemote(input) {
   let worktreeAdded = false;
   const registeredPaths = /* @__PURE__ */ new Set();
   try {
-    pushRoot = await mkdtemp4(join83(resolveAiMergeRoot(projectRootDir, settings), `fusion-ai-merge-push-${taskId.toLowerCase()}-`));
+    pushRoot = await mkdtemp4(join84(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);