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

package/dist/extension.js

@@ -5525,7 +5525,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       sql2.raw = raw;
-      function join108(chunks, separator) {
+      function join109(chunks, separator) {
         const result2 = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -5535,7 +5535,7 @@ var init_sql = __esm({
         }
         return new SQL(result2);
       }
-      sql2.join = join108;
+      sql2.join = join109;
       function identifier(value) {
         return new Name(value);
       }
@@ -10183,7 +10183,7 @@ var init_select2 = __esm({
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table)) this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join108) => join108.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join109) => join109.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -11718,7 +11718,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join108) => join108.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join109) => join109.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -11814,10 +11814,10 @@ var init_update = __esm({
               const fromFields = this.getTableLikeFields(this.config.from);
               fields[tableName] = fromFields;
             }
-            for (const join108 of this.config.joins) {
-              const tableName2 = getTableLikeName(join108.table);
-              if (typeof tableName2 === "string" && !is(join108.table, SQL)) {
-                const fromFields = this.getTableLikeFields(join108.table);
+            for (const join109 of this.config.joins) {
+              const tableName2 = getTableLikeName(join109.table);
+              if (typeof tableName2 === "string" && !is(join109.table, SQL)) {
+                const fromFields = this.getTableLikeFields(join109.table);
                 fields[tableName2] = fromFields;
               }
             }
@@ -20421,26 +20421,26 @@ function validateParallelism(nodes2, outgoing, nodesById) {
     }
     const joinsReached = /* @__PURE__ */ new Set();
     for (const edge of branchEdges) {
-      const join109 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
-      if (!join109) {
+      const join110 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
+      if (!join110) {
         throw new WorkflowIrError(`split '${split.id}' has a branch with no reachable matching join`);
       }
-      joinsReached.add(join109);
+      joinsReached.add(join110);
     }
     if (joinsReached.size !== 1) {
       throw new WorkflowIrError(`split '${split.id}' branches converge on more than one join`);
     }
     const joinId = [...joinsReached][0];
-    const join108 = nodesById.get(joinId);
-    const mode = join108.config?.mode;
+    const join109 = nodesById.get(joinId);
+    const mode = join109.config?.mode;
     if (mode && typeof mode === "object" && "quorum" in mode) {
       const n = mode.quorum;
       if (typeof n !== "number" || !Number.isInteger(n) || n < 1) {
-        throw new WorkflowIrError(`join '${join108.id}' quorum must be a positive integer`);
+        throw new WorkflowIrError(`join '${join109.id}' quorum must be a positive integer`);
       }
       if (n > branchEdges.length) {
         throw new WorkflowIrError(
-          `join '${join108.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
+          `join '${join109.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
         );
       }
     }
@@ -23996,14 +23996,14 @@ async function detectWorkspaceRepos(dir, runner = runGitCommand, timeout = DEFAU
     return [];
   }
   const { stat: stat13 } = await import("node:fs/promises");
-  const { join: join108 } = await import("node:path");
+  const { join: join109 } = await import("node:path");
   const found = [];
   const EXCLUDED_ENTRIES = /* @__PURE__ */ new Set(["node_modules", ".fusion", ".git", ".pi"]);
   for (const entry of entries) {
     if (EXCLUDED_ENTRIES.has(entry)) continue;
-    const childDir = join108(dir, entry);
+    const childDir = join109(dir, entry);
     try {
-      const s3 = await stat13(join108(childDir, ".git"));
+      const s3 = await stat13(join109(childDir, ".git"));
       if (!s3.isDirectory() && !s3.isFile()) continue;
     } catch {
       continue;
@@ -24016,9 +24016,9 @@ async function detectWorkspaceRepos(dir, runner = runGitCommand, timeout = DEFAU
 }
 async function isWorkspaceModeExplicitlyDisabled(projectPath) {
   try {
-    const { readFile: readFile46 } = await import("node:fs/promises");
-    const { join: join108 } = await import("node:path");
-    const raw = await readFile46(join108(projectPath, ".fusion", "config.json"), "utf-8");
+    const { readFile: readFile47 } = await import("node:fs/promises");
+    const { join: join109 } = await import("node:path");
+    const raw = await readFile47(join109(projectPath, ".fusion", "config.json"), "utf-8");
     const config3 = JSON.parse(raw);
     return config3.settings?.workspaceMode === false;
   } catch {
@@ -24026,12 +24026,12 @@ async function isWorkspaceModeExplicitlyDisabled(projectPath) {
   }
 }
 async function setWorkspaceModeInConfig(projectPath, value) {
-  const { readFile: readFile46, writeFile: writeFile35, mkdir: mkdir32 } = await import("node:fs/promises");
-  const { join: join108 } = await import("node:path");
-  const configPath = join108(projectPath, ".fusion", "config.json");
+  const { readFile: readFile47, writeFile: writeFile35, mkdir: mkdir32 } = await import("node:fs/promises");
+  const { join: join109 } = await import("node:path");
+  const configPath = join109(projectPath, ".fusion", "config.json");
   let config3 = {};
   try {
-    config3 = JSON.parse(await readFile46(configPath, "utf-8"));
+    config3 = JSON.parse(await readFile47(configPath, "utf-8"));
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
@@ -24040,7 +24040,7 @@ async function setWorkspaceModeInConfig(projectPath, value) {
   }
   const settings = config3.settings;
   settings.workspaceMode = value;
-  await mkdir32(join108(projectPath, ".fusion"), { recursive: true });
+  await mkdir32(join109(projectPath, ".fusion"), { recursive: true });
   await writeFile35(configPath, JSON.stringify(config3, null, 2), "utf-8");
 }
 function isInRootRelativePath(entry, pathMod) {
@@ -24053,12 +24053,12 @@ function isInRootRelativePath(entry, pathMod) {
   return true;
 }
 async function loadWorkspaceConfig(rootDir) {
-  const { readFile: readFile46 } = await import("node:fs/promises");
+  const { readFile: readFile47 } = await import("node:fs/promises");
   const pathMod = await import("node:path");
-  const { join: join108 } = pathMod;
-  const configPath = join108(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME);
+  const { join: join109 } = pathMod;
+  const configPath = join109(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME);
   try {
-    const raw = await readFile46(configPath, "utf-8");
+    const raw = await readFile47(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object" && "repos" in parsed && Array.isArray(parsed.repos) && parsed.repos.every((r) => typeof r === "string")) {
       const rawRepos = parsed.repos;
@@ -24072,11 +24072,11 @@ async function loadWorkspaceConfig(rootDir) {
 }
 async function saveWorkspaceConfig(rootDir, config3) {
   const { mkdir: mkdir32, writeFile: writeFile35 } = await import("node:fs/promises");
-  const { join: join108 } = await import("node:path");
-  const fusionDir = join108(rootDir, ".fusion");
+  const { join: join109 } = await import("node:path");
+  const fusionDir = join109(rootDir, ".fusion");
   await mkdir32(fusionDir, { recursive: true });
   await writeFile35(
-    join108(fusionDir, WORKSPACE_CONFIG_FILENAME),
+    join109(fusionDir, WORKSPACE_CONFIG_FILENAME),
     JSON.stringify(config3, null, 2),
     "utf-8"
   );
@@ -38905,11 +38905,11 @@ async function rekeyFallbackProjectPartition(db, fallbackProjectId, registeredPr
       const parentKey = `${fk.parentSchema}.${fk.parentTable}`;
       if (!targetKeys.has(parentKey)) continue;
       const childTarget = targetKeys.has(`${fk.childSchema}.${fk.childTable}`);
-      const join108 = fk.childColumns.map((column, index2) => `child.${quoteIdentifier(column)} IS NOT DISTINCT FROM parent.${quoteIdentifier(fk.parentColumns[index2])}`).join(" AND ");
+      const join109 = fk.childColumns.map((column, index2) => `child.${quoteIdentifier(column)} IS NOT DISTINCT FROM parent.${quoteIdentifier(fk.parentColumns[index2])}`).join(" AND ");
       const registeredChildScope = childTarget ? ` AND child.${quoteIdentifier("project_id")} = ${quoteLiteral(registeredProjectId)}` : "";
       const unreplaced = await tx.execute(sql.raw(`SELECT EXISTS (
         SELECT 1 FROM ${relationName({ schema: fk.childSchema, table: fk.childTable })} child
-        JOIN ${relationName({ schema: fk.parentSchema, table: fk.parentTable })} parent ON ${join108}
+        JOIN ${relationName({ schema: fk.parentSchema, table: fk.parentTable })} parent ON ${join109}
         JOIN fusion_rekey_conflict_candidates parent_candidate
           ON parent_candidate.schema_name = ${quoteLiteral(fk.parentSchema)}
          AND parent_candidate.table_name = ${quoteLiteral(fk.parentTable)}
@@ -49746,8 +49746,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static async parseFile(filePath) {
-        const { readFile: readFile46 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
-        const data = await readFile46(filePath, "utf8");
+        const { readFile: readFile47 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
+        const data = await readFile47(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -132671,8 +132671,8 @@ var require_graceful_fs = __commonJS({
       fs10.createReadStream = createReadStream;
       fs10.createWriteStream = createWriteStream;
       var fs$readFile = fs10.readFile;
-      fs10.readFile = readFile46;
-      function readFile46(path10, options, cb) {
+      fs10.readFile = readFile47;
+      function readFile47(path10, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path10, options, cb);
@@ -135388,10 +135388,10 @@ async function runHoldReleaseSweep(store, deps) {
   }
   return result2;
 }
-async function issueRelease(store, deps, task, target, ir2) {
+async function issueRelease(store, deps, task, target, ir2, options = {}) {
   const targetColumn = findColumn2(ir2, target);
   const targetIsProcessing = targetColumn ? resolveColumnFlags(targetColumn).countsTowardWip === true : false;
-  if (targetIsProcessing && await isUnplannedForExecution(store, task, ir2)) {
+  if (targetIsProcessing && !options.allowUnplanned && await isUnplannedForExecution(store, task, ir2)) {
     schedulerLog.log(`Hold release for ${task.id} blocked \u2014 card is unplanned and cannot enter processing column ${target}`);
     return false;
   }
@@ -135433,7 +135433,7 @@ async function issueRelease(store, deps, task, target, ir2) {
     return false;
   }
 }
-async function promoteHeldTask(store, taskId, deps = {}) {
+async function promoteHeldTask(store, taskId, deps = {}, options = {}) {
   const task = await store.getTask(taskId);
   if (!task) return { released: false, rejection: "task-not-found" };
   const ir2 = await resolveWorkflowIrForTask(store, taskId);
@@ -135444,17 +135444,50 @@ async function promoteHeldTask(store, taskId, deps = {}) {
   if (!target) return { released: false, rejection: "no-release-target" };
   const targetColumn = findColumn2(ir2, target);
   const targetIsProcessing = targetColumn ? resolveColumnFlags(targetColumn).countsTowardWip === true : false;
-  if (targetIsProcessing && await isUnplannedForExecution(store, task, ir2)) {
+  const unplanned = targetIsProcessing && await isUnplannedForExecution(store, task, ir2);
+  if (unplanned && options.force !== true) {
     return { released: false, rejection: "unplanned-for-execution", toColumn: target };
   }
+  let promoted = task;
+  if (unplanned) {
+    if (task.status === "needs-replan" || task.status === "plan-review-unavailable") {
+      try {
+        await store.updateTask(task.id, { status: null });
+        promoted = { ...task, status: void 0 };
+      } catch (error3) {
+        schedulerLog.warn(
+          `Force-promote for ${task.id} could not clear replan status: ${error3 instanceof Error ? error3.message : String(error3)}`
+        );
+      }
+    }
+    if (typeof store.recordRunAuditEvent === "function") {
+      try {
+        await store.recordRunAuditEvent({
+          domain: "database",
+          mutationType: "task:promote-forced-unplanned",
+          target: task.id,
+          taskId: task.id,
+          agentId: "system",
+          runId: `promote-force-${task.id}`,
+          metadata: { fromColumn: task.column, toColumn: target, priorStatus: task.status ?? null }
+        });
+      } catch {
+      }
+    }
+    schedulerLog.log(`Force-promote for ${task.id} bypassing unplanned gate into ${target} (operator override)`);
+  }
   const released = await issueRelease(
     store,
     { now: () => Date.now(), reserveSlot: deps.reserveSlot, allocateWorktree: deps.allocateWorktree },
-    task,
+    promoted,
     target,
-    ir2
+    ir2,
+    { allowUnplanned: unplanned }
   );
-  return released ? { released: true, toColumn: target } : { released: false, rejection: "capacity-exhausted-or-no-slot" };
+  if (!released) {
+    return { released: false, rejection: "capacity-exhausted-or-no-slot" };
+  }
+  return { released: true, toColumn: target, forcedUnplanned: unplanned || void 0 };
 }
 async function releaseHeldTaskByEvent(store, taskId, eventTag, deps = {}) {
   const task = await store.getTask(taskId);
@@ -161627,6 +161660,86 @@ var init_research_step_runner = __esm({
   }
 });
 
+// ../engine/src/plan-artifact-writeback.ts
+import { readFile as readFile29 } from "node:fs/promises";
+import { join as join61 } from "node:path";
+function relativePromptPath(taskId) {
+  return `.fusion/tasks/${taskId}/PROMPT.md`;
+}
+async function readIfPresent(path10) {
+  try {
+    return await readFile29(path10, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function reconcileWorktreePlanArtifact(options) {
+  const { store, taskId, rootDir, planningCwd, logger: logger3 } = options;
+  const relPath = relativePromptPath(taskId);
+  const rootContent = await readIfPresent(join61(rootDir, relPath));
+  if (planningCwd === rootDir) {
+    return { outcome: "not-worktree", content: rootContent ?? void 0 };
+  }
+  const worktreeContent = await readIfPresent(join61(planningCwd, relPath));
+  if (worktreeContent === null) {
+    return { outcome: "no-worktree-artifact", content: rootContent ?? void 0 };
+  }
+  if (worktreeContent.trim().length === 0) {
+    return { outcome: "worktree-artifact-empty", content: rootContent ?? void 0 };
+  }
+  if (rootContent === worktreeContent) {
+    return { outcome: "already-authoritative", content: rootContent };
+  }
+  try {
+    await store.updateTask(taskId, { prompt: worktreeContent });
+    logger3?.log?.(
+      `${taskId}: recovered a worktree-local PROMPT.md into the project .fusion folder (${planningCwd})`
+    );
+    return { outcome: "recovered", content: worktreeContent };
+  } catch (error3) {
+    const message = error3 instanceof Error ? error3.message : String(error3);
+    logger3?.warn?.(
+      `${taskId}: failed to copy the worktree-local PROMPT.md back into the project .fusion folder: ${message}`
+    );
+    return { outcome: "recovery-failed", content: rootContent ?? void 0 };
+  }
+}
+async function mirrorPlanToProjectDb(store, taskId, content, options = {}) {
+  if (content.trim().length === 0) return false;
+  if (typeof store.upsertTaskDocument !== "function") return false;
+  try {
+    if (typeof store.getTaskDocument === "function") {
+      const existing = await store.getTaskDocument(taskId, PLAN_DOCUMENT_KEY);
+      if (typeof existing?.content === "string" && existing.content === content) return false;
+    }
+    await store.upsertTaskDocument(taskId, {
+      key: PLAN_DOCUMENT_KEY,
+      content,
+      author: options.author ?? "agent"
+    });
+    return true;
+  } catch (error3) {
+    const message = error3 instanceof Error ? error3.message : String(error3);
+    options.logger?.warn?.(`${taskId}: failed to mirror the plan into the project database: ${message}`);
+    return false;
+  }
+}
+async function persistPlanArtifact(options) {
+  const result2 = await reconcileWorktreePlanArtifact(options);
+  const mirrored = result2.content ? await mirrorPlanToProjectDb(options.store, options.taskId, result2.content, {
+    author: options.author,
+    logger: options.logger
+  }) : false;
+  return { ...result2, mirrored };
+}
+var PLAN_DOCUMENT_KEY;
+var init_plan_artifact_writeback = __esm({
+  "../engine/src/plan-artifact-writeback.ts"() {
+    "use strict";
+    PLAN_DOCUMENT_KEY = "plan";
+  }
+});
+
 // ../engine/src/auto-recovery-handlers/message-delivery.ts
 import { setTimeout as delay2 } from "node:timers/promises";
 var baseLog, MessageDeliveryAutoRecoveryHandler;
@@ -163636,7 +163749,7 @@ var init_worktree_prune = __esm({
 
 // ../engine/src/worktree-stale-lock.ts
 import { exec as exec8 } from "node:child_process";
-import { readFile as readFile30, stat as stat8, unlink as unlink9 } from "node:fs/promises";
+import { readFile as readFile31, stat as stat8, unlink as unlink9 } from "node:fs/promises";
 import { dirname as dirname23, resolve as resolve26 } from "node:path";
 import { promisify as promisify12 } from "node:util";
 function parseIndexLockPath(stderr) {
@@ -163661,7 +163774,7 @@ async function resolveOwningWorktreePath(input) {
   if (!worktreeName) return void 0;
   const gitdirFile = resolve26(dirname23(input.lockPath), "gitdir");
   try {
-    const gitdirRef = (await readFile30(gitdirFile, "utf-8")).trim();
+    const gitdirRef = (await readFile31(gitdirFile, "utf-8")).trim();
     if (gitdirRef) {
       const resolvedGitdirRef = resolve26(dirname23(gitdirFile), gitdirRef);
       if (resolvedGitdirRef.endsWith("/.git") || resolvedGitdirRef.endsWith("\\.git")) {
@@ -165040,7 +165153,7 @@ import { exec as exec11, execFile as execFile9 } from "node:child_process";
 import { promisify as promisify15 } from "node:util";
 import { existsSync as existsSync47, lstatSync as lstatSync2, readdirSync as readdirSync7, readFileSync as readFileSync16, rmSync as rmSync5, realpathSync as realpathSync6 } from "node:fs";
 import { mkdir as mkdir24 } from "node:fs/promises";
-import { basename as basename15, dirname as dirname24, join as join61, relative as relative8, resolve as resolve29, isAbsolute as isAbsolute9 } from "node:path";
+import { basename as basename15, dirname as dirname24, join as join62, relative as relative8, resolve as resolve29, isAbsolute as isAbsolute9 } from "node:path";
 async function getWorktrunkBinary(settings) {
   const cacheKey = `${process.env.HOME ?? ""}::${settings.binaryPath ?? ""}`;
   const cached2 = _worktrunkBinaryCache.get(cacheKey);
@@ -165191,7 +165304,7 @@ async function isRegisteredGitWorktree2(rootDir, worktreePath) {
   return (await getRegisteredWorktreePaths(rootDir)).has(canonicalizePath(worktreePath));
 }
 function hasRequiredWorktreeFiles(worktreePath) {
-  return existsSync47(join61(worktreePath, ".git"));
+  return existsSync47(join62(worktreePath, ".git"));
 }
 async function isInsideGitWorkTree2(worktreePath) {
   try {
@@ -165324,7 +165437,7 @@ async function scanIdleWorktrees(rootDir, store, settings) {
   let dirs;
   try {
     const entries = readdirSync7(worktreesDir, { withFileTypes: true });
-    dirs = entries.filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join61(worktreesDir, e.name));
+    dirs = entries.filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join62(worktreesDir, e.name));
   } catch (err) {
     const errorMessage2 = err instanceof Error ? err.message : String(err);
     worktreePoolLog.warn(`Failed to read .worktrees/ directory: ${errorMessage2}`);
@@ -165356,7 +165469,7 @@ async function cleanupOrphanedWorktrees(rootDir, store, settings) {
   let dirs = [];
   if (existsSync47(worktreesDir)) {
     try {
-      dirs = readdirSync7(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join61(worktreesDir, e.name));
+      dirs = readdirSync7(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join62(worktreesDir, e.name));
     } catch (err) {
       const errorMessage2 = err instanceof Error ? err.message : String(err);
       worktreePoolLog.warn(`Failed to read .worktrees/ directory for cleanup: ${errorMessage2}`);
@@ -165434,11 +165547,11 @@ async function reapOrphanWorktrees(projectRoot, settings) {
     entries = readdirSync7(worktreesDir, { withFileTypes: true }).filter((e) => {
       if (!e.isDirectory() || isAiMergeContainerDir(e.name)) return false;
       try {
-        return lstatSync2(join61(worktreesDir, e.name)).isDirectory() && !lstatSync2(join61(worktreesDir, e.name)).isSymbolicLink();
+        return lstatSync2(join62(worktreesDir, e.name)).isDirectory() && !lstatSync2(join62(worktreesDir, e.name)).isSymbolicLink();
       } catch {
         return false;
       }
-    }).map((e) => ({ name: e.name, fullPath: join61(worktreesDir, e.name) }));
+    }).map((e) => ({ name: e.name, fullPath: join62(worktreesDir, e.name) }));
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     worktreePoolLog.warn(`reapOrphanWorktrees: failed to read .worktrees/ \u2014 ${msg}`);
@@ -165457,7 +165570,7 @@ async function reapOrphanWorktrees(projectRoot, settings) {
     if (registered2.has(resolvedFull)) {
       continue;
     }
-    const dotGit = join61(resolvedFull, ".git");
+    const dotGit = join62(resolvedFull, ".git");
     if (existsSync47(dotGit)) {
       if (!dotGitPointerIsDangling(dotGit)) {
         worktreePoolLog.log(`reapOrphanWorktrees: skipping ${name2} (has .git entry but not in registered list \u2014 may be partially registered)`);
@@ -165823,27 +165936,27 @@ var init_worktree_pool = __esm({
 
 // ../engine/src/worktree-paths.ts
 import { homedir as homedir10 } from "node:os";
-import { basename as basename16, isAbsolute as isAbsolute10, join as join62, relative as relative9, resolve as resolve30 } from "node:path";
+import { basename as basename16, isAbsolute as isAbsolute10, join as join63, relative as relative9, resolve as resolve30 } from "node:path";
 function isAiMergeContainerDir(name2) {
   return name2 === AI_MERGE_DIRNAME;
 }
 function resolveAiMergeRootPath(rootDir, settings) {
-  return join62(resolveWorktreesDir(rootDir, settings), AI_MERGE_DIRNAME);
+  return join63(resolveWorktreesDir(rootDir, settings), AI_MERGE_DIRNAME);
 }
 function resolveLegacyAiMergeRootPath(rootDir) {
-  return join62(rootDir, ".fusion", "ai-merge");
+  return join63(rootDir, ".fusion", "ai-merge");
 }
 function resolveWorktreesDir(rootDir, settings) {
   const configured = settings?.worktreesDir;
   if (!configured) {
-    return join62(rootDir, ".worktrees");
+    return join63(rootDir, ".worktrees");
   }
   const expandedHome = configured.replace(/^~(?=$|[\\/])/, homedir10());
   const expandedRepo = expandedHome.replaceAll("{repo}", basename16(rootDir));
   return resolve30(rootDir, expandedRepo);
 }
 function resolveTaskWorktreePath(rootDir, settings, worktreeName) {
-  return join62(resolveWorktreesDir(rootDir, settings), worktreeName);
+  return join63(resolveWorktreesDir(rootDir, settings), worktreeName);
 }
 async function resolveTaskWorktreePathForBackend(rootDir, worktreeName, settings, backend, branch) {
   if (backend.kind === "worktrunk" && backend.resolveWorktreePath) {
@@ -166957,9 +167070,9 @@ function assertInRootRepoRelPath(repoRelPath, sep17, isAbsolute27, normalize8) {
 async function acquireWorkspaceRepoWorktree(opts) {
   const { repoRelPath, workspaceRootDir, task, store, settings, logger: logger3, secretsStore, audit, runContext, runConfiguredCommand: runConfiguredCommand2, taskEnv } = opts;
   const registry3 = opts.registry ?? activeSessionRegistry;
-  const { join: join108, isAbsolute: isAbsolute27, normalize: normalize8, sep: sep17 } = await import("node:path");
+  const { join: join109, isAbsolute: isAbsolute27, normalize: normalize8, sep: sep17 } = await import("node:path");
   assertInRootRepoRelPath(repoRelPath, sep17, isAbsolute27, normalize8);
-  const repoAbsPath = join108(workspaceRootDir, repoRelPath);
+  const repoAbsPath = join109(workspaceRootDir, repoRelPath);
   const existing = task.workspaceWorktrees?.[repoRelPath];
   if (existing) {
     let live = existsSync49(existing.worktreePath);
@@ -168683,7 +168796,7 @@ import { execFile as execFile11 } from "node:child_process";
 import { createRequire as createRequire6 } from "node:module";
 import { mkdtemp, rm as rm7, writeFile as writeFile24 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join63 } from "node:path";
+import { join as join64 } from "node:path";
 function getTransformSync() {
   if (!cachedTransformSync) {
     const req = createRequire6(import.meta.url);
@@ -168770,9 +168883,9 @@ function readStdin() {
 async function runCodeNode(opts) {
   const timeoutMs = resolveCodeNodeTimeout(opts.timeoutMs);
   const compiled = await compileCodeNodeSource(opts.source);
-  const dir = await mkdtemp(join63(tmpdir4(), "fusion-code-node-"));
-  const userModuleFile = join63(dir, "user.mjs");
-  const harnessFile = join63(dir, "harness.mjs");
+  const dir = await mkdtemp(join64(tmpdir4(), "fusion-code-node-"));
+  const userModuleFile = join64(dir, "user.mjs");
+  const harnessFile = join64(dir, "harness.mjs");
   try {
     await writeFile24(userModuleFile, compiled, "utf8");
     await writeFile24(harnessFile, buildChildHarness(userModuleFile), "utf8");
@@ -169000,11 +169113,11 @@ var init_code_node_runner = __esm({
 });
 
 // ../engine/src/agent-tools.ts
-import { appendFile as appendFile3, mkdir as mkdir26, readFile as readFile31, readdir as readdir9, realpath, stat as stat9, writeFile as writeFile25 } from "node:fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir26, readFile as readFile32, readdir as readdir9, realpath, stat as stat9, writeFile as writeFile25 } from "node:fs/promises";
 import { existsSync as existsSync50 } from "node:fs";
 import { createHash as createHash16, randomUUID as randomUUID45 } from "node:crypto";
 import { tmpdir as tmpdir5 } from "node:os";
-import { extname as extname3, isAbsolute as isAbsolute12, join as join64, relative as relative11, resolve as resolve32, sep as sep9 } from "node:path";
+import { extname as extname3, isAbsolute as isAbsolute12, join as join65, relative as relative11, resolve as resolve32, sep as sep9 } from "node:path";
 import { Type as Type2 } from "@earendil-works/pi-ai";
 function sanitizeAgentMemoryId(agentId) {
   return agentId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
@@ -169016,16 +169129,16 @@ function agentDreamsDisplayPath(agentId) {
   return `${AGENT_MEMORY_ROOT3}/${sanitizeAgentMemoryId(agentId)}/${AGENT_DREAMS_FILENAME2}`;
 }
 function agentMemoryDirectory(rootDir, agentId) {
-  return join64(rootDir, AGENT_MEMORY_ROOT3, sanitizeAgentMemoryId(agentId));
+  return join65(rootDir, AGENT_MEMORY_ROOT3, sanitizeAgentMemoryId(agentId));
 }
 function agentMemoryFilePath(rootDir, agentId) {
-  return join64(agentMemoryDirectory(rootDir, agentId), AGENT_MEMORY_FILENAME2);
+  return join65(agentMemoryDirectory(rootDir, agentId), AGENT_MEMORY_FILENAME2);
 }
 function agentDreamsFilePath(rootDir, agentId) {
-  return join64(agentMemoryDirectory(rootDir, agentId), AGENT_DREAMS_FILENAME2);
+  return join65(agentMemoryDirectory(rootDir, agentId), AGENT_DREAMS_FILENAME2);
 }
 function agentDailyFilePath(rootDir, agentId, date5 = /* @__PURE__ */ new Date()) {
-  return join64(agentMemoryDirectory(rootDir, agentId), `${date5.toISOString().slice(0, 10)}.md`);
+  return join65(agentMemoryDirectory(rootDir, agentId), `${date5.toISOString().slice(0, 10)}.md`);
 }
 async function readAgentMemoryWorkspaceLongTerm(rootDir, agentId) {
   const safeRoot = typeof rootDir === "string" ? rootDir.trim() : "";
@@ -169039,7 +169152,7 @@ async function readAgentMemoryWorkspaceLongTerm(rootDir, agentId) {
     if (!fileStat.isFile()) {
       return "";
     }
-    const content = await readFile31(filePath, "utf-8");
+    const content = await readFile32(filePath, "utf-8");
     return typeof content === "string" ? content.trim() : "";
   } catch {
     return "";
@@ -169118,7 +169231,7 @@ async function listAgentMemoryFiles2(rootDir, agentMemory) {
   }
   for (const entry of entries) {
     if (!DAILY_AGENT_MEMORY_RE2.test(entry)) continue;
-    const absPath = join64(dir, entry);
+    const absPath = join65(dir, entry);
     const fileStat = await stat9(absPath);
     if (fileStat.isFile()) {
       files.push({
@@ -169141,7 +169254,7 @@ async function searchAgentMemoryFile(rootDir, agentMemory, query, limit) {
   }
   const results = [];
   for (const file of await listAgentMemoryFiles2(rootDir, agentMemory)) {
-    const content = await readFile31(file.absPath, "utf-8");
+    const content = await readFile32(file.absPath, "utf-8");
     const lines = content.split("\n");
     for (let index2 = 0; index2 < lines.length; index2 += 8) {
       const chunk = lines.slice(index2, index2 + 12).join("\n").trim();
@@ -169287,7 +169400,7 @@ function resolveAgentMemoryPath(rootDir, agentId, path10) {
     return null;
   }
   return {
-    absPath: join64(agentMemoryDirectory(rootDir, agentId), filename),
+    absPath: join65(agentMemoryDirectory(rootDir, agentId), filename),
     displayPath: `${prefix}${filename}`
   };
 }
@@ -169297,7 +169410,7 @@ async function getAgentMemoryWindow(rootDir, agentMemory, path10, startLine = 1,
     return null;
   }
   await syncAgentMemoryFile(rootDir, agentMemory);
-  const content = await readFile31(resolved.absPath, "utf-8");
+  const content = await readFile32(resolved.absPath, "utf-8");
   const lines = content.split("\n");
   const start = Math.max(1, Math.floor(startLine));
   const count2 = Math.max(1, Math.min(Math.floor(lineCount), 200));
@@ -169956,6 +170069,9 @@ function createTaskPromptWriteTool(store, taskId, runContext) {
         if (persisted?.prompt !== params.content) {
           throw new Error("authoritative PROMPT.md read-back did not match the requested content; persistence could not be verified");
         }
+        await mirrorPlanToProjectDb(store, taskId, params.content, {
+          author: runContext?.agentId ?? "agent"
+        });
         return {
           content: [{ type: "text", text: `Updated PROMPT.md for ${taskId}.` }],
           details: {}
@@ -170244,7 +170360,7 @@ async function readArtifactFileFromPath(params, baseDir) {
   if (!mimeType) {
     throw new Error(`Could not infer a MIME type from ${resolvedPath}; pass mimeType explicitly.`);
   }
-  const data = await readFile31(canonicalPath);
+  const data = await readFile32(canonicalPath);
   if (params.type === "image") {
     if (!mimeType.startsWith("image/")) {
       throw new Error(`image artifacts require an image/* mimeType, got ${mimeType}.`);
@@ -170587,25 +170703,33 @@ function createTaskPromoteTool(store, currentTaskId) {
   return {
     name: "fn_task_promote",
     label: "Promote Held Task",
-    description: "Manually promote a held task out of its hold column, releasing it regardless of the hold's release kind (the explicit operator action a 'manual' hold waits for). Defaults to the current task. Returns the destination column, or a rejection reason when the task is not held or the destination is full.",
+    description: "Manually promote a held task out of its hold column, releasing it regardless of the hold's release kind (the explicit operator action a 'manual' hold waits for). Defaults to the current task. Returns the destination column, or a rejection reason when the task is not held or the destination is full. Pass force:true to start execution even when planning or plan review is still outstanding (that waives the plan gate and cancels the pending replan; capacity still applies).",
     parameters: taskPromoteParams,
     execute: async (_id, params) => {
       const taskId = params.task_id?.trim() || currentTaskId;
+      const force = params.force === true;
       try {
-        const outcome = await promoteHeldTask(store, taskId);
+        const outcome = await promoteHeldTask(store, taskId, {}, { force });
         if (outcome.released) {
+          const forcedNote = outcome.forcedUnplanned ? " Forced past the outstanding planning/plan review \u2014 the pending replan was cancelled." : "";
           return {
             content: [{
               type: "text",
-              text: `Promoted ${taskId} to column '${outcome.toColumn}'.`
+              text: `Promoted ${taskId} to column '${outcome.toColumn}'.${forcedNote}`
             }],
-            details: { taskId, released: true, toColumn: outcome.toColumn }
+            details: {
+              taskId,
+              released: true,
+              toColumn: outcome.toColumn,
+              forcedUnplanned: outcome.forcedUnplanned === true
+            }
           };
         }
+        const forceHint = outcome.rejection === "unplanned-for-execution" ? " Pass force:true to start execution anyway." : "";
         return {
           content: [{
             type: "text",
-            text: `ERROR: Could not promote ${taskId}: ${outcome.rejection ?? "unknown"}.`
+            text: `ERROR: Could not promote ${taskId}: ${outcome.rejection ?? "unknown"}.${forceHint}`
           }],
           details: { taskId, released: false, rejection: outcome.rejection },
           isError: true
@@ -172829,6 +172953,7 @@ var init_agent_tools = __esm({
     init_provider_registry();
     init_research_step_runner();
     init_logger3();
+    init_plan_artifact_writeback();
     init_web_fetch();
     init_agent_action_gate();
     init_message_delivery();
@@ -173008,6 +173133,19 @@ var init_agent_tools = __esm({
     taskPromoteParams = Type2.Object({
       task_id: Type2.Optional(
         Type2.String({ description: "Held task to promote. Defaults to the current task." })
+      ),
+      /*
+      FNXC:WorkflowScheduling 2026-07-25-05:40:
+      Agent-native parity with the dashboard's force-promote override: an agent that
+      has read the card and judged the pending replan / Plan Review not worth waiting
+      for can start execution anyway. Opt-in per call and never defaulted on — the
+      automatic surfaces (hold-release sweep, webhook release) still cannot force, so
+      FN-7648 holds for everything that is not an explicit promote request.
+      */
+      force: Type2.Optional(
+        Type2.Boolean({
+          description: "Start execution even when the task is still waiting on planning or plan review (rejection 'unplanned-for-execution'). Waives ONLY that gate \u2014 hold membership and downstream capacity still apply \u2014 and cancels the pending replan. Default false."
+        })
       )
     });
     workflowCreateParams = Type2.Object({
@@ -177316,7 +177454,7 @@ Follow instructions precisely and avoid unrelated changes.`,
 
 // ../engine/src/spec-validation/task-document-references.ts
 import { access as access7 } from "node:fs/promises";
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 function normalizePathToken(token) {
   return token.replace(/^[`([{"']+/, "").replace(/[`),.;:!?\]}'"]+$/, "");
 }
@@ -177404,7 +177542,7 @@ async function detectDanglingTaskDocReferences(promptContent, opts) {
   }
   const dangling = [];
   for (const [path10, sections] of references.entries()) {
-    const absPath = join65(opts.rootDir, path10);
+    const absPath = join66(opts.rootDir, path10);
     if (await existsImpl(absPath)) continue;
     dangling.push({ path: path10, sections: Array.from(sections).sort() });
   }
@@ -177665,8 +177803,8 @@ var init_session_skill_context = __esm({
 });
 
 // ../engine/src/agent-memory-index.ts
-import { readFile as readFile32 } from "node:fs/promises";
-import { join as join66 } from "node:path";
+import { readFile as readFile33 } from "node:fs/promises";
+import { join as join67 } from "node:path";
 function clampUtf8(input, maxBytes) {
   if (Buffer.byteLength(input, "utf8") <= maxBytes) return input;
   let out = "";
@@ -177698,7 +177836,7 @@ function parseHeadings(content) {
 }
 async function buildFileSection(sectionHeader, displayPath, fsPath) {
   try {
-    const content = await readFile32(fsPath, "utf-8");
+    const content = await readFile33(fsPath, "utf-8");
     const headings = parseHeadings(content);
     const lines = [sectionHeader, `- ${displayPath}`];
     for (const entry of headings) {
@@ -177714,9 +177852,9 @@ async function buildFileSection(sectionHeader, displayPath, fsPath) {
 async function buildMemoryIndex({ rootDir, agentId }) {
   const safeAgentId = agentId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
   const agentDisplayPath = `.fusion/agent-memory/${safeAgentId}/MEMORY.md`;
-  const agentFsPath = join66(rootDir, ".fusion", "agent-memory", safeAgentId, "MEMORY.md");
+  const agentFsPath = join67(rootDir, ".fusion", "agent-memory", safeAgentId, "MEMORY.md");
   const projectDisplayPath = ".fusion/memory/MEMORY.md";
-  const projectFsPath = join66(rootDir, ".fusion", "memory", "MEMORY.md");
+  const projectFsPath = join67(rootDir, ".fusion", "memory", "MEMORY.md");
   const [agentSection, projectSection] = await Promise.all([
     buildFileSection("## Agent Memory Index (use fn_memory_search / fn_memory_get to read)", agentDisplayPath, agentFsPath),
     buildFileSection("## Project Memory Index", projectDisplayPath, projectFsPath)
@@ -177735,7 +177873,7 @@ var init_agent_memory_index = __esm({
 });
 
 // ../engine/src/agent-instructions.ts
-import { readFile as readFile33, writeFile as writeFile26, mkdir as mkdir27, access as access8 } from "node:fs/promises";
+import { readFile as readFile34, writeFile as writeFile26, mkdir as mkdir27, access as access8 } from "node:fs/promises";
 import { constants as fsConstants3 } from "node:fs";
 import { isAbsolute as isAbsolute13, resolve as resolve33, relative as relative12, normalize as normalize7, sep as sep10, dirname as dirname28 } from "node:path";
 function trimAndClamp(value, maxLength, label, agentId) {
@@ -177797,7 +177935,7 @@ async function resolveAgentHeartbeatProcedure(agent, rootDir) {
     return null;
   }
   try {
-    const content = await readFile33(filePath, "utf-8");
+    const content = await readFile34(filePath, "utf-8");
     const normalized = trimAndClamp(
       content,
       MAX_INSTRUCTIONS_TEXT_LENGTH2,
@@ -177943,7 +178081,7 @@ async function resolveAgentInstructions(agent, rootDir, ratingSummary, inclusion
     const filePath = resolveValidatedInstructionsPath(agent.instructionsPath, rootDir, agent.id);
     if (filePath) {
       try {
-        const content = await readFile33(filePath, "utf-8");
+        const content = await readFile34(filePath, "utf-8");
         const normalizedContent = trimAndClamp(
           content,
           MAX_INSTRUCTIONS_TEXT_LENGTH2,
@@ -185950,8 +186088,8 @@ var init_mission_symbol_admission = __esm({
 
 // ../engine/src/scheduler.ts
 import { existsSync as existsSync54 } from "node:fs";
-import { readFile as readFile34 } from "node:fs/promises";
-import { join as join67 } from "node:path";
+import { readFile as readFile35 } from "node:fs/promises";
+import { join as join68 } from "node:path";
 function logTaskRouting(taskId, node) {
   const message = `Task ${taskId} routed to node=${node.nodeId ?? "local"} (source=${node.source})`;
   if (node.nodeId === void 0) {
@@ -186584,16 +186722,16 @@ var init_scheduler = __esm({
         if (typeof this.store.getTasksDir !== "function") {
           return { valid: true };
         }
-        const taskDir = join67(this.store.getTasksDir(), id);
+        const taskDir = join68(this.store.getTasksDir(), id);
         if (!existsSync54(taskDir)) {
           return { valid: false, reason: "missing directory" };
         }
-        const promptPath = join67(taskDir, "PROMPT.md");
+        const promptPath = join68(taskDir, "PROMPT.md");
         if (!existsSync54(promptPath)) {
           return { valid: false, reason: "missing or empty PROMPT.md" };
         }
         try {
-          const content = await readFile34(promptPath, "utf-8");
+          const content = await readFile35(promptPath, "utf-8");
           if (!content || content.trim().length === 0) {
             return { valid: false, reason: "missing or empty PROMPT.md" };
           }
@@ -186963,7 +187101,7 @@ var init_scheduler = __esm({
           todo = (await Promise.all(
             todo.map(async (t) => {
               try {
-                const content = await readFile34(getPromptPath(this.store.getTasksDir(), t.id), "utf-8");
+                const content = await readFile35(getPromptPath(this.store.getTasksDir(), t.id), "utf-8");
                 if (isUnplannedSeedPrompt(content, t.id, t.title, t.description)) return null;
               } catch {
               }
@@ -190530,10 +190668,10 @@ var init_verification_utils = __esm({
 import { exec as exec23 } from "node:child_process";
 import { createHash as createHash18 } from "node:crypto";
 import { existsSync as existsSync55, readFileSync as readFileSync18, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 import { promisify as promisify32 } from "node:util";
 function hasInstallState(rootDir) {
-  return existsSync55(join68(rootDir, "node_modules")) || existsSync55(join68(rootDir, ".pnp.cjs"));
+  return existsSync55(join69(rootDir, "node_modules")) || existsSync55(join69(rootDir, ".pnp.cjs"));
 }
 function getConfiguredWorktreeInitCommand(settings) {
   const trimmed = settings?.worktreeInitCommand?.trim();
@@ -190542,17 +190680,17 @@ function getConfiguredWorktreeInitCommand(settings) {
 function getDependencySyncCommand(rootDir, settings) {
   const configuredCommand = getConfiguredWorktreeInitCommand(settings);
   if (configuredCommand) return configuredCommand;
-  if (existsSync55(join68(rootDir, "pnpm-lock.yaml"))) return "pnpm install --frozen-lockfile";
-  if (existsSync55(join68(rootDir, "package-lock.json"))) return "npm install";
-  if (existsSync55(join68(rootDir, "yarn.lock"))) return "yarn install --frozen-lockfile";
-  if (existsSync55(join68(rootDir, "bun.lock")) || existsSync55(join68(rootDir, "bun.lockb"))) {
+  if (existsSync55(join69(rootDir, "pnpm-lock.yaml"))) return "pnpm install --frozen-lockfile";
+  if (existsSync55(join69(rootDir, "package-lock.json"))) return "npm install";
+  if (existsSync55(join69(rootDir, "yarn.lock"))) return "yarn install --frozen-lockfile";
+  if (existsSync55(join69(rootDir, "bun.lock")) || existsSync55(join69(rootDir, "bun.lockb"))) {
     return "bun install --frozen-lockfile";
   }
   return null;
 }
 function computeLockfileHash(rootDir) {
   for (const name2 of LOCKFILE_CANDIDATES) {
-    const p2 = join68(rootDir, name2);
+    const p2 = join69(rootDir, name2);
     if (existsSync55(p2)) {
       try {
         return createHash18("sha256").update(readFileSync18(p2)).digest("hex");
@@ -190565,7 +190703,7 @@ function computeLockfileHash(rootDir) {
 }
 function readInstallMarker(rootDir) {
   try {
-    const value = readFileSync18(join68(rootDir, INSTALL_MARKER_RELPATH), "utf-8").trim();
+    const value = readFileSync18(join69(rootDir, INSTALL_MARKER_RELPATH), "utf-8").trim();
     return value || null;
   } catch {
     return null;
@@ -190573,7 +190711,7 @@ function readInstallMarker(rootDir) {
 }
 function writeInstallMarker(rootDir, hash) {
   try {
-    writeFileSync7(join68(rootDir, INSTALL_MARKER_RELPATH), hash);
+    writeFileSync7(join69(rootDir, INSTALL_MARKER_RELPATH), hash);
   } catch {
   }
 }
@@ -190664,7 +190802,7 @@ var init_merge_dependency_sync = __esm({
   "../engine/src/merge-dependency-sync.ts"() {
     "use strict";
     execAsync21 = promisify32(exec23);
-    INSTALL_MARKER_RELPATH = join68("node_modules", ".fusion-install-marker");
+    INSTALL_MARKER_RELPATH = join69("node_modules", ".fusion-install-marker");
     LOCKFILE_CANDIDATES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb", "bun.lock"];
     INSTALL_TIMEOUT_MS = 3e5;
   }
@@ -191041,7 +191179,7 @@ var init_merger_glob = __esm({
 
 // ../engine/src/merger-workspace-test-commands.ts
 import { existsSync as existsSync56, readdirSync as readdirSync9, readFileSync as readFileSync19 } from "node:fs";
-import { basename as basename18, dirname as dirname31, join as join69 } from "node:path";
+import { basename as basename18, dirname as dirname31, join as join70 } from "node:path";
 import { execSync as execSync4 } from "node:child_process";
 function quoteArg2(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
@@ -191072,14 +191210,14 @@ function resolveWorkspacePackageRoots(rootDir, globs) {
   for (const glob of globs) {
     const starIdx = glob.indexOf("*");
     if (starIdx === -1) {
-      const candidate = join69(rootDir, glob);
-      if (existsSync56(join69(candidate, "package.json"))) {
+      const candidate = join70(rootDir, glob);
+      if (existsSync56(join70(candidate, "package.json"))) {
         roots.push(glob);
       }
       continue;
     }
     const prefix = glob.slice(0, starIdx);
-    const parentDir = join69(rootDir, prefix.replace(/\/$/, ""));
+    const parentDir = join70(rootDir, prefix.replace(/\/$/, ""));
     let entries;
     try {
       entries = readdirSync9(parentDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -191088,8 +191226,8 @@ function resolveWorkspacePackageRoots(rootDir, globs) {
     }
     for (const entry of entries) {
       const relPath = `${prefix.replace(/\/$/, "")}/${entry}`;
-      const absPath = join69(rootDir, relPath);
-      if (existsSync56(join69(absPath, "package.json"))) {
+      const absPath = join70(rootDir, relPath);
+      if (existsSync56(join70(absPath, "package.json"))) {
         roots.push(relPath);
       }
     }
@@ -191112,7 +191250,7 @@ function mapChangedFilesToPackageNames(changedFiles, packageRoots, rootDir) {
     }
     if (bestRoot !== null) {
       try {
-        const pkgJsonPath = join69(rootDir, bestRoot, "package.json");
+        const pkgJsonPath = join70(rootDir, bestRoot, "package.json");
         const raw = readFileSync19(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed.name) {
@@ -191129,7 +191267,7 @@ function packageNamesForFiles(rootDir, files) {
   if (files.length === 0) return [];
   let workspaceContent;
   try {
-    workspaceContent = readFileSync19(join69(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    workspaceContent = readFileSync19(join70(rootDir, "pnpm-workspace.yaml"), "utf-8");
   } catch {
     return [];
   }
@@ -191140,7 +191278,7 @@ function packageNamesForFiles(rootDir, files) {
   return mapChangedFilesToPackageNames(files, packageRoots, rootDir);
 }
 function deriveScopedPnpmTestCommand(rootDir, baseBranch, branch) {
-  const workspacePath = join69(rootDir, "pnpm-workspace.yaml");
+  const workspacePath = join70(rootDir, "pnpm-workspace.yaml");
   let workspaceContent;
   try {
     workspaceContent = readFileSync19(workspacePath, "utf-8");
@@ -191178,7 +191316,7 @@ function deriveScopedPnpmTestCommand(rootDir, baseBranch, branch) {
 function deriveFileScopedPnpmTestCommand(rootDir, baseBranch, branch) {
   let workspaceContent;
   try {
-    workspaceContent = readFileSync19(join69(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    workspaceContent = readFileSync19(join70(rootDir, "pnpm-workspace.yaml"), "utf-8");
   } catch {
     return null;
   }
@@ -191220,7 +191358,7 @@ function deriveFileScopedPnpmTestCommand(rootDir, baseBranch, branch) {
     ];
     for (const candidate of candidates) {
       const normalized = candidate.startsWith("./") ? candidate.slice(2) : candidate;
-      if (existsSync56(join69(rootDir, normalized))) {
+      if (existsSync56(join70(rootDir, normalized))) {
         resolvedTests.add(normalized);
       }
     }
@@ -191248,7 +191386,7 @@ function deriveFileScopedPnpmTestCommand(rootDir, baseBranch, branch) {
       let name2 = bestRoot;
       try {
         const parsed = JSON.parse(
-          readFileSync19(join69(rootDir, bestRoot, "package.json"), "utf-8")
+          readFileSync19(join70(rootDir, bestRoot, "package.json"), "utf-8")
         );
         if (parsed.name) name2 = parsed.name;
       } catch {
@@ -191292,8 +191430,8 @@ function inferDefaultTestCommand(rootDir, explicitTestCommand, explicitBuildComm
     };
   }
   const buildSource = explicitBuildCommand?.trim() ? "explicit" : void 0;
-  if (existsSync56(join69(rootDir, "pnpm-lock.yaml"))) {
-    if (existsSync56(join69(rootDir, "pnpm-workspace.yaml"))) {
+  if (existsSync56(join70(rootDir, "pnpm-lock.yaml"))) {
+    if (existsSync56(join70(rootDir, "pnpm-workspace.yaml"))) {
       if (baseBranch?.trim() && branch?.trim()) {
         try {
           const scoped = deriveScopedPnpmTestCommand(rootDir, baseBranch.trim(), branch.trim());
@@ -191312,13 +191450,13 @@ function inferDefaultTestCommand(rootDir, explicitTestCommand, explicitBuildComm
     }
     return { command: "pnpm test", testSource: "inferred", buildSource };
   }
-  if (existsSync56(join69(rootDir, "yarn.lock"))) {
+  if (existsSync56(join70(rootDir, "yarn.lock"))) {
     return { command: "yarn test", testSource: "inferred", buildSource };
   }
-  if (existsSync56(join69(rootDir, "bun.lock")) || existsSync56(join69(rootDir, "bun.lockb"))) {
+  if (existsSync56(join70(rootDir, "bun.lock")) || existsSync56(join70(rootDir, "bun.lockb"))) {
     return { command: "bun test", testSource: "inferred", buildSource };
   }
-  if (existsSync56(join69(rootDir, "package-lock.json"))) {
+  if (existsSync56(join70(rootDir, "package-lock.json"))) {
     return { command: "npm test", testSource: "inferred", buildSource };
   }
   return null;
@@ -193595,7 +193733,7 @@ var init_merger_integration_worktree = __esm({
 import { execFile as execFile23, spawn as spawn7 } from "node:child_process";
 import { promisify as promisify43 } from "node:util";
 import { copyFileSync, existsSync as existsSync57, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync2, readFileSync as readFileSync20, rmSync as rmSync7, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname32, join as join70 } from "node:path";
+import { dirname as dirname32, join as join71 } from "node:path";
 import { tmpdir as tmpdir6 } from "node:os";
 async function runGit4(args, cwd, timeoutMs) {
   const result2 = await execFileAsync16("git", ["-c", "core.quotePath=false", ...args], {
@@ -193681,9 +193819,9 @@ async function syncWorktreeToHead(input) {
   if (mode === "ff-only") {
     return { kind: "skipped-dirty", fromSha: previousSha, reason: "ff-only-mode-requires-clean-tree", dirtyFiles, untrackedFiles };
   }
-  const stageDir = mkdtempSync2(join70(tmpdir6(), "fusion-worktree-sync-"));
-  const patchPath = join70(stageDir, "edits.patch");
-  const untrackedDir = join70(stageDir, "untracked");
+  const stageDir = mkdtempSync2(join71(tmpdir6(), "fusion-worktree-sync-"));
+  const patchPath = join71(stageDir, "edits.patch");
+  const untrackedDir = join71(stageDir, "untracked");
   let preserveStageDir = false;
   try {
     mkdirSync9(untrackedDir, { recursive: true });
@@ -193703,8 +193841,8 @@ async function syncWorktreeToHead(input) {
       }
     }
     for (const rel of untrackedFiles) {
-      const src = join70(worktreePath, rel);
-      const dst = join70(untrackedDir, rel);
+      const src = join71(worktreePath, rel);
+      const dst = join71(untrackedDir, rel);
       try {
         mkdirSync9(dirname32(dst), { recursive: true });
         copyFileSync(src, dst);
@@ -193767,13 +193905,13 @@ async function syncWorktreeToHead(input) {
     const restored = [];
     const untrackedSkippedAsTracked = [];
     for (const rel of untrackedFiles) {
-      const src = join70(untrackedDir, rel);
+      const src = join71(untrackedDir, rel);
       if (!existsSync57(src)) continue;
       if (trackedAtHead.has(rel)) {
         untrackedSkippedAsTracked.push(rel);
         continue;
       }
-      const dst = join70(worktreePath, rel);
+      const dst = join71(worktreePath, rel);
       try {
         mkdirSync9(dirname32(dst), { recursive: true });
         const data = readFileSync20(src);
@@ -193842,8 +193980,8 @@ var init_worktree_ref_sync = __esm({
 
 // ../engine/src/merger-scope-auto-widen.ts
 import { exec as exec30 } from "node:child_process";
-import { readFile as readFile35, writeFile as writeFile27 } from "node:fs/promises";
-import { join as join71 } from "node:path";
+import { readFile as readFile36, writeFile as writeFile27 } from "node:fs/promises";
+import { join as join72 } from "node:path";
 import { promisify as promisify44 } from "node:util";
 function quoteArg4(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -193982,8 +194120,8 @@ function parseScopeEntries(section) {
 async function appendAutoWidenedScopeToPrompt(params) {
   const { store, taskId, files } = params;
   if (files.length === 0) return [];
-  const promptPath = join71(store.getTaskDir(taskId), "PROMPT.md");
-  const prompt = await readFile35(promptPath, "utf-8");
+  const promptPath = join72(store.getTaskDir(taskId), "PROMPT.md");
+  const prompt = await readFile36(promptPath, "utf-8");
   const { before, section, after } = splitPromptSections(prompt);
   const existing = parseScopeEntries(section);
   const toAdd = files.filter((file) => !existing.has(file));
@@ -194139,7 +194277,7 @@ import * as childProcess4 from "node:child_process";
 import { promisify as promisify45 } from "node:util";
 import { existsSync as existsSync58, readFileSync as readFileSync21, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
 import { createHash as createHash20 } from "node:crypto";
-import { join as join72, resolve as resolve36 } from "node:path";
+import { join as join73, resolve as resolve36 } from "node:path";
 import { hostname as hostname2 } from "node:os";
 import { Type as Type4 } from "typebox";
 function mergerCommitEnv() {
@@ -194452,7 +194590,7 @@ async function runDeterministicVerification(store, rootDir, taskId, testCommand,
   const deterministicVerificationMessage = "Running deterministic merge verification" + (hasTestCommand ? ` (test${testSourceDisplayLabel}: ${normalizedTestCommand})` : "") + (hasBuildCommand ? ` (build${buildSource === "inferred" ? " [inferred]" : ""}: ${normalizedBuildCommand})` : "");
   await store.logEntry(taskId, deterministicVerificationMessage);
   await store.appendAgentLog(taskId, deterministicVerificationMessage, "status", void 0, "merger");
-  const bootstrapScriptPath = join72(rootDir, "scripts/ensure-test-artifacts.mjs");
+  const bootstrapScriptPath = join73(rootDir, "scripts/ensure-test-artifacts.mjs");
   if (hasTestCommand || hasBuildCommand) {
     if (!existsSync58(bootstrapScriptPath)) {
       const bootstrapMissingMessage = `${taskId}: [verification:bootstrap] script missing at scripts/ensure-test-artifacts.mjs \u2014 skipping preamble`;
@@ -194951,7 +195089,7 @@ async function stashTreesEqual(rootDir, aSha, bSha) {
 }
 function writeActiveMergerStatus(rootDir, taskId) {
   try {
-    const statusPath = join72(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
+    const statusPath = join73(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
     const payload = {
       taskId,
       pid: process.pid,
@@ -194980,7 +195118,7 @@ function clearActiveMergerStatus(statusPath, taskId) {
 }
 function readActiveMergerStatus(rootDir) {
   try {
-    const statusPath = join72(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
+    const statusPath = join73(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
     if (!existsSync58(statusPath)) return null;
     const raw = readFileSync21(statusPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -195553,7 +195691,7 @@ async function findFilesWithConflictMarkers(rootDir, files) {
   const stillConflicted = [];
   for (const file of files) {
     try {
-      const fullPath = join72(rootDir, file);
+      const fullPath = join73(rootDir, file);
       if (!existsSync58(fullPath)) continue;
       const { stdout } = await execAsync29(
         `git grep -l -e "^<<<<<<< " -e "^=======$" -e "^>>>>>>> " --no-index -- ${quoteArg3(fullPath)}`,
@@ -195580,7 +195718,7 @@ async function tryRecoverHardFailApply(params) {
     if (!patchText.trim()) {
       mergerLog.warn(`${taskId}: autostash ${sha.slice(0, 7)} produced empty patch; cannot 3-way recover`);
     } else {
-      const patchPath = join72(rootDir, ".git", `fusion-autostash-${sha.slice(0, 7)}.patch`);
+      const patchPath = join73(rootDir, ".git", `fusion-autostash-${sha.slice(0, 7)}.patch`);
       writeFileSync9(patchPath, patchText, "utf-8");
       try {
         await execAsync29(`git apply --3way --whitespace=nowarn ${quoteArg3(patchPath)}`, { cwd: rootDir });
@@ -197068,13 +197206,13 @@ async function isCherryPickInProgress(rootDir) {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const cherryPickHeadPath = join72(rootDir, cherryPickHeadPathOut.trim());
+    const cherryPickHeadPath = join73(rootDir, cherryPickHeadPathOut.trim());
     if (existsSync58(cherryPickHeadPath)) return true;
     const { stdout: sequencerPathOut } = await execAsync29("git rev-parse --git-path sequencer", {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const sequencerPath = join72(rootDir, sequencerPathOut.trim());
+    const sequencerPath = join73(rootDir, sequencerPathOut.trim());
     return existsSync58(sequencerPath);
   } catch {
     return false;
@@ -202117,7 +202255,7 @@ import { promisify as promisify46 } from "node:util";
 import { setImmediate as setImmediateCb2 } from "node:timers";
 import { existsSync as existsSync59, mkdirSync as mkdirSync10, readdirSync as readdirSync10, readFileSync as readFileSync22, realpathSync as realpathSync7, rmSync as rmSync8, statSync as statSync10, writeFileSync as writeFileSync10 } from "node:fs";
 import { tmpdir as tmpdir7 } from "node:os";
-import { isAbsolute as isAbsolute14, join as join73, relative as relative13, resolve as resolve37 } from "node:path";
+import { isAbsolute as isAbsolute14, join as join74, relative as relative13, resolve as resolve37 } from "node:path";
 function resolveRepoLocalAiMergeRoot(rootDir, settings) {
   return resolveAiMergeRootPath(rootDir, settings);
 }
@@ -202150,9 +202288,9 @@ async function preserveWorktreeChanges(repoDir, worktreePath, taskId) {
       return null;
     }
     const diff = (await execAsync30("git diff HEAD --binary", { cwd: worktreePath, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 })).stdout;
-    const recoveryDir = join73(repoDir, ".fusion", "recovery");
+    const recoveryDir = join74(repoDir, ".fusion", "recovery");
     mkdirSync10(recoveryDir, { recursive: true });
-    const patchPath = join73(recoveryDir, `${taskId.toLowerCase()}-${formatRecoveryTimestamp()}.patch`);
+    const patchPath = join74(recoveryDir, `${taskId.toLowerCase()}-${formatRecoveryTimestamp()}.patch`);
     writeFileSync10(patchPath, diff, "utf-8");
     return patchPath;
   } catch (error3) {
@@ -203585,6 +203723,35 @@ var init_self_healing = __esm({
         }
         return false;
       }
+      /**
+       * FNXC:WorkflowRecovery 2026-07-25-09:40:
+       * Single shared decision for "is this branch tip's foreign `Fusion-Task-Id`/`Fusion-Task-Lineage` trailer real
+       * evidence of cross-task contamination, or just an inherited start point?"
+       *
+       * A task branch cut from the integration branch points at whatever landed last. When the task has not committed
+       * anything of its own (planning aborted, spec revise, operator move back to `todo`), the branch tip IS that
+       * previous task's commit — a foreign trailer with zero foreign intent. FN-1406 hit exactly this: `fusion/fn-1406`
+       * was cut from `main` at FN-1401's landed commit, planning ended without a commit, and the reclaim sweep logged
+       * `already-merged rejected ... owner=FN-1401 reason=foreign-task-tip` every pass instead of clearing the stale
+       * worktree/branch metadata.
+       *
+       * Merge-base-to-tip diff proof separates the two: no unique diff means the branch carries no task content, so the
+       * foreign trailer is inherited and the caller may treat the row as stale metadata. The one exception is when the
+       * base ALREADY has an explicit commit for this task — then the branch should have been sitting on the task's own
+       * landed commit, and a foreign tip is genuine misbinding worth rejecting.
+       *
+       * Callers: already-merged recovery (`branchTipForeignOwnership`), branch-misbound recovery
+       * (`isBranchTipMisboundToTask`), and the self-owned-branch reclaim sweep's `tip-already-merged` arm. Keeping the
+       * three on one helper is the point — the reclaim arm drifted without the diff proof and that was the bug.
+       */
+      async foreignTipRejection(input) {
+        const { taskId, lineageId, branchTip, baseBranch, ownership } = input;
+        if (ownership.rejectionReason !== "foreign-task" && ownership.rejectionReason !== "foreign-lineage") return null;
+        const hasNoUniqueDiff = await this.branchHasNoUniqueDiff(branchTip, baseBranch).catch(() => false);
+        const baseAlreadyHasCurrentTask = hasNoUniqueDiff ? await this.baseHasExplicitTaskOwnership(taskId, lineageId, baseBranch).catch(() => false) : false;
+        if (hasNoUniqueDiff && !baseAlreadyHasCurrentTask) return null;
+        return ownership.rejectionReason === "foreign-task" ? { reason: "foreign-task-tip", owner: ownership.ownerTaskId } : { reason: "foreign-lineage-tip", owner: ownership.ownerLineageId };
+      }
       async rejectForeignAlreadyMergedCandidate(input) {
         const { task, candidateSha, candidateOwner, taskBranch, baseBranch, reason, phase } = input;
         await this.store.logEntry(
@@ -203626,20 +203793,14 @@ var init_self_healing = __esm({
         }
         const sha = stdout.trim();
         if (!sha) return null;
-        const hasNoUniqueDiff = await this.branchHasNoUniqueDiff(sha, baseBranch).catch(() => false);
         let ownership;
         try {
           ownership = await this.readCommitTaskOwnership(sha, taskId, lineageId);
         } catch {
           return { sha, reason: "ownership-unverifiable" };
         }
-        const baseAlreadyHasCurrentTask = hasNoUniqueDiff ? await this.baseHasExplicitTaskOwnership(taskId, lineageId, baseBranch).catch(() => false) : false;
-        if ((!hasNoUniqueDiff || baseAlreadyHasCurrentTask) && ownership.rejectionReason === "foreign-task") {
-          return { sha, owner: ownership.ownerTaskId, reason: "foreign-task-tip" };
-        }
-        if ((!hasNoUniqueDiff || baseAlreadyHasCurrentTask) && ownership.rejectionReason === "foreign-lineage") {
-          return { sha, owner: ownership.ownerLineageId, reason: "foreign-lineage-tip" };
-        }
+        const rejection = await this.foreignTipRejection({ taskId, lineageId, branchTip: sha, baseBranch, ownership });
+        if (rejection) return { sha, owner: rejection.owner, reason: rejection.reason };
         return null;
       }
       async resolveSelfHealingMergeTarget(task, settings, phase) {
@@ -204855,14 +205016,21 @@ var init_self_healing = __esm({
                 if (!ownership) {
                   continue;
                 }
-                if (ownership?.rejectionReason === "foreign-task" || ownership?.rejectionReason === "foreign-lineage") {
+                const foreignRejection = await this.foreignTipRejection({
+                  taskId: task.id,
+                  lineageId: task.lineageId,
+                  branchTip: inspection.tipSha,
+                  baseBranch: inspection.integrationRef,
+                  ownership
+                });
+                if (foreignRejection) {
                   await this.rejectForeignAlreadyMergedCandidate({
                     task,
                     candidateSha: inspection.tipSha,
-                    candidateOwner: ownership.rejectionReason === "foreign-task" ? ownership.ownerTaskId : ownership.ownerLineageId,
+                    candidateOwner: foreignRejection.owner,
                     taskBranch: branchName,
                     baseBranch: inspection.integrationRef,
-                    reason: ownership.rejectionReason === "foreign-task" ? "foreign-task-tip" : "foreign-lineage-tip",
+                    reason: foreignRejection.reason,
                     phase: "tip-already-merged"
                   });
                   continue;
@@ -208802,7 +208970,7 @@ var init_self_healing = __esm({
               const unrecoverableRepos = [];
               for (const repoRel of repoKeys) {
                 const entry = workspaceWorktrees[repoRel];
-                const repoRootDir = join73(this.options.rootDir, repoRel);
+                const repoRootDir = join74(this.options.rootDir, repoRel);
                 let integrationBranch;
                 try {
                   integrationBranch = await resolveIntegrationBranch(
@@ -209096,7 +209264,7 @@ var init_self_healing = __esm({
               if ((this.orphanWorktreeRemovalFailures.get(worktreePath) ?? 0) >= MAX_STARVATION_DROPS) {
                 continue;
               }
-              const repoRootDir = join73(this.options.rootDir, repoRel);
+              const repoRootDir = join74(this.options.rootDir, repoRel);
               let success = false;
               let reason = "removed";
               try {
@@ -210017,7 +210185,7 @@ var init_self_healing = __esm({
         if (testWorkerRoot) {
           try {
             for (const entry of readdirSync10(testWorkerRoot)) {
-              if (entry.startsWith("redir-")) roots.push(join73(testWorkerRoot, entry));
+              if (entry.startsWith("redir-")) roots.push(join74(testWorkerRoot, entry));
             }
           } catch {
           }
@@ -210031,7 +210199,7 @@ var init_self_healing = __esm({
           } catch {
             continue;
           }
-          for (const entry of entries) paths2.push(join73(root, entry));
+          for (const entry of entries) paths2.push(join74(root, entry));
         }
         return paths2;
       }
@@ -210267,14 +210435,10 @@ var init_self_healing = __esm({
           maxBuffer: 1024 * 1024
         });
         const branchTip = tipOut.trim();
-        const hasNoUniqueDiff = await this.branchHasNoUniqueDiff(branchTip, baseBranch).catch(() => false);
         const ownership = await this.readCommitTaskOwnership(branchTip, taskId, lineageId);
-        const baseAlreadyHasCurrentTask = hasNoUniqueDiff ? await this.baseHasExplicitTaskOwnership(taskId, lineageId, baseBranch).catch(() => false) : false;
-        if ((!hasNoUniqueDiff || baseAlreadyHasCurrentTask) && ownership.rejectionReason === "foreign-task") {
-          return { misbound: false, branchTip, landed: null, rejection: { reason: "foreign-task-tip", owner: ownership.ownerTaskId } };
-        }
-        if ((!hasNoUniqueDiff || baseAlreadyHasCurrentTask) && ownership.rejectionReason === "foreign-lineage") {
-          return { misbound: false, branchTip, landed: null, rejection: { reason: "foreign-lineage-tip", owner: ownership.ownerLineageId } };
+        const rejection = await this.foreignTipRejection({ taskId, lineageId, branchTip, baseBranch, ownership });
+        if (rejection) {
+          return { misbound: false, branchTip, landed: null, rejection };
         }
         const hasTaskId = ownership.ownerTaskId === taskId;
         const hasLineage = lineageId ? ownership.ownerLineageId === lineageId : false;
@@ -211936,7 +212100,7 @@ var init_self_healing = __esm({
           let processedMarkers = 0;
           for (const task of candidates) {
             try {
-              const promptPath = join73(this.options.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+              const promptPath = join74(this.options.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
               if (!existsSync59(promptPath)) {
                 continue;
               }
@@ -212323,7 +212487,7 @@ var init_self_healing = __esm({
         if (!existsSync59(worktreesDir)) return 0;
         let dirs;
         try {
-          dirs = readdirSync10(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join73(worktreesDir, e.name));
+          dirs = readdirSync10(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join74(worktreesDir, e.name));
         } catch (err) {
           log28.warn(`Failed to read .worktrees/ for unregistered orphan reap: ${err instanceof Error ? err.message : String(err)}`);
           return 0;
@@ -212393,7 +212557,7 @@ var init_self_healing = __esm({
             }
             if (entries.length === 0) continue;
             for (const entry of entries) {
-              const path10 = join73(tempRoot, entry);
+              const path10 = join74(tempRoot, entry);
               let canonicalPath = path10;
               let cleanupReason = "stale";
               try {
@@ -212631,8 +212795,8 @@ var init_self_healing = __esm({
 // ../engine/src/triage.ts
 import { Type as Type5 } from "@earendil-works/pi-ai";
 import { exec as exec33 } from "node:child_process";
-import { readFile as readFile36, writeFile as writeFile28, rm as rm9 } from "node:fs/promises";
-import { join as join74 } from "node:path";
+import { readFile as readFile37, writeFile as writeFile28, rm as rm9 } from "node:fs/promises";
+import { join as join75 } from "node:path";
 import { promisify as promisify47 } from "node:util";
 function inlineTaskListFallback(lines, opts = {}) {
   const maxChars = Math.max(1, Math.floor(opts.maxChars ?? MAX_TASK_LIST_TEXT_CHARS));
@@ -212683,10 +212847,10 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
   if (!attachments || attachments.length === 0) {
     return { attachmentContents, imageContents };
   }
-  const { readFile: readFile46 } = await import("node:fs/promises");
-  const { join: join108 } = await import("node:path");
+  const { readFile: readFile47 } = await import("node:fs/promises");
+  const { join: join109 } = await import("node:path");
   for (const att of attachments) {
-    const filePath = join108(
+    const filePath = join109(
       rootDir,
       ".fusion",
       "tasks",
@@ -212696,7 +212860,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
     );
     try {
       if (IMAGE_MIME_TYPES.has(att.mimeType)) {
-        const data = await readFile46(filePath);
+        const data = await readFile47(filePath);
         const detectedMimeType = detectImageMimeFromBytes(data);
         const imageMimeType = detectedMimeType ?? att.mimeType;
         if (detectedMimeType && detectedMimeType !== att.mimeType) {
@@ -212713,7 +212877,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
           text: null
         });
       } else {
-        const data = await readFile46(filePath, "utf-8");
+        const data = await readFile47(filePath, "utf-8");
         const text2 = data.length > TEXT_INLINE_LIMIT ? data.slice(0, TEXT_INLINE_LIMIT) + "\n... (truncated at 50KB)" : data;
         attachmentContents.push({
           originalName: att.originalName,
@@ -212954,6 +213118,7 @@ var init_triage = __esm({
     init_prompt_layers();
     init_fallback_model_observer();
     init_logger3();
+    init_plan_artifact_writeback();
     init_mcp_resolution();
     init_usage_limit_detector();
     init_transient_error_detector();
@@ -213510,8 +213675,8 @@ var init_triage = __esm({
         }
         const settings = await mergeEffectiveSettings(this.store, task, await this.store.getSettings());
         const approvalRequired = resolvePlanApprovalRequired(settings);
-        const promptPath = join74(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
-        const written = await readFile36(promptPath, "utf-8").catch((err) => {
+        const promptPath = join75(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+        const written = await readFile37(promptPath, "utf-8").catch((err) => {
           const msg = err instanceof Error ? err.message : String(err);
           planLog.warn(`${task.id}: failed to read PROMPT.md during planning recovery (${promptPath}): ${msg}`);
           return "";
@@ -213549,8 +213714,8 @@ var init_triage = __esm({
         return true;
       }
       async readNonEmptyPromptDraft(taskId, context) {
-        const promptPath = join74(this.rootDir, ".fusion", "tasks", taskId, "PROMPT.md");
-        const written = await readFile36(promptPath, "utf-8").catch((err) => {
+        const promptPath = join75(this.rootDir, ".fusion", "tasks", taskId, "PROMPT.md");
+        const written = await readFile37(promptPath, "utf-8").catch((err) => {
           const msg = err instanceof Error ? err.message : String(err);
           planLog.warn(`${taskId}: failed to read PROMPT.md during ${context} (${promptPath}): ${msg}`);
           return "";
@@ -213714,8 +213879,8 @@ var init_triage = __esm({
             continue;
           }
           try {
-            const promptPath = join74(this.rootDir, ".fusion", "tasks", todoTask.id, "PROMPT.md");
-            const content = await readFile36(promptPath, "utf-8");
+            const promptPath = join75(this.rootDir, ".fusion", "tasks", todoTask.id, "PROMPT.md");
+            const content = await readFile37(promptPath, "utf-8");
             if (isUnplannedSeedPrompt(content, todoTask.id, todoTask.title, todoTask.description)) {
               eligibleTodoTasks.push(todoTask);
             }
@@ -213926,7 +214091,7 @@ var init_triage = __esm({
           const detail = await this.store.getTask(task.id);
           const currentTask = detail ?? task;
           const settings = await mergeEffectiveSettings(this.store, currentTask, await this.store.getSettings());
-          const promptPath = `.fusion/tasks/${task.id}/PROMPT.md`;
+          const promptPath = relativePromptPath(task.id);
           const isFast = task.executionMode === "fast";
           const leanPlanning = settings.leanPlanning === true || isFast;
           const agentWork = async () => {
@@ -214262,8 +214427,22 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
                 }
                 return;
               }
-              const written = await readFile36(
-                join74(this.rootDir, promptPath),
+              const planPersistence = await persistPlanArtifact({
+                store: this.store,
+                taskId: task.id,
+                rootDir: this.rootDir,
+                planningCwd,
+                author: "triage",
+                logger: { log: (m2) => planLog.log(m2), warn: (m2) => planLog.warn(m2) }
+              });
+              if (planPersistence.outcome === "recovered") {
+                await this.store.logEntry(
+                  task.id,
+                  "Recovered the plan written inside the task worktree into the project .fusion folder"
+                ).catch(() => void 0);
+              }
+              const written = await readFile37(
+                join75(this.rootDir, promptPath),
                 "utf-8"
               ).catch((err) => {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -214880,7 +215059,7 @@ Remove or replace these ids and call fn_task_create again.`
           if (isNearDuplicateCanonicalInactive(canonicalTask ?? void 0)) {
             if (canClearInactiveMarker) {
               if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
-                await rm9(join74(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+                await rm9(join75(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
               })) return;
               await this.updatePlanningStateIfStillCurrent(task, { paused: false, pausedReason: null, status: null });
             }
@@ -214891,7 +215070,7 @@ Remove or replace these ids and call fn_task_create again.`
           if (resolution === "prompt" && keepAcknowledged) {
             if (canClearInactiveMarker) {
               if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
-                await rm9(join74(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+                await rm9(join75(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
               })) return;
               await this.updatePlanningStateIfStillCurrent(task, {
                 paused: false,
@@ -214932,7 +215111,7 @@ Remove or replace these ids and call fn_task_create again.`
             return;
           }
           if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
-            await rm9(join74(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+            await rm9(join75(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
           })) return;
           if (!await this.updatePlanningStateIfStillCurrent(task, {
             paused: false,
@@ -214997,7 +215176,7 @@ Remove or replace these ids and call fn_task_create again.`
           let nextPrompt = applyOriginalDescription(written, originalDescription);
           nextPrompt = applyFrontendUxCriteria(nextPrompt, parsedFileScope);
           if (nextPrompt !== written) {
-            const promptPath = join74(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+            const promptPath = join75(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
             try {
               if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
                 await writeFile28(promptPath, nextPrompt, "utf-8");
@@ -215009,6 +215188,10 @@ Remove or replace these ids and call fn_task_create again.`
             }
           }
         }
+        await mirrorPlanToProjectDb(this.store, task.id, written, {
+          author: "triage",
+          logger: { warn: (m2) => planLog.warn(m2) }
+        });
         let taskIntentSignature = {
           routePaths: [],
           filePaths: [],
@@ -215255,10 +215438,10 @@ Remove or replace these ids and call fn_task_create again.`
 });
 
 // ../engine/src/review-artifacts/feature-video.ts
-import { access as access9, mkdtemp as mkdtemp2, readFile as readFile37, rm as rm10 } from "node:fs/promises";
+import { access as access9, mkdtemp as mkdtemp2, readFile as readFile38, rm as rm10 } from "node:fs/promises";
 import { constants as constants2 } from "node:fs";
 import { tmpdir as tmpdir8 } from "node:os";
-import { join as join75 } from "node:path";
+import { join as join76 } from "node:path";
 function shouldGenerateReviewArtifacts(task, settings) {
   return isReviewArtifactGenerationEligible(settings, task.prompt);
 }
@@ -215284,7 +215467,7 @@ async function generateFeatureVideo(options) {
   let browser;
   let context;
   try {
-    recordingDir = await mkdtemp2(join75(tmpdir8(), "fusion-feature-video-"));
+    recordingDir = await mkdtemp2(join76(tmpdir8(), "fusion-feature-video-"));
     try {
       browser = await client.launch({ executablePath, headless: true });
     } catch {
@@ -215302,7 +215485,7 @@ async function generateFeatureVideo(options) {
     await (options.sleep ?? defaultSleep)(Math.min(Math.max(options.durationMs ?? DEFAULT_DURATION_MS, 0), MAX_DURATION_MS));
     await context.close();
     context = void 0;
-    const data = await readFile37(await video.path());
+    const data = await readFile38(await video.path());
     if (data.byteLength > (options.maxBytes ?? DEFAULT_MAX_BYTES2)) {
       return { status: "failed", reason: "size-cap-exceeded" };
     }
@@ -215451,16 +215634,16 @@ async function persistBranchState(persistence, state) {
     );
   }
 }
-function resolveJoinConfig(join108) {
-  const rawMode = join108.config?.mode;
+function resolveJoinConfig(join109) {
+  const rawMode = join109.config?.mode;
   let mode = "all";
   if (rawMode === "all" || rawMode === "any") mode = rawMode;
   else if (rawMode && typeof rawMode === "object" && "quorum" in rawMode) {
     const n = rawMode.quorum;
     if (typeof n === "number" && Number.isInteger(n) && n > 0) mode = { quorum: n };
-    else throw new WorkflowIrError(`join '${join108.id}' quorum must be a positive integer`);
+    else throw new WorkflowIrError(`join '${join109.id}' quorum must be a positive integer`);
   }
-  const rawFail = join108.config?.onBranchFailure;
+  const rawFail = join109.config?.onBranchFailure;
   const onBranchFailure = rawFail === "collect" ? "collect" : "fail-fast";
   return { mode, onBranchFailure };
 }
@@ -215476,9 +215659,9 @@ async function runSplitJoin(split, env) {
   if (branchEdges.length === 0) {
     throw new WorkflowIrError(`split '${split.id}' has no traversable branches`);
   }
-  const join108 = findMatchingJoin(branchEdges[0].to, env);
-  if (!join108) throw new WorkflowIrError(`split '${split.id}' has no reachable matching join`);
-  const joinConfig = resolveJoinConfig(env.nodeMap.get(join108));
+  const join109 = findMatchingJoin(branchEdges[0].to, env);
+  if (!join109) throw new WorkflowIrError(`split '${split.id}' has no reachable matching join`);
+  const joinConfig = resolveJoinConfig(env.nodeMap.get(join109));
   const controller = new AbortController();
   const branchCount = branchEdges.length;
   const required2 = requiredCompletions(joinConfig.mode, branchCount);
@@ -215514,7 +215697,7 @@ async function runSplitJoin(split, env) {
   };
   const branchPromises = branchEdges.map((edge) => {
     const branchId = edge.to;
-    return walkBranch(branchId, join108, env, controller.signal, visitedNodeIds).then((result2) => {
+    return walkBranch(branchId, join109, env, controller.signal, visitedNodeIds).then((result2) => {
       branchOutcomes.push({ branchId, outcome: result2.outcome, nodeId: result2.lastNodeId });
       if (result2.outcome === "success") succeeded += 1;
       else failed += 1;
@@ -215532,7 +215715,7 @@ async function runSplitJoin(split, env) {
   });
   const outcome = await joinReached;
   await Promise.allSettled(branchPromises);
-  return { joinNodeId: join108, outcome, branchOutcomes, visitedNodeIds };
+  return { joinNodeId: join109, outcome, branchOutcomes, visitedNodeIds };
 }
 async function walkBranch(startNodeId, joinId, env, signal, visitedNodeIds) {
   let currentId = startNodeId;
@@ -218948,7 +219131,7 @@ var init_workspace_paths = __esm({
 
 // ../engine/src/cli-agent/hook-scripts.ts
 import { mkdir as mkdir28, rm as rm11, writeFile as writeFile29 } from "node:fs/promises";
-import { join as join76 } from "node:path";
+import { join as join77 } from "node:path";
 function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -219020,8 +219203,8 @@ exit 0
 async function writeSessionHookScripts(opts) {
   const { sessionId, token, endpointUrl, dir } = opts;
   await mkdir28(dir, { recursive: true, mode: 448 });
-  const hookScriptPath = join76(dir, HOOK_SCRIPT_NAMES.hook);
-  const notifyScriptPath = join76(dir, HOOK_SCRIPT_NAMES.notify);
+  const hookScriptPath = join77(dir, HOOK_SCRIPT_NAMES.hook);
+  const notifyScriptPath = join77(dir, HOOK_SCRIPT_NAMES.notify);
   await writeFile29(hookScriptPath, buildHookScriptContent({ sessionId, token, endpointUrl }), {
     mode: 448
   });
@@ -219180,7 +219363,7 @@ var init_autonomy = __esm({
 // ../engine/src/cli-agent/task-session.ts
 import { mkdtemp as mkdtemp3, rm as rm12 } from "node:fs/promises";
 import { tmpdir as tmpdir9 } from "node:os";
-import { join as join77 } from "node:path";
+import { join as join78 } from "node:path";
 function launchCliTaskSession(opts) {
   return CliTaskSession.launch(opts);
 }
@@ -219246,9 +219429,9 @@ var init_task_session = __esm({
           isApproved: opts.isAutonomyApproved ?? (() => false)
         });
         const root = opts.hookDirRoot ?? tmpdir9();
-        const hookDir = await mkdtemp3(join77(root, "fusion-cli-hooks-"));
-        const hookScriptPath = join77(hookDir, HOOK_SCRIPT_NAMES.hook);
-        const settingsPath = join77(hookDir, "settings.json");
+        const hookDir = await mkdtemp3(join78(root, "fusion-cli-hooks-"));
+        const hookScriptPath = join78(hookDir, HOOK_SCRIPT_NAMES.hook);
+        const settingsPath = join78(hookDir, "settings.json");
         const cliAgentSettings = opts.config.cliAgentSettings ?? null;
         const operatorEnvAdditions = (cliAgentSettings?.envAdditions ?? []).filter(
           (k2) => !/^FUSION_/i.test(k2)
@@ -219490,7 +219673,7 @@ var init_task_session = __esm({
 // ../engine/src/pty-native.ts
 import * as fs7 from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
-import { join as join78, dirname as dirname33 } from "node:path";
+import { join as join79, dirname as dirname33 } from "node:path";
 function getNativePrebuildName() {
   const platform4 = process.platform === "darwin" ? "darwin" : process.platform === "linux" ? "linux" : process.platform === "win32" ? "win32" : "unknown";
   const arch = process.arch === "arm64" ? "arm64" : process.arch === "x64" ? "x64" : "unknown";
@@ -219500,12 +219683,12 @@ function findInstalledNodePtyNativeDir() {
   try {
     const packageJsonPath = require4.resolve("node-pty/package.json");
     const pkgRoot = dirname33(packageJsonPath);
-    const releaseDir = join78(pkgRoot, "build", "Release");
-    if (fs7.existsSync(join78(releaseDir, "pty.node"))) {
+    const releaseDir = join79(pkgRoot, "build", "Release");
+    if (fs7.existsSync(join79(releaseDir, "pty.node"))) {
       return releaseDir;
     }
-    const prebuildDir = join78(pkgRoot, "prebuilds", getNativePrebuildName());
-    if (fs7.existsSync(join78(prebuildDir, "pty.node"))) {
+    const prebuildDir = join79(pkgRoot, "prebuilds", getNativePrebuildName());
+    if (fs7.existsSync(join79(prebuildDir, "pty.node"))) {
       return prebuildDir;
     }
     return null;
@@ -219516,14 +219699,14 @@ function findInstalledNodePtyNativeDir() {
 function findStagedNativeDir() {
   const prebuildName = getNativePrebuildName();
   if (process.env.FUSION_RUNTIME_DIR) {
-    const envPath = join78(process.env.FUSION_RUNTIME_DIR, prebuildName);
-    if (fs7.existsSync(join78(envPath, "pty.node"))) {
+    const envPath = join79(process.env.FUSION_RUNTIME_DIR, prebuildName);
+    if (fs7.existsSync(join79(envPath, "pty.node"))) {
       return envPath;
     }
   }
   const execDir = dirname33(process.execPath);
-  const nextToBinary = join78(execDir, "runtime", prebuildName);
-  if (fs7.existsSync(join78(nextToBinary, "pty.node"))) {
+  const nextToBinary = join79(execDir, "runtime", prebuildName);
+  if (fs7.existsSync(join79(nextToBinary, "pty.node"))) {
     return nextToBinary;
   }
   return null;
@@ -219546,8 +219729,8 @@ function ensureNodePtyNativePermissions() {
     candidateDirs.add(installedNativeDir);
   }
   for (const nativeDir of candidateDirs) {
-    const helperPath = join78(nativeDir, "spawn-helper");
-    const nativeModulePath = join78(nativeDir, "pty.node");
+    const helperPath = join79(nativeDir, "spawn-helper");
+    const nativeModulePath = join79(nativeDir, "pty.node");
     try {
       fs7.chmodSync(helperPath, 493);
     } catch {
@@ -219577,7 +219760,7 @@ async function loadPtyModule() {
         process.env.NODE_PTY_SPAWN_HELPER_DIR = nativeDir;
       }
       process.env.FUSION_NATIVE_ASSETS_PATH = nativeDir;
-      const nativePath = join78(nativeDir, "pty.node");
+      const nativePath = join79(nativeDir, "pty.node");
       if (fs7.existsSync(nativePath)) {
         try {
           const nativeModule = { exports: {} };
@@ -221116,7 +221299,7 @@ var init_file_scope2 = __esm({
 
 // ../engine/src/run-verification-tool.ts
 import { existsSync as existsSync64, readdirSync as readdirSync11, readFileSync as readFileSync23 } from "node:fs";
-import { isAbsolute as isAbsolute16, join as join79, relative as relative14 } from "node:path";
+import { isAbsolute as isAbsolute16, join as join80, relative as relative14 } from "node:path";
 import { Type as Type6 } from "@earendil-works/pi-ai";
 function shellSplit(input) {
   const tokens = [];
@@ -221231,7 +221414,7 @@ function findWorkspacePackageDir(rootDir, packageName) {
   for (const candidate of candidates) {
     if (!candidate) continue;
     try {
-      const pkg = JSON.parse(readFileSync23(join79(rootDir, candidate, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync23(join80(rootDir, candidate, "package.json"), "utf8"));
       if (pkg.name === packageName) {
         packageDirCache.set(cacheKey, candidate);
         return candidate;
@@ -221246,7 +221429,7 @@ function findWorkspacePackageDir(rootDir, packageName) {
   while (queue.length > 0) {
     const current = queue.shift();
     if (!current) break;
-    const abs = join79(rootDir, current.dir);
+    const abs = join80(rootDir, current.dir);
     let entries;
     try {
       entries = readdirSync11(abs, { withFileTypes: true });
@@ -221256,9 +221439,9 @@ function findWorkspacePackageDir(rootDir, packageName) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name === "node_modules" || entry.name === "dist") continue;
-      const child = join79(current.dir, entry.name);
+      const child = join80(current.dir, entry.name);
       try {
-        const pkg = JSON.parse(readFileSync23(join79(rootDir, child, "package.json"), "utf8"));
+        const pkg = JSON.parse(readFileSync23(join80(rootDir, child, "package.json"), "utf8"));
         if (pkg.name === packageName) {
           packageDirCache.set(cacheKey, child);
           return child;
@@ -221278,7 +221461,7 @@ function toPackageRelativeFilter(token, rootDir, packageDir) {
     return normalized.slice(normalizedPackageDir.length + 1);
   }
   if (isAbsolute16(token)) {
-    const rel = relative14(join79(rootDir, packageDir), token).replace(/\\/g, "/");
+    const rel = relative14(join80(rootDir, packageDir), token).replace(/\\/g, "/");
     if (!rel.startsWith("../") && rel !== "..") return rel;
   }
   return token;
@@ -221535,7 +221718,7 @@ function createRunVerificationTool(opts) {
       if (params.cwd && isAbsolute16(params.cwd)) {
         resolvedCwd = params.cwd;
       } else if (params.cwd) {
-        resolvedCwd = join79(worktreePath, params.cwd);
+        resolvedCwd = join80(worktreePath, params.cwd);
       } else {
         resolvedCwd = worktreePath;
       }
@@ -221568,7 +221751,7 @@ function createRunVerificationTool(opts) {
         warnings.push(...normalized.warnings);
       }
       if (effectiveCommand.trimStart().startsWith("pnpm --filter")) {
-        const modulesYaml = join79(rootDir, "node_modules", ".modules.yaml");
+        const modulesYaml = join80(rootDir, "node_modules", ".modules.yaml");
         if (!existsSync64(modulesYaml)) {
           const installCmd = "pnpm install --prefer-offline";
           const msg = `node_modules/.modules.yaml not found in workspace root \u2014 auto-prepending \`${installCmd}\` before running the command.`;
@@ -221913,9 +222096,9 @@ var init_pseudo_pause = __esm({
 import { exec as exec38, execFile as execFile26, execSync as execSync7 } from "node:child_process";
 import { promisify as promisify53 } from "node:util";
 import { setImmediate as setImmediateCb3 } from "node:timers";
-import { basename as basename19, delimiter as delimiter2, isAbsolute as isAbsolute18, join as join80, relative as relative16, resolve as resolvePath3 } from "node:path";
+import { basename as basename19, delimiter as delimiter2, isAbsolute as isAbsolute18, join as join81, relative as relative16, resolve as resolvePath3 } from "node:path";
 import { existsSync as existsSync65, lstatSync as lstatSync3, realpathSync as realpathSync9 } from "node:fs";
-import { readFile as readFile38, rm as rm13, writeFile as writeFile30 } from "node:fs/promises";
+import { readFile as readFile39, rm as rm13, writeFile as writeFile30 } from "node:fs/promises";
 import { Type as Type7 } from "@earendil-works/pi-ai";
 import { SessionManager as SessionManager2 } from "@earendil-works/pi-coding-agent";
 function mergeAdditionalSkillPaths2(...pathGroups) {
@@ -221929,7 +222112,7 @@ function isWorkflowStepSkillDiscoverable(skillName, additionalSkillPaths, ceSkil
     return false;
   }
   return (additionalSkillPaths ?? []).some(
-    (skillPath) => basename19(skillPath) === bareSkillName && existsSync65(join80(skillPath, "SKILL.md")) || existsSync65(join80(skillPath, bareSkillName, "SKILL.md"))
+    (skillPath) => basename19(skillPath) === bareSkillName && existsSync65(join81(skillPath, "SKILL.md")) || existsSync65(join81(skillPath, bareSkillName, "SKILL.md"))
   );
 }
 function getPromptSection(prompt, heading) {
@@ -222238,7 +222421,7 @@ function normalizeWorktreePath(pathValue) {
 }
 async function extractPersistedSessionWorktreePath(sessionFile, rootDir, settings) {
   try {
-    const content = await readFile38(sessionFile, "utf-8");
+    const content = await readFile39(sessionFile, "utf-8");
     const matches = content.match(buildSessionWorktreePathRegex(rootDir, settings)) ?? [];
     if (matches.length === 0) return null;
     const normalizedCounts = /* @__PURE__ */ new Map();
@@ -225686,7 +225869,7 @@ ${info.feedback}`, revisionKey),
           const authoritativeAgentLayer = this.store.getAsyncLayer();
           if (!this.authoritativeAssignedAgentStore || authoritativeAgentLayer && !this.authoritativeAssignedAgentStore.backendMode) {
             this.authoritativeAssignedAgentStore = new AgentStore({
-              rootDir: join80(this.rootDir, ".fusion"),
+              rootDir: join81(this.rootDir, ".fusion"),
               taskStore: this.store,
               ...authoritativeAgentLayer ? { asyncLayer: authoritativeAgentLayer } : {}
             });
@@ -230146,7 +230329,7 @@ Graph value: ${failureValue}` : ""}`, budget.key),
         const activeMergeStatuses = /* @__PURE__ */ new Set(["merging", "merging-pr", "merging-fix"]);
         const isActiveTask = activeColumns.has(task.column) || activeMergeStatuses.has(task.status ?? "");
         if (!isActiveTask) {
-          const tasksDir = join80(this.store.getFusionDir(), "tasks");
+          const tasksDir = join81(this.store.getFusionDir(), "tasks");
           const promptPath = getPromptPath(tasksDir, task.id);
           const staleness = await evaluateSpecStaleness({ settings, promptPath, task });
           if (staleness.isStale) {
@@ -234007,10 +234190,10 @@ Please fix the issues so the verification can pass on the next attempt.`,
        * The section is replaced entirely to avoid accumulation of old feedback.
        */
       async injectWorkflowStepFailureInstructions(task, failureFeedback, stepName, retry) {
-        const promptPath = join80(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
+        const promptPath = join81(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
         let content;
         try {
-          content = await readFile38(promptPath, "utf-8");
+          content = await readFile39(promptPath, "utf-8");
         } catch {
           executorLog.warn(`${task.id}: PROMPT.md not found at ${promptPath}, skipping workflow failure injection`);
           return;
@@ -240549,7 +240732,7 @@ import { execFile as execFile27 } from "node:child_process";
 import { appendFileSync as appendFileSync2, existsSync as existsSync66, mkdirSync as mkdirSync11, readdirSync as readdirSync12, readFileSync as readFileSync24, realpathSync as realpathSync10, rmSync as rmSync9, statSync as statSync13 } from "node:fs";
 import { rm as rm14 } from "node:fs/promises";
 import { tmpdir as tmpdir10 } from "node:os";
-import { isAbsolute as isAbsolute19, join as join81, relative as relative17 } from "node:path";
+import { isAbsolute as isAbsolute19, join as join82, relative as relative17 } from "node:path";
 import { promisify as promisify56 } from "node:util";
 async function git4(args, cwd, opts = {}) {
   const { stdout } = await execFileAsync20("git", args, {
@@ -240580,7 +240763,7 @@ function isBenignAbsentWorktreeError(err) {
   return /is not a working tree|No such file or directory|spawn\s+.*\bENOENT\b/i.test(description);
 }
 function ensureAiMergeRootIgnored(projectRootDir, settings) {
-  const excludePath = join81(projectRootDir, ".git", "info", "exclude");
+  const excludePath = join82(projectRootDir, ".git", "info", "exclude");
   if (!existsSync66(excludePath)) return;
   try {
     const current = readFileSync24(excludePath, "utf-8");
@@ -240612,7 +240795,7 @@ function getAiMergeTempSearchRoots(projectRootDir, settings) {
   if (testWorkerRoot) {
     try {
       for (const entry of readdirSync12(testWorkerRoot)) {
-        if (entry.startsWith("redir-")) roots.push(join81(testWorkerRoot, entry));
+        if (entry.startsWith("redir-")) roots.push(join82(testWorkerRoot, entry));
       }
     } catch {
     }
@@ -240635,7 +240818,7 @@ async function pruneExistingAiMergeWorktrees(taskId, projectRootDir, audit, log3
       continue;
     }
     for (const entry of entries) {
-      const candidatePath = join81(tempRoot, entry);
+      const candidatePath = join82(tempRoot, entry);
       let canonicalPath = candidatePath;
       try {
         canonicalPath = realpathSync10(candidatePath);
@@ -241058,7 +241241,7 @@ import { promisify as promisify57 } from "node:util";
 import { realpathSync as realpathSync11, readdirSync as readdirSync13 } from "node:fs";
 import { mkdtemp as mkdtemp4 } from "node:fs/promises";
 import { tmpdir as tmpdir11 } from "node:os";
-import { join as join82 } from "node:path";
+import { join as join83 } from "node:path";
 async function git5(args, cwd, opts = {}) {
   const { stdout } = await execFileAsync21("git", args, {
     cwd,
@@ -241130,7 +241313,7 @@ function listAiMergeWorktreeCandidates(taskId, projectRootDir, settings) {
   if (testWorkerRoot) {
     try {
       for (const entry of readdirSync13(testWorkerRoot)) {
-        if (entry.startsWith("redir-")) roots.push(join82(testWorkerRoot, entry));
+        if (entry.startsWith("redir-")) roots.push(join83(testWorkerRoot, entry));
       }
     } catch {
     }
@@ -241143,7 +241326,7 @@ function listAiMergeWorktreeCandidates(taskId, projectRootDir, settings) {
     } catch {
       continue;
     }
-    for (const entry of entries) candidates.push(join82(root, entry));
+    for (const entry of entries) candidates.push(join83(root, entry));
   }
   return candidates;
 }
@@ -241477,7 +241660,7 @@ async function landOneRepo(repoRootDir, branch, integrationBranch, ctx) {
       registeredMergePaths.add(pathToRegister);
     };
     try {
-      mergeRoot = await mkdtemp4(join82(resolveAiMergeRoot(repoRootDir, settings), `fusion-ai-merge-${taskId.toLowerCase()}-`));
+      mergeRoot = await mkdtemp4(join83(resolveAiMergeRoot(repoRootDir, settings), `fusion-ai-merge-${taskId.toLowerCase()}-`));
       registerMergeRoot(mergeRoot);
       await git5(["worktree", "add", "--detach", mergeRoot, tipSha], repoRootDir);
       worktreeAdded = true;
@@ -241973,7 +242156,7 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
     for (const repoRel of repoKeys) {
       throwIfAborted2(options.signal, taskId);
       const entry = workspaceWorktrees[repoRel];
-      const repoRootDir = join82(workspaceRootDir, repoRel);
+      const repoRootDir = join83(workspaceRootDir, repoRel);
       let integrationBranch;
       try {
         integrationBranch = await resolveIntegrationBranch(
@@ -242290,7 +242473,7 @@ async function pushAfterMergeToRemote(input) {
   let worktreeAdded = false;
   const registeredPaths = /* @__PURE__ */ new Set();
   try {
-    pushRoot = await mkdtemp4(join82(resolveAiMergeRoot(projectRootDir, settings), `fusion-ai-merge-push-${taskId.toLowerCase()}-`));
+    pushRoot = await mkdtemp4(join83(resolveAiMergeRoot(projectRootDir, settings), `fusion-ai-merge-push-${taskId.toLowerCase()}-`));
     for (const p2 of [pushRoot]) {
       activeSessionRegistry.registerPath(p2, { taskId, kind: "ai-merge", ownerKey: `ai-merge-push:${taskId}` });
       registeredPaths.add(p2);
@@ -242597,7 +242780,7 @@ var init_merger_ai = __esm({
 
 // ../engine/src/task-revert.ts
 import { exec as exec41 } from "node:child_process";
-import { join as join83 } from "node:path";
+import { join as join84 } from "node:path";
 import { promisify as promisify58 } from "node:util";
 function quoteShellArg7(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -243047,7 +243230,7 @@ async function resolveWorkspaceTaskRevertCommits(task, opts) {
   const result2 = {};
   for (const repoRel of repoKeys) {
     const entry = workspaceWorktrees[repoRel];
-    const repoRootDir = join83(opts.workspaceRootDir, repoRel);
+    const repoRootDir = join84(opts.workspaceRootDir, repoRel);
     const landedSha = workspaceLandedShas[repoRel] ?? entry?.landedSha;
     if (landedSha && !entry?.baseCommitSha) {
       result2[repoRel] = { commits: [landedSha], source: "squash" };
@@ -243114,7 +243297,7 @@ async function revertWorkspaceTask(opts) {
   });
   const contexts = [];
   for (const repoRel of repoKeys) {
-    const repoRootDir = join83(workspaceRootDir, repoRel);
+    const repoRootDir = join84(workspaceRootDir, repoRel);
     let integrationBranch;
     try {
       integrationBranch = await resolveIntegrationBranch(repoRootDir, { ...opts.settings, integrationBranch: void 0, baseBranch: void 0 });
@@ -243239,7 +243422,7 @@ async function prepareWorkspaceRevertPrBranches(opts) {
   });
   const contexts = [];
   for (const repoRel of repoKeys) {
-    const repoRootDir = join83(workspaceRootDir, repoRel);
+    const repoRootDir = join84(workspaceRootDir, repoRel);
     let integrationBranch;
     try {
       integrationBranch = await resolveIntegrationBranch(repoRootDir, { ...opts.settings, integrationBranch: void 0, baseBranch: void 0 });
@@ -243580,7 +243763,7 @@ async function readOptionalTextFile(filePath) {
 }
 async function discoverMcpServers(opts) {
   const homeDir = opts.homeDir ?? process.env.HOME ?? process.env.USERPROFILE ?? osHomedir();
-  const readFile46 = opts.readFile ?? readOptionalTextFile;
+  const readFile47 = opts.readFile ?? readOptionalTextFile;
   const sources = getMcpDiscoverySources({
     homeDir,
     platform: osPlatform(),
@@ -243591,7 +243774,7 @@ async function discoverMcpServers(opts) {
   for (const source of sources) {
     let contents;
     try {
-      contents = await readFile46(source.path);
+      contents = await readFile47(source.path);
     } catch (error3) {
       errors.push(`${source.label}: ${error3 instanceof Error ? error3.message : String(error3)}`);
       continue;
@@ -244141,7 +244324,7 @@ var agent_reflection_exports = {};
 __export(agent_reflection_exports, {
   AgentReflectionService: () => AgentReflectionService
 });
-import { readFile as readFile39 } from "node:fs/promises";
+import { readFile as readFile40 } from "node:fs/promises";
 import { isAbsolute as isAbsolute20, resolve as resolve38 } from "node:path";
 var reflectionLog, REFLECTION_SYSTEM_PROMPT, DEFAULT_OUTCOME_LIMIT, AgentReflectionService;
 var init_agent_reflection = __esm({
@@ -244700,7 +244883,7 @@ Rules:
         if (agent.instructionsPath?.trim()) {
           const resolvedPath = isAbsolute20(agent.instructionsPath) ? agent.instructionsPath : resolve38(this.rootDir, agent.instructionsPath);
           try {
-            const content = await readFile39(resolvedPath, "utf-8");
+            const content = await readFile40(resolvedPath, "utf-8");
             if (content.trim()) {
               pieces.push(content.trim());
             }
@@ -246808,7 +246991,7 @@ The note must be specific (what/where/why). Prefer citing File Scope, PROMPT, a
 
 // ../engine/src/overseer-watchdog.ts
 import { existsSync as existsSync67, readFileSync as readFileSync25 } from "node:fs";
-import { dirname as dirname34, join as join84, relative as relative18, resolve as resolve39, sep as sep11 } from "node:path";
+import { dirname as dirname34, join as join85, relative as relative18, resolve as resolve39, sep as sep11 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 function defaultReadText(path10) {
   try {
@@ -246837,7 +247020,7 @@ function discoverOverseerWatchdogFiles(options) {
     };
     if (agentDir) {
       for (const name2 of WATCHDOG_FILENAMES) {
-        tryAdd(join84(agentDir, name2), "user", 999);
+        tryAdd(join85(agentDir, name2), "user", 999);
       }
     }
     let current = cwd;
@@ -246845,9 +247028,9 @@ function discoverOverseerWatchdogFiles(options) {
     for (let hop = 0; hop < 64; hop++) {
       const depth = relative18(cwd, current) === "" ? 0 : relative18(cwd, current).split(sep11).filter(Boolean).length;
       for (const name2 of WATCHDOG_FILENAMES) {
-        tryAdd(join84(current, name2), "project", depth);
-        tryAdd(join84(current, ".fusion", name2), "project", depth);
-        tryAdd(join84(current, ".omp", name2), "project", depth);
+        tryAdd(join85(current, name2), "project", depth);
+        tryAdd(join85(current, ".fusion", name2), "project", depth);
+        tryAdd(join85(current, ".omp", name2), "project", depth);
       }
       if (current === stopAt) break;
       const parent = dirname34(current);
@@ -255150,7 +255333,7 @@ __export(child_process_runtime_exports, {
 import { EventEmitter as EventEmitter28 } from "node:events";
 import { fork } from "node:child_process";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { dirname as dirname35, join as join85 } from "node:path";
+import { dirname as dirname35, join as join86 } from "node:path";
 var HealthMonitor, ChildProcessRuntime;
 var init_child_process_runtime = __esm({
   "../engine/src/runtimes/child-process-runtime.ts"() {
@@ -255312,7 +255495,7 @@ var init_child_process_runtime = __esm({
         const isCompiled = !import.meta.url.endsWith(".ts");
         const currentDir = dirname35(fileURLToPath4(import.meta.url));
         const workerFile = isCompiled ? "child-process-worker.js" : "child-process-worker.ts";
-        return join85(currentDir, workerFile);
+        return join86(currentDir, workerFile);
       }
       /**
        * Set up event forwarding from IPC host to runtime listeners.
@@ -261579,7 +261762,7 @@ import { mkdirSync as mkdirSync12 } from "node:fs";
 import { access as access10, unlink as unlink10, writeFile as writeFile32 } from "node:fs/promises";
 import net2 from "node:net";
 import { platform as platform3, tmpdir as tmpdir12 } from "node:os";
-import { join as join86 } from "node:path";
+import { join as join87 } from "node:path";
 import { createHash as createHash24 } from "node:crypto";
 function projectHash(projectId) {
   return createHash24("sha1").update(projectId).digest("hex").slice(0, 16);
@@ -261589,10 +261772,10 @@ function computeEngineSocketPath(projectId) {
   if (platform3() === "win32") {
     return `\\\\.\\pipe\\fusion-engine-${hash}`;
   }
-  return join86(tmpdir12(), `fusion-engine-${hash}.sock`);
+  return join87(tmpdir12(), `fusion-engine-${hash}.sock`);
 }
 function computeEngineLockFilePath(workingDir) {
-  return join86(workingDir, ".fusion", "engine.lock");
+  return join87(workingDir, ".fusion", "engine.lock");
 }
 async function ensureLockTargetExists(lockPath) {
   try {
@@ -261602,7 +261785,7 @@ async function ensureLockTargetExists(lockPath) {
   }
 }
 async function acquireLockfile(workingDir, onCompromised) {
-  const dir = join86(workingDir, ".fusion");
+  const dir = join87(workingDir, ".fusion");
   mkdirSync12(dir, { recursive: true });
   const path10 = computeEngineLockFilePath(workingDir);
   await ensureLockTargetExists(path10);
@@ -267278,7 +267461,7 @@ var init_issue_image_attachments = __esm({
 import { exec as exec45 } from "node:child_process";
 import { mkdtemp as mkdtemp6, rm as rm15 } from "node:fs/promises";
 import { tmpdir as tmpdir13 } from "node:os";
-import { join as join87 } from "node:path";
+import { join as join88 } from "node:path";
 import { promisify as promisify65 } from "node:util";
 function resolveCommentAuthor(input) {
   const login = input.login || "unknown";
@@ -268447,8 +268630,8 @@ var init_github = __esm({
               { timeout: 3e4, maxBuffer: 10 * 1024 * 1024 }
             );
             const mergeBase = mergeBaseStdout.trim();
-            const indexDir = await mkdtemp6(join87(tmpdir13(), "fn-pr-conflict-"));
-            const indexPath = join87(indexDir, "index");
+            const indexDir = await mkdtemp6(join88(tmpdir13(), "fn-pr-conflict-"));
+            const indexPath = join88(indexDir, "index");
             const gitEnv = { ...process.env, GIT_INDEX_FILE: indexPath };
             try {
               await execAsync40(`git -C ${quoteGitArg(opts.repoRoot)} read-tree -m ${quoteGitArg(mergeBase)} ${quoteGitArg(baseRef)} ${quoteGitArg(headRef)}`, {
@@ -272035,8 +272218,8 @@ var init_knowledge_index_refresh = __esm({
 // ../dashboard/src/pr-metadata-generator.ts
 import { promisify as promisify66 } from "node:util";
 import { exec as execCb } from "node:child_process";
-import { access as access11, readFile as readFile40 } from "node:fs/promises";
-import { join as join88 } from "node:path";
+import { access as access11, readFile as readFile41 } from "node:fs/promises";
+import { join as join89 } from "node:path";
 function buildFallbackPrMetadata(task) {
   return {
     title: task.title ?? task.id,
@@ -272236,14 +272419,14 @@ async function generatePrMetadata(input) {
     ]), combinedSignal);
     let promptContent = "";
     try {
-      const promptPath = join88(repoRoot, ".fusion", "tasks", task.id, "PROMPT.md");
-      promptContent = (await raceWithAbort(readFile40(promptPath, "utf8"), combinedSignal)).trim();
+      const promptPath = join89(repoRoot, ".fusion", "tasks", task.id, "PROMPT.md");
+      promptContent = (await raceWithAbort(readFile41(promptPath, "utf8"), combinedSignal)).trim();
     } catch {
       promptContent = "";
     }
-    const templatePath = join88(repoRoot, ".github", "pull_request_template.md");
+    const templatePath = join89(repoRoot, ".github", "pull_request_template.md");
     const templateExists = await raceWithAbort(access11(templatePath).then(() => true).catch(() => false), combinedSignal);
-    const template = templateExists ? await raceWithAbort(readFile40(templatePath, "utf8"), combinedSignal) : "";
+    const template = templateExists ? await raceWithAbort(readFile41(templatePath, "utf8"), combinedSignal) : "";
     const model = resolveTitleSummarizerSettingsModel(settings);
     const systemPrompt = [PR_METADATA_SYSTEM_PROMPT];
     const titleGuidance = settings.prTitlePromptInstructions?.trim();
@@ -279896,12 +280079,12 @@ import {
   unlinkSync as unlinkSync4
 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
-import { basename as basename21, dirname as dirname36, join as join89, resolve as resolve40 } from "node:path";
+import { basename as basename21, dirname as dirname36, join as join90, resolve as resolve40 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function resolveHermesHome(profile) {
-  const base = process.env.HERMES_HOME ?? join89(homedir12(), ".hermes");
+  const base = process.env.HERMES_HOME ?? join90(homedir12(), ".hermes");
   if (!profile || profile === "default") return base;
-  return join89(base, "profiles", profile);
+  return join90(base, "profiles", profile);
 }
 function getFusionSkillSourceCandidates(moduleUrl = import.meta.url) {
   const here = fileURLToPath5(moduleUrl);
@@ -279916,13 +280099,13 @@ function getFusionSkillSourceCandidates(moduleUrl = import.meta.url) {
 function resolveBundledFusionSkillSource() {
   const candidates = getFusionSkillSourceCandidates();
   for (const candidate of candidates) {
-    if (existsSync69(join89(candidate, "SKILL.md"))) return candidate;
+    if (existsSync69(join90(candidate, "SKILL.md"))) return candidate;
   }
   return null;
 }
 function installFusionSkillIntoHermesHome(options = {}) {
   const sourceDir = options.sourceDir ?? resolveBundledFusionSkillSource();
-  const targetDir = join89(resolveHermesHome(options.profile), "skills", FUSION_SKILL_NAME);
+  const targetDir = join90(resolveHermesHome(options.profile), "skills", FUSION_SKILL_NAME);
   if (!sourceDir) {
     return {
       outcome: "warning",
@@ -280011,7 +280194,7 @@ function isBrokenSymlink(path10) {
   }
 }
 function looksLikePriorFusionInstall(path10) {
-  const skillMd = join89(path10, "SKILL.md");
+  const skillMd = join90(path10, "SKILL.md");
   if (!existsSync69(skillMd)) return false;
   try {
     const body = readFileSync26(skillMd, "utf-8");
@@ -280023,7 +280206,7 @@ function looksLikePriorFusionInstall(path10) {
 function looksLikeFusionSkillTarget(path10) {
   if (!path10) return false;
   if (basename21(path10).toLowerCase() === FUSION_SKILL_NAME) return true;
-  return existsSync69(join89(path10, "SKILL.md"));
+  return existsSync69(join90(path10, "SKILL.md"));
 }
 var FUSION_SKILL_NAME;
 var init_fusion_skill_install = __esm({
@@ -280204,7 +280387,7 @@ var init_src8 = __esm({
 // ../../plugins/fusion-plugin-openclaw-runtime/src/pi-module.ts
 import { spawn as spawn13 } from "node:child_process";
 import { randomUUID as randomUUID50 } from "node:crypto";
-import { readFile as readFile42 } from "node:fs/promises";
+import { readFile as readFile43 } from "node:fs/promises";
 function asString2(v2) {
   return typeof v2 === "string" && v2.trim() !== "" ? v2.trim() : void 0;
 }
@@ -280275,7 +280458,7 @@ function createCliSession(opts) {
   };
 }
 async function configureOpenClawMcpServer(opts) {
-  const serverValue = await readFile42(opts.serverConfigPath, "utf-8");
+  const serverValue = await readFile43(opts.serverConfigPath, "utf-8");
   await new Promise((resolve53, reject) => {
     const child = spawn13(opts.binaryPath, ["--no-color", "--profile", opts.profile, "mcp", "set", opts.serverName, serverValue], {
       stdio: ["ignore", "pipe", "pipe"]
@@ -280419,7 +280602,7 @@ var init_pi_module = __esm({
 // ../../plugins/fusion-plugin-openclaw-runtime/src/mcp-config.ts
 import { writeFileSync as writeFileSync13 } from "node:fs";
 import { tmpdir as tmpdir14 } from "node:os";
-import { join as join90 } from "node:path";
+import { join as join91 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { dirname as dirname37 } from "node:path";
 function toolsToMcpToolDefs(tools) {
@@ -280432,16 +280615,16 @@ function toolsToMcpToolDefs(tools) {
 }
 function writeOpenClawMcpBridgeFiles(toolDefs, cacheKey) {
   const suffix = cacheKey ? `${process.pid}-${cacheKey}` : `${process.pid}`;
-  const schemaPath = join90(tmpdir14(), `openclaw-runtime-mcp-schemas-${suffix}.json`);
+  const schemaPath = join91(tmpdir14(), `openclaw-runtime-mcp-schemas-${suffix}.json`);
   writeFileSync13(schemaPath, JSON.stringify(toolDefs));
   const __filename = fileURLToPath6(import.meta.url);
   const __dirname3 = dirname37(__filename);
-  const serverPath = join90(__dirname3, "mcp-schema-server.cjs");
+  const serverPath = join91(__dirname3, "mcp-schema-server.cjs");
   const serverConfig = {
     command: "node",
     args: [serverPath, schemaPath]
   };
-  const serverConfigPath = join90(tmpdir14(), `openclaw-runtime-mcp-server-${suffix}.json`);
+  const serverConfigPath = join91(tmpdir14(), `openclaw-runtime-mcp-server-${suffix}.json`);
   writeFileSync13(serverConfigPath, JSON.stringify(serverConfig));
   return {
     schemaPath,
@@ -281209,9 +281392,9 @@ var init_cli_spawn3 = __esm({
 });
 
 // ../../plugins/fusion-plugin-grok-runtime/src/probe.ts
-import { readFile as readFile43 } from "node:fs/promises";
+import { readFile as readFile44 } from "node:fs/promises";
 import { homedir as homedir13 } from "node:os";
-import { join as join91 } from "node:path";
+import { join as join92 } from "node:path";
 function buildCandidates2(binaryPath) {
   const configuredBinaryPath = binaryPath?.trim() || void 0;
   const ordered = configuredBinaryPath ? [configuredBinaryPath, ...CANDIDATES3] : [...CANDIDATES3];
@@ -281228,10 +281411,10 @@ async function probeGrokApiKeyPresence() {
   if (typeof envKey === "string" && envKey.trim().length > 0) {
     return { detected: true };
   }
-  const settingsPath = join91(homedir13(), ".grok", "user-settings.json");
+  const settingsPath = join92(homedir13(), ".grok", "user-settings.json");
   let raw;
   try {
-    raw = await readFile43(settingsPath, "utf-8");
+    raw = await readFile44(settingsPath, "utf-8");
   } catch {
     return { detected: false, reason: "No Grok API key detected by Fusion (GROK_API_KEY unset, ~/.grok/user-settings.json not found); the CLI will use its own credentials." };
   }
@@ -281380,7 +281563,7 @@ var init_provider2 = __esm({
 
 // ../../plugins/fusion-plugin-grok-runtime/src/acp/cli-spawn.ts
 import { existsSync as existsSync70 } from "node:fs";
-import { dirname as dirname38, isAbsolute as isAbsolute22, join as join92, resolve as resolve41 } from "node:path";
+import { dirname as dirname38, isAbsolute as isAbsolute22, join as join93, resolve as resolve41 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function asTrimmedString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
@@ -281398,7 +281581,7 @@ function pluginRootDir() {
 }
 function bundledClaudeBridgeBinPath(pluginRoot = pluginRootDir()) {
   const extension = process.platform === "win32" ? ".cmd" : "";
-  return join92(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY}${extension}`);
+  return join93(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY}${extension}`);
 }
 function resolveBundledClaudeBridgeBinary(options = {}) {
   const root = options.pluginRoot ?? pluginRootDir();
@@ -282761,10 +282944,10 @@ import {
 } from "node:fs";
 import { createRequire as createRequire8 } from "node:module";
 import { tmpdir as tmpdir15 } from "node:os";
-import { basename as basename23, dirname as dirname40, join as join94, resolve as resolve43 } from "node:path";
+import { basename as basename23, dirname as dirname40, join as join95, resolve as resolve43 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function isSkillDir(dir) {
-  return existsSync71(join94(dir, "SKILL.md"));
+  return existsSync71(join95(dir, "SKILL.md"));
 }
 function pushUnique(out, candidate) {
   if (!candidate) return;
@@ -282772,8 +282955,8 @@ function pushUnique(out, candidate) {
   if (!out.includes(resolved)) out.push(resolved);
 }
 function pushSkillLayoutsAtRoot(out, root) {
-  pushUnique(out, join94(root, "skill", FUSION_SKILL_NAME2));
-  pushUnique(out, join94(root, "packages", "cli", "skill", FUSION_SKILL_NAME2));
+  pushUnique(out, join95(root, "skill", FUSION_SKILL_NAME2));
+  pushUnique(out, join95(root, "packages", "cli", "skill", FUSION_SKILL_NAME2));
 }
 function walkAncestorSkillCandidates(out, startDir, maxParents = 8) {
   let dir = startDir;
@@ -282788,7 +282971,7 @@ function pushPackageRequireCandidates(out, from) {
   try {
     const require5 = createRequire8(from);
     const pkgJson = require5.resolve("@runfusion/fusion/package.json");
-    pushUnique(out, join94(dirname40(pkgJson), "skill", FUSION_SKILL_NAME2));
+    pushUnique(out, join95(dirname40(pkgJson), "skill", FUSION_SKILL_NAME2));
   } catch {
   }
 }
@@ -282856,21 +283039,21 @@ function collectSkillsFromRoot(root, out) {
     return;
   }
   for (const entry of entries) {
-    const child = join94(root, entry);
+    const child = join95(root, entry);
     if (isSkillDir(child)) {
       out.set(entry, child);
     }
   }
 }
 function stageGrokSessionSkills(options = {}) {
-  const pluginDir = mkdtempSync3(join94(tmpdir15(), "fusion-grok-plugin-"));
-  const skillsDir = join94(pluginDir, "skills");
+  const pluginDir = mkdtempSync3(join95(tmpdir15(), "fusion-grok-plugin-"));
+  const skillsDir = join95(pluginDir, "skills");
   mkdirSync14(skillsDir, { recursive: true });
   const installed = /* @__PURE__ */ new Map();
   const includeFusion = options.includeFusionSkill !== false;
   if (includeFusion) {
     const fusionSource = resolveBundledFusionSkillSource2();
-    if (fusionSource && installSkillDir(fusionSource, join94(skillsDir, FUSION_SKILL_NAME2))) {
+    if (fusionSource && installSkillDir(fusionSource, join95(skillsDir, FUSION_SKILL_NAME2))) {
       installed.set(FUSION_SKILL_NAME2, fusionSource);
     }
   }
@@ -282880,15 +283063,15 @@ function stageGrokSessionSkills(options = {}) {
   }
   for (const [name2, source] of installed) {
     if (name2 === FUSION_SKILL_NAME2 && includeFusion) continue;
-    installSkillDir(source, join94(skillsDir, name2));
+    installSkillDir(source, join95(skillsDir, name2));
   }
   for (const [name2, source] of installed) {
-    if (!existsSync71(join94(skillsDir, name2))) {
-      installSkillDir(source, join94(skillsDir, name2));
+    if (!existsSync71(join95(skillsDir, name2))) {
+      installSkillDir(source, join95(skillsDir, name2));
     }
   }
   writeFileSync14(
-    join94(pluginDir, "plugin.json"),
+    join95(pluginDir, "plugin.json"),
     JSON.stringify(
       {
         name: "fusion-session-skills",
@@ -282954,7 +283137,7 @@ var init_skill_loader = __esm({
 import { createServer as createServer2 } from "node:http";
 import { existsSync as existsSync72, writeFileSync as writeFileSync15 } from "node:fs";
 import { tmpdir as tmpdir16 } from "node:os";
-import { dirname as dirname41, join as join95 } from "node:path";
+import { dirname as dirname41, join as join96 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 import { randomUUID as randomUUID52 } from "node:crypto";
 function toolsToMcpToolDefs2(tools) {
@@ -282966,7 +283149,7 @@ function toolsToMcpToolDefs2(tools) {
   }));
 }
 function fusionToolsMcpServerPath() {
-  return join95(dirname41(fileURLToPath9(import.meta.url)), "mcp-schema-server.cjs");
+  return join96(dirname41(fileURLToPath9(import.meta.url)), "mcp-schema-server.cjs");
 }
 function missingMcpSchemaServerError(serverPath) {
   const error3 = new Error(`Fusion MCP schema server is missing: ${serverPath}`);
@@ -283007,7 +283190,7 @@ async function startFusionToolBridge(tools) {
       byName.set(tool.name, tool);
     }
   }
-  const schemaPath = join95(tmpdir16(), `fusion-grok-mcp-schemas-${process.pid}-${randomUUID52()}.json`);
+  const schemaPath = join96(tmpdir16(), `fusion-grok-mcp-schemas-${process.pid}-${randomUUID52()}.json`);
   writeFileSync15(schemaPath, JSON.stringify(defs));
   const server = createServer2(async (req, res) => {
     if (req.method !== "POST" || req.url !== "/tool-call") {
@@ -283440,7 +283623,7 @@ var init_src11 = __esm({
 
 // ../../plugins/fusion-plugin-claude-runtime/src/acp/cli-spawn.ts
 import { existsSync as existsSync73 } from "node:fs";
-import { dirname as dirname42, isAbsolute as isAbsolute23, join as join96, resolve as resolve44 } from "node:path";
+import { dirname as dirname42, isAbsolute as isAbsolute23, join as join97, resolve as resolve44 } from "node:path";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
 function asTrimmedString2(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
@@ -283458,7 +283641,7 @@ function pluginRootDir2() {
 }
 function bundledClaudeBridgeBinPath2(pluginRoot = pluginRootDir2()) {
   const extension = process.platform === "win32" ? ".cmd" : "";
-  return join96(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY2}${extension}`);
+  return join97(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY2}${extension}`);
 }
 function resolveBundledClaudeBridgeBinary2(options = {}) {
   const root = options.pluginRoot ?? pluginRootDir2();
@@ -284698,14 +284881,14 @@ var init_acp2 = __esm({
 // ../../plugins/fusion-plugin-claude-runtime/src/cli-spawn.ts
 import { spawn as spawn19 } from "node:child_process";
 import { existsSync as existsSync74 } from "node:fs";
-import { basename as basename25, dirname as dirname44, isAbsolute as isAbsolute24, join as join98, resolve as resolve46 } from "node:path";
+import { basename as basename25, dirname as dirname44, isAbsolute as isAbsolute24, join as join99, resolve as resolve46 } from "node:path";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 function pluginRootDir3() {
   const moduleDir = dirname44(fileURLToPath11(import.meta.url));
   return ["src", "dist"].includes(basename25(moduleDir)) ? resolve46(moduleDir, "..") : moduleDir;
 }
 function bundledClaudeBridgeBinPath3(pluginRoot = pluginRootDir3()) {
-  return join98(pluginRoot, "bridge", `${CLAUDE_CODE_CLI_ACP_BINARY3}${process.platform === "win32" ? ".cmd" : ""}`);
+  return join99(pluginRoot, "bridge", `${CLAUDE_CODE_CLI_ACP_BINARY3}${process.platform === "win32" ? ".cmd" : ""}`);
 }
 function resolveBundledClaudeBridgeBinary3(options = {}) {
   const candidate = bundledClaudeBridgeBinPath3(options.pluginRoot ?? pluginRootDir3());
@@ -284882,10 +285065,10 @@ import {
 } from "node:fs";
 import { createRequire as createRequire9 } from "node:module";
 import { tmpdir as tmpdir17 } from "node:os";
-import { basename as basename26, dirname as dirname45, join as join99, resolve as resolve47 } from "node:path";
+import { basename as basename26, dirname as dirname45, join as join100, resolve as resolve47 } from "node:path";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
 function isSkillDir2(dir) {
-  return existsSync75(join99(dir, "SKILL.md"));
+  return existsSync75(join100(dir, "SKILL.md"));
 }
 function pushUnique2(out, candidate) {
   if (!candidate) return;
@@ -284893,8 +285076,8 @@ function pushUnique2(out, candidate) {
   if (!out.includes(resolved)) out.push(resolved);
 }
 function pushSkillLayoutsAtRoot2(out, root) {
-  pushUnique2(out, join99(root, "skill", FUSION_SKILL_NAME3));
-  pushUnique2(out, join99(root, "packages", "cli", "skill", FUSION_SKILL_NAME3));
+  pushUnique2(out, join100(root, "skill", FUSION_SKILL_NAME3));
+  pushUnique2(out, join100(root, "packages", "cli", "skill", FUSION_SKILL_NAME3));
 }
 function walkAncestorSkillCandidates2(out, startDir, maxParents = 8) {
   let dir = startDir;
@@ -284909,7 +285092,7 @@ function pushPackageRequireCandidates2(out, from) {
   try {
     const require5 = createRequire9(from);
     const pkgJson = require5.resolve("@runfusion/fusion/package.json");
-    pushUnique2(out, join99(dirname45(pkgJson), "skill", FUSION_SKILL_NAME3));
+    pushUnique2(out, join100(dirname45(pkgJson), "skill", FUSION_SKILL_NAME3));
   } catch {
   }
 }
@@ -284977,21 +285160,21 @@ function collectSkillsFromRoot2(root, out) {
     return;
   }
   for (const entry of entries) {
-    const child = join99(root, entry);
+    const child = join100(root, entry);
     if (isSkillDir2(child)) {
       out.set(entry, child);
     }
   }
 }
 function stageClaudeSessionSkills(options = {}) {
-  const pluginDir = mkdtempSync4(join99(tmpdir17(), "fusion-claude-plugin-"));
-  const skillsDir = join99(pluginDir, "skills");
+  const pluginDir = mkdtempSync4(join100(tmpdir17(), "fusion-claude-plugin-"));
+  const skillsDir = join100(pluginDir, "skills");
   mkdirSync15(skillsDir, { recursive: true });
   const installed = /* @__PURE__ */ new Map();
   const includeFusion = options.includeFusionSkill !== false;
   if (includeFusion) {
     const fusionSource = resolveBundledFusionSkillSource3();
-    if (fusionSource && installSkillDir2(fusionSource, join99(skillsDir, FUSION_SKILL_NAME3))) {
+    if (fusionSource && installSkillDir2(fusionSource, join100(skillsDir, FUSION_SKILL_NAME3))) {
       installed.set(FUSION_SKILL_NAME3, fusionSource);
     }
   }
@@ -285001,15 +285184,15 @@ function stageClaudeSessionSkills(options = {}) {
   }
   for (const [name2, source] of installed) {
     if (name2 === FUSION_SKILL_NAME3 && includeFusion) continue;
-    installSkillDir2(source, join99(skillsDir, name2));
+    installSkillDir2(source, join100(skillsDir, name2));
   }
   for (const [name2, source] of installed) {
-    if (!existsSync75(join99(skillsDir, name2))) {
-      installSkillDir2(source, join99(skillsDir, name2));
+    if (!existsSync75(join100(skillsDir, name2))) {
+      installSkillDir2(source, join100(skillsDir, name2));
     }
   }
   writeFileSync16(
-    join99(pluginDir, "plugin.json"),
+    join100(pluginDir, "plugin.json"),
     JSON.stringify(
       {
         name: "fusion-session-skills",
@@ -285075,7 +285258,7 @@ var init_skill_loader2 = __esm({
 import { createServer as createServer3 } from "node:http";
 import { existsSync as existsSync76, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
 import { tmpdir as tmpdir18 } from "node:os";
-import { dirname as dirname46, join as join100 } from "node:path";
+import { dirname as dirname46, join as join101 } from "node:path";
 import { fileURLToPath as fileURLToPath13 } from "node:url";
 import { randomBytes as randomBytes7, randomUUID as randomUUID53 } from "node:crypto";
 function toolsToMcpToolDefs3(tools) {
@@ -285087,7 +285270,7 @@ function toolsToMcpToolDefs3(tools) {
   }));
 }
 function fusionToolsMcpServerPath2() {
-  return join100(dirname46(fileURLToPath13(import.meta.url)), "mcp-schema-server.cjs");
+  return join101(dirname46(fileURLToPath13(import.meta.url)), "mcp-schema-server.cjs");
 }
 function missingMcpSchemaServerError2(serverPath) {
   const error3 = new Error(`Fusion MCP schema server is missing: ${serverPath}`);
@@ -285128,7 +285311,7 @@ async function startFusionToolBridge2(tools, options = {}) {
       byName.set(tool.name, tool);
     }
   }
-  const schemaPath = join100(tmpdir18(), `fusion-claude-mcp-schemas-${process.pid}-${randomUUID53()}.json`);
+  const schemaPath = join101(tmpdir18(), `fusion-claude-mcp-schemas-${process.pid}-${randomUUID53()}.json`);
   writeFileSync17(schemaPath, JSON.stringify(defs));
   const capabilityToken = randomBytes7(32).toString("base64url");
   const server = createServer3(async (req, res) => {
@@ -285932,7 +286115,7 @@ var init_provider6 = __esm({
 
 // ../../plugins/fusion-plugin-omp-runtime/src/acp/cli-spawn.ts
 import { existsSync as existsSync77 } from "node:fs";
-import { dirname as dirname47, isAbsolute as isAbsolute25, join as join101, resolve as resolve48 } from "node:path";
+import { dirname as dirname47, isAbsolute as isAbsolute25, join as join102, resolve as resolve48 } from "node:path";
 import { fileURLToPath as fileURLToPath14 } from "node:url";
 function asTrimmedString3(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
@@ -285950,7 +286133,7 @@ function pluginRootDir4() {
 }
 function bundledClaudeBridgeBinPath4(pluginRoot = pluginRootDir4()) {
   const extension = process.platform === "win32" ? ".cmd" : "";
-  return join101(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY4}${extension}`);
+  return join102(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY4}${extension}`);
 }
 function resolveBundledClaudeBridgeBinary4(options = {}) {
   const root = options.pluginRoot ?? pluginRootDir4();
@@ -287268,7 +287451,7 @@ var init_mcp_forwarding3 = __esm({
 import { createServer as createServer4 } from "node:http";
 import { existsSync as existsSync78, unlinkSync as unlinkSync5, writeFileSync as writeFileSync18 } from "node:fs";
 import { tmpdir as tmpdir19 } from "node:os";
-import { dirname as dirname49, join as join103 } from "node:path";
+import { dirname as dirname49, join as join104 } from "node:path";
 import { fileURLToPath as fileURLToPath15 } from "node:url";
 import { randomUUID as randomUUID54 } from "node:crypto";
 function toolsToMcpToolDefs4(tools) {
@@ -287285,12 +287468,12 @@ function fusionToolsMcpServerPath3() {
   const here = dirname49(fileURLToPath15(import.meta.url));
   const candidates = [
     // Packaged CLI / same-dir as bundled.js or tool-bridge source.
-    join103(here, "mcp-schema-server.cjs"),
+    join104(here, "mcp-schema-server.cjs"),
     // Source layout when running from dist/ that still has ../src assets.
-    join103(here, "src", "mcp-schema-server.cjs"),
-    join103(here, "..", "src", "mcp-schema-server.cjs"),
+    join104(here, "src", "mcp-schema-server.cjs"),
+    join104(here, "..", "src", "mcp-schema-server.cjs"),
     // Monorepo plugin root relative to src/ or dist/plugins/.../bundled.js.
-    join103(here, "..", "mcp-schema-server.cjs")
+    join104(here, "..", "mcp-schema-server.cjs")
   ];
   for (const candidate of candidates) {
     if (existsSync78(candidate)) return candidate;
@@ -287327,7 +287510,7 @@ async function startFusionToolBridge3(tools) {
       byName.set(tool.name, tool);
     }
   }
-  const schemaPath = join103(tmpdir19(), `fusion-omp-mcp-schemas-${process.pid}-${randomUUID54()}.json`);
+  const schemaPath = join104(tmpdir19(), `fusion-omp-mcp-schemas-${process.pid}-${randomUUID54()}.json`);
   writeFileSync18(schemaPath, JSON.stringify(defs));
   const server = createServer4(async (req, res) => {
     if (req.method !== "POST" || req.url !== "/tool-call") {
@@ -289049,8 +289232,8 @@ var init_types5 = __esm({
 
 // ../dashboard/src/stt/model-manager.ts
 import { createHash as createHash25, randomUUID as randomUUID56 } from "node:crypto";
-import { mkdir as mkdir31, open as open4, readFile as readFile44, readdir as readdir11, rename as rename10, rm as rm18, stat as stat12, writeFile as writeFile34 } from "node:fs/promises";
-import { join as join104, relative as relative19, resolve as resolve50, sep as sep15 } from "node:path";
+import { mkdir as mkdir31, open as open4, readFile as readFile45, readdir as readdir11, rename as rename10, rm as rm18, stat as stat12, writeFile as writeFile34 } from "node:fs/promises";
+import { join as join105, relative as relative19, resolve as resolve50, sep as sep15 } from "node:path";
 function parseSafeTarListing(listing) {
   for (const line2 of listing.split("\n").filter(Boolean)) {
     const type = line2[0];
@@ -289065,8 +289248,8 @@ function parseSafeTarListing(listing) {
 function createVoiceModelManager(options = {}) {
   const asset = options.asset ?? PARAKEET_V3_ASSET;
   let configuredCacheDir = options.cacheDir;
-  const cacheDir = () => configuredCacheDir ??= join104(resolveGlobalDir(), "models", "parakeet-v3");
-  const finalDir = () => join104(cacheDir(), "model");
+  const cacheDir = () => configuredCacheDir ??= join105(resolveGlobalDir(), "models", "parakeet-v3");
+  const finalDir = () => join105(cacheDir(), "model");
   let state = { status: "not-installed" };
   let generation = 0;
   let cleanupBarrier = Promise.resolve();
@@ -289129,8 +289312,8 @@ function createVoiceModelManager(options = {}) {
       if (!current(g2, signal)) return state;
       await mkdir31(cacheDir(), { recursive: true });
       if (!current(g2, signal)) return state;
-      partial2 = join104(cacheDir(), `.partial-${g2}-${randomUUID56()}`);
-      staging = join104(cacheDir(), `.staging-${g2}-${randomUUID56()}`);
+      partial2 = join105(cacheDir(), `.partial-${g2}-${randomUUID56()}`);
+      staging = join105(cacheDir(), `.staging-${g2}-${randomUUID56()}`);
       const file = await open4(partial2, "wx");
       try {
         const response = await (options.fetch ?? globalThis.fetch)(asset.url, { signal });
@@ -289175,10 +289358,10 @@ function createVoiceModelManager(options = {}) {
         }
       }
       if (!current(g2, signal)) return state;
-      await writeFile34(join104(staging, "manifest.json"), JSON.stringify({ filename: asset.filename, sha256: asset.sha256, installedAt: (/* @__PURE__ */ new Date()).toISOString(), expectedFiles: asset.expectedFiles }));
+      await writeFile34(join105(staging, "manifest.json"), JSON.stringify({ filename: asset.filename, sha256: asset.sha256, installedAt: (/* @__PURE__ */ new Date()).toISOString(), expectedFiles: asset.expectedFiles }));
       await options.beforePromote?.(signal);
       if (!current(g2, signal)) return state;
-      const backup = join104(cacheDir(), `.backup-${g2}-${randomUUID56()}`);
+      const backup = join105(cacheDir(), `.backup-${g2}-${randomUUID56()}`);
       let movedPrevious = false;
       try {
         try {
@@ -289258,9 +289441,9 @@ function createVoiceModelManager(options = {}) {
           publish(absent);
           return absent;
         }
-        const manifest = JSON.parse(await readFile44(join104(finalDir(), "manifest.json"), "utf8"));
+        const manifest = JSON.parse(await readFile45(join105(finalDir(), "manifest.json"), "utf8"));
         if (manifest.sha256 !== asset.sha256) throw new Error("stale manifest digest");
-        for (const expected of asset.expectedFiles) if (!await existsFile(join104(finalDir(), expected))) throw new Error("missing expected model file");
+        for (const expected of asset.expectedFiles) if (!await existsFile(join105(finalDir(), expected))) throw new Error("missing expected model file");
         const installed = { status: "installed", checksumVerified: true, installedPath: finalDir() };
         publish(installed);
         return installed;
@@ -289272,7 +289455,7 @@ function createVoiceModelManager(options = {}) {
         try {
           for (const entry of await readdir11(cacheDir())) {
             const own = /^\.(partial|staging|backup)-(\d+)-/.exec(entry);
-            if (own && Number(own[2]) !== active?.generation) await rm18(join104(cacheDir(), entry), { recursive: true, force: true });
+            if (own && Number(own[2]) !== active?.generation) await rm18(join105(cacheDir(), entry), { recursive: true, force: true });
           }
         } catch {
         }
@@ -289294,7 +289477,7 @@ function createVoiceModelManager(options = {}) {
         try {
           for (const entry of await readdir11(cacheDir())) {
             const match = /^\.(partial|staging|backup)-(\d+)-/.exec(entry);
-            if (match && Number(match[2]) <= g2) await rm18(join104(cacheDir(), entry), { recursive: true, force: true });
+            if (match && Number(match[2]) <= g2) await rm18(join105(cacheDir(), entry), { recursive: true, force: true });
           }
         } catch {
         }
@@ -290080,7 +290263,7 @@ var init_provider_health_monitor = __esm({
 
 // ../dashboard/src/server.ts
 import express3 from "express";
-import { join as join105, dirname as dirname50 } from "node:path";
+import { join as join106, dirname as dirname50 } from "node:path";
 import { fileURLToPath as fileURLToPath16 } from "node:url";
 import { WebSocketServer as WebSocketServer2 } from "ws";
 function clearAiSessionCleanupInterval() {
@@ -290784,7 +290967,7 @@ __export(task_exports, {
 });
 import { createInterface as createInterface2 } from "node:readline/promises";
 import { watchFile, unwatchFile, statSync as statSync14, existsSync as existsSync80, readFileSync as readFileSync27 } from "node:fs";
-import { basename as basename29, join as join106 } from "node:path";
+import { basename as basename29, join as join107 } from "node:path";
 function columnLabel(column) {
   return COLUMN_LABELS[column] ?? column;
 }
@@ -291142,7 +291325,7 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName,
     }
     console.log(`    Path:   .fusion/tasks/${resolvedTask.id}/`);
     if (attachFiles && attachFiles.length > 0) {
-      const { readFile: readFile46 } = await import("node:fs/promises");
+      const { readFile: readFile47 } = await import("node:fs/promises");
       const { basename: basename31, extname: extname5, resolve: resolve53 } = await import("node:path");
       for (const filePath of attachFiles) {
         const resolvedPath = resolve53(filePath);
@@ -291155,7 +291338,7 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName,
         }
         let content;
         try {
-          content = await readFile46(resolvedPath);
+          content = await readFile47(resolvedPath);
         } catch {
           console.error(`    \u2717 Cannot read file: ${filePath}`);
           continue;
@@ -291326,7 +291509,7 @@ async function runTaskLogs(id, options = {}, projectName) {
   printEntries(filteredEntries);
   if (options.follow) {
     const projectPath = context.projectPath ?? process.cwd();
-    const logPath = join106(projectPath, ".fusion", "tasks", id, "agent.log");
+    const logPath = join107(projectPath, ".fusion", "tasks", id, "agent.log");
     if (!existsSync80(logPath)) {
       console.log(`
   Waiting for log file to be created...`);
@@ -291531,7 +291714,7 @@ async function runTaskMerge(id, projectName) {
   }
 }
 async function runTaskAttach(id, filePath, projectName) {
-  const { readFile: readFile46 } = await import("node:fs/promises");
+  const { readFile: readFile47 } = await import("node:fs/promises");
   const { basename: basename31, extname: extname5 } = await import("node:path");
   const { resolve: resolve53 } = await import("node:path");
   const resolvedPath = resolve53(filePath);
@@ -291545,7 +291728,7 @@ async function runTaskAttach(id, filePath, projectName) {
   }
   let content;
   try {
-    content = await readFile46(resolvedPath);
+    content = await readFile47(resolvedPath);
   } catch {
     console.error(`Cannot read file: ${filePath}`);
     process.exit(1);
@@ -292710,8 +292893,8 @@ init_src15();
 import { randomUUID as randomUUID58 } from "node:crypto";
 import { Type as Type9 } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
-import { resolve as resolve52, relative as relative20, isAbsolute as isAbsolute26, sep as sep16, basename as basename30, extname as extname4, join as join107 } from "node:path";
-import { readFile as readFile45 } from "node:fs/promises";
+import { resolve as resolve52, relative as relative20, isAbsolute as isAbsolute26, sep as sep16, basename as basename30, extname as extname4, join as join108 } from "node:path";
+import { readFile as readFile46 } from "node:fs/promises";
 import { existsSync as existsSync81 } from "node:fs";
 import { spawn as spawn23 } from "node:child_process";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -292792,12 +292975,12 @@ function resolveProjectRoot2(cwd) {
     warnedMissingProjectRootResolver = true;
     console.warn("[fusion-extension] @fusion/core.getProjectRootFromWorktree is unavailable; using filesystem fallback resolution.");
   }
-  if (worktreeProjectRoot && existsSync81(join107(worktreeProjectRoot, ".fusion"))) {
+  if (worktreeProjectRoot && existsSync81(join108(worktreeProjectRoot, ".fusion"))) {
     return worktreeProjectRoot;
   }
   let current = resolve52(cwd);
   while (true) {
-    if (existsSync81(join107(current, ".fusion"))) {
+    if (existsSync81(join108(current, ".fusion"))) {
       return current;
     }
     const parent = resolve52(current, "..");
@@ -293059,7 +293242,7 @@ async function closeCachedStores() {
   }
 }
 function getFusionDir(cwd) {
-  return join107(resolveProjectRoot2(cwd), ".fusion");
+  return join108(resolveProjectRoot2(cwd), ".fusion");
 }
 function requireProjectLayer(store, consumer) {
   const layer = store.getAsyncLayer();
@@ -293841,7 +294024,7 @@ ${renderAgentLogEntries(entries)}` : `${header}
       }
       let content;
       try {
-        content = await readFile45(filePath);
+        content = await readFile46(filePath);
       } catch {
         throw new Error(`Cannot read file: ${params.path}`);
       }