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

package/dist/bin.js

@@ -5605,7 +5605,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       sql2.raw = raw;
-      function join155(chunks, separator) {
+      function join156(chunks, separator) {
         const result2 = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -5615,7 +5615,7 @@ var init_sql = __esm({
         }
         return new SQL(result2);
       }
-      sql2.join = join155;
+      sql2.join = join156;
       function identifier(value) {
         return new Name(value);
       }
@@ -10263,7 +10263,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((join155) => join155.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join156) => join156.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -11798,7 +11798,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join155) => join155.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join156) => join156.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -11894,10 +11894,10 @@ var init_update = __esm({
               const fromFields = this.getTableLikeFields(this.config.from);
               fields[tableName] = fromFields;
             }
-            for (const join155 of this.config.joins) {
-              const tableName2 = getTableLikeName(join155.table);
-              if (typeof tableName2 === "string" && !is(join155.table, SQL)) {
-                const fromFields = this.getTableLikeFields(join155.table);
+            for (const join156 of this.config.joins) {
+              const tableName2 = getTableLikeName(join156.table);
+              if (typeof tableName2 === "string" && !is(join156.table, SQL)) {
+                const fromFields = this.getTableLikeFields(join156.table);
                 fields[tableName2] = fromFields;
               }
             }
@@ -20501,26 +20501,26 @@ function validateParallelism(nodes2, outgoing, nodesById) {
     }
     const joinsReached = /* @__PURE__ */ new Set();
     for (const edge of branchEdges) {
-      const join156 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
-      if (!join156) {
+      const join157 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
+      if (!join157) {
         throw new WorkflowIrError(`split '${split.id}' has a branch with no reachable matching join`);
       }
-      joinsReached.add(join156);
+      joinsReached.add(join157);
     }
     if (joinsReached.size !== 1) {
       throw new WorkflowIrError(`split '${split.id}' branches converge on more than one join`);
     }
     const joinId = [...joinsReached][0];
-    const join155 = nodesById.get(joinId);
-    const mode = join155.config?.mode;
+    const join156 = nodesById.get(joinId);
+    const mode = join156.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 '${join155.id}' quorum must be a positive integer`);
+        throw new WorkflowIrError(`join '${join156.id}' quorum must be a positive integer`);
       }
       if (n > branchEdges.length) {
         throw new WorkflowIrError(
-          `join '${join155.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
+          `join '${join156.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
         );
       }
     }
@@ -24076,14 +24076,14 @@ async function detectWorkspaceRepos(dir2, runner = runGitCommand, timeout2 = DEF
     return [];
   }
   const { stat: stat20 } = await import("node:fs/promises");
-  const { join: join155 } = await import("node:path");
+  const { join: join156 } = 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 = join155(dir2, entry);
+    const childDir = join156(dir2, entry);
     try {
-      const s3 = await stat20(join155(childDir, ".git"));
+      const s3 = await stat20(join156(childDir, ".git"));
       if (!s3.isDirectory() && !s3.isFile()) continue;
     } catch {
       continue;
@@ -24096,9 +24096,9 @@ async function detectWorkspaceRepos(dir2, runner = runGitCommand, timeout2 = DEF
 }
 async function isWorkspaceModeExplicitlyDisabled(projectPath) {
   try {
-    const { readFile: readFile63 } = await import("node:fs/promises");
-    const { join: join155 } = await import("node:path");
-    const raw = await readFile63(join155(projectPath, ".fusion", "config.json"), "utf-8");
+    const { readFile: readFile64 } = await import("node:fs/promises");
+    const { join: join156 } = await import("node:path");
+    const raw = await readFile64(join156(projectPath, ".fusion", "config.json"), "utf-8");
     const config3 = JSON.parse(raw);
     return config3.settings?.workspaceMode === false;
   } catch {
@@ -24106,12 +24106,12 @@ async function isWorkspaceModeExplicitlyDisabled(projectPath) {
   }
 }
 async function setWorkspaceModeInConfig(projectPath, value) {
-  const { readFile: readFile63, writeFile: writeFile44, mkdir: mkdir42 } = await import("node:fs/promises");
-  const { join: join155 } = await import("node:path");
-  const configPath = join155(projectPath, ".fusion", "config.json");
+  const { readFile: readFile64, writeFile: writeFile44, mkdir: mkdir42 } = await import("node:fs/promises");
+  const { join: join156 } = await import("node:path");
+  const configPath = join156(projectPath, ".fusion", "config.json");
   let config3 = {};
   try {
-    config3 = JSON.parse(await readFile63(configPath, "utf-8"));
+    config3 = JSON.parse(await readFile64(configPath, "utf-8"));
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
@@ -24120,7 +24120,7 @@ async function setWorkspaceModeInConfig(projectPath, value) {
   }
   const settings = config3.settings;
   settings.workspaceMode = value;
-  await mkdir42(join155(projectPath, ".fusion"), { recursive: true });
+  await mkdir42(join156(projectPath, ".fusion"), { recursive: true });
   await writeFile44(configPath, JSON.stringify(config3, null, 2), "utf-8");
 }
 function isInRootRelativePath(entry, pathMod) {
@@ -24133,12 +24133,12 @@ function isInRootRelativePath(entry, pathMod) {
   return true;
 }
 async function loadWorkspaceConfig(rootDir) {
-  const { readFile: readFile63 } = await import("node:fs/promises");
+  const { readFile: readFile64 } = await import("node:fs/promises");
   const pathMod = await import("node:path");
-  const { join: join155 } = pathMod;
-  const configPath = join155(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME);
+  const { join: join156 } = pathMod;
+  const configPath = join156(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME);
   try {
-    const raw = await readFile63(configPath, "utf-8");
+    const raw = await readFile64(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;
@@ -24152,11 +24152,11 @@ async function loadWorkspaceConfig(rootDir) {
 }
 async function saveWorkspaceConfig(rootDir, config3) {
   const { mkdir: mkdir42, writeFile: writeFile44 } = await import("node:fs/promises");
-  const { join: join155 } = await import("node:path");
-  const fusionDir = join155(rootDir, ".fusion");
+  const { join: join156 } = await import("node:path");
+  const fusionDir = join156(rootDir, ".fusion");
   await mkdir42(fusionDir, { recursive: true });
   await writeFile44(
-    join155(fusionDir, WORKSPACE_CONFIG_FILENAME),
+    join156(fusionDir, WORKSPACE_CONFIG_FILENAME),
     JSON.stringify(config3, null, 2),
     "utf-8"
   );
@@ -38985,11 +38985,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 join155 = fk.childColumns.map((column, index3) => `child.${quoteIdentifier(column)} IS NOT DISTINCT FROM parent.${quoteIdentifier(fk.parentColumns[index3])}`).join(" AND ");
+      const join156 = fk.childColumns.map((column, index3) => `child.${quoteIdentifier(column)} IS NOT DISTINCT FROM parent.${quoteIdentifier(fk.parentColumns[index3])}`).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 ${join155}
+        JOIN ${relationName({ schema: fk.parentSchema, table: fk.parentTable })} parent ON ${join156}
         JOIN fusion_rekey_conflict_candidates parent_candidate
           ON parent_candidate.schema_name = ${quoteLiteral(fk.parentSchema)}
          AND parent_candidate.table_name = ${quoteLiteral(fk.parentTable)}
@@ -49826,8 +49826,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static async parseFile(filePath) {
-        const { readFile: readFile63 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
-        const data = await readFile63(filePath, "utf8");
+        const { readFile: readFile64 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
+        const data = await readFile64(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -133433,8 +133433,8 @@ var require_graceful_fs = __commonJS({
       fs11.createReadStream = createReadStream6;
       fs11.createWriteStream = createWriteStream2;
       var fs$readFile = fs11.readFile;
-      fs11.readFile = readFile63;
-      function readFile63(path14, options, cb) {
+      fs11.readFile = readFile64;
+      function readFile64(path14, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path14, options, cb);
@@ -136150,10 +136150,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;
   }
@@ -136195,7 +136195,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);
@@ -136206,17 +136206,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);
@@ -162389,6 +162422,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(path14) {
+  try {
+    return await readFile29(path14, "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;
@@ -164398,7 +164511,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) {
@@ -164423,7 +164536,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")) {
@@ -165802,7 +165915,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);
@@ -165953,7 +166066,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 {
@@ -166086,7 +166199,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 errorMessage4 = err instanceof Error ? err.message : String(err);
     worktreePoolLog.warn(`Failed to read .worktrees/ directory: ${errorMessage4}`);
@@ -166118,7 +166231,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 errorMessage4 = err instanceof Error ? err.message : String(err);
       worktreePoolLog.warn(`Failed to read .worktrees/ directory for cleanup: ${errorMessage4}`);
@@ -166196,11 +166309,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}`);
@@ -166219,7 +166332,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)`);
@@ -166585,27 +166698,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) {
@@ -167719,9 +167832,9 @@ function assertInRootRepoRelPath(repoRelPath, sep23, isAbsolute36, normalize10)
 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: join155, isAbsolute: isAbsolute36, normalize: normalize10, sep: sep23 } = await import("node:path");
+  const { join: join156, isAbsolute: isAbsolute36, normalize: normalize10, sep: sep23 } = await import("node:path");
   assertInRootRepoRelPath(repoRelPath, sep23, isAbsolute36, normalize10);
-  const repoAbsPath = join155(workspaceRootDir, repoRelPath);
+  const repoAbsPath = join156(workspaceRootDir, repoRelPath);
   const existing = task.workspaceWorktrees?.[repoRelPath];
   if (existing) {
     let live = existsSync49(existing.worktreePath);
@@ -169445,7 +169558,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);
@@ -169532,9 +169645,9 @@ function readStdin() {
 async function runCodeNode(opts) {
   const timeoutMs = resolveCodeNodeTimeout(opts.timeoutMs);
   const compiled = await compileCodeNodeSource(opts.source);
-  const dir2 = await mkdtemp(join63(tmpdir4(), "fusion-code-node-"));
-  const userModuleFile = join63(dir2, "user.mjs");
-  const harnessFile = join63(dir2, "harness.mjs");
+  const dir2 = await mkdtemp(join64(tmpdir4(), "fusion-code-node-"));
+  const userModuleFile = join64(dir2, "user.mjs");
+  const harnessFile = join64(dir2, "harness.mjs");
   try {
     await writeFile24(userModuleFile, compiled, "utf8");
     await writeFile24(harnessFile, buildChildHarness(userModuleFile), "utf8");
@@ -169762,11 +169875,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 randomUUID46 } 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";
@@ -169778,16 +169891,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() : "";
@@ -169801,7 +169914,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 "";
@@ -169880,7 +169993,7 @@ async function listAgentMemoryFiles2(rootDir, agentMemory) {
   }
   for (const entry of entries) {
     if (!DAILY_AGENT_MEMORY_RE2.test(entry)) continue;
-    const absPath = join64(dir2, entry);
+    const absPath = join65(dir2, entry);
     const fileStat = await stat9(absPath);
     if (fileStat.isFile()) {
       files.push({
@@ -169903,7 +170016,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 index3 = 0; index3 < lines.length; index3 += 8) {
       const chunk = lines.slice(index3, index3 + 12).join("\n").trim();
@@ -170049,7 +170162,7 @@ function resolveAgentMemoryPath(rootDir, agentId, path14) {
     return null;
   }
   return {
-    absPath: join64(agentMemoryDirectory(rootDir, agentId), filename),
+    absPath: join65(agentMemoryDirectory(rootDir, agentId), filename),
     displayPath: `${prefix}${filename}`
   };
 }
@@ -170059,7 +170172,7 @@ async function getAgentMemoryWindow(rootDir, agentMemory, path14, 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));
@@ -170718,6 +170831,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: {}
@@ -171006,7 +171122,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}.`);
@@ -171349,25 +171465,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
@@ -173591,6 +173715,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();
@@ -173770,6 +173895,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({
@@ -178078,7 +178216,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(/[`),.;:!?\]}'"]+$/, "");
 }
@@ -178166,7 +178304,7 @@ async function detectDanglingTaskDocReferences(promptContent, opts) {
   }
   const dangling = [];
   for (const [path14, sections] of references.entries()) {
-    const absPath = join65(opts.rootDir, path14);
+    const absPath = join66(opts.rootDir, path14);
     if (await existsImpl(absPath)) continue;
     dangling.push({ path: path14, sections: Array.from(sections).sort() });
   }
@@ -178427,8 +178565,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 = "";
@@ -178460,7 +178598,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) {
@@ -178476,9 +178614,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)
@@ -178497,7 +178635,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) {
@@ -178559,7 +178697,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,
@@ -178705,7 +178843,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,
@@ -186712,8 +186850,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) {
@@ -187346,16 +187484,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" };
           }
@@ -187725,7 +187863,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 {
               }
@@ -191292,10 +191430,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();
@@ -191304,17 +191442,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");
@@ -191327,7 +191465,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;
@@ -191335,7 +191473,7 @@ function readInstallMarker(rootDir) {
 }
 function writeInstallMarker(rootDir, hash) {
   try {
-    writeFileSync7(join68(rootDir, INSTALL_MARKER_RELPATH), hash);
+    writeFileSync7(join69(rootDir, INSTALL_MARKER_RELPATH), hash);
   } catch {
   }
 }
@@ -191426,7 +191564,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;
   }
@@ -191803,7 +191941,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, "'\\''")}'`;
@@ -191834,14 +191972,14 @@ function resolveWorkspacePackageRoots(rootDir, globs) {
   for (const glob2 of globs) {
     const starIdx = glob2.indexOf("*");
     if (starIdx === -1) {
-      const candidate = join69(rootDir, glob2);
-      if (existsSync56(join69(candidate, "package.json"))) {
+      const candidate = join70(rootDir, glob2);
+      if (existsSync56(join70(candidate, "package.json"))) {
         roots.push(glob2);
       }
       continue;
     }
     const prefix = glob2.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);
@@ -191850,8 +191988,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);
       }
     }
@@ -191874,7 +192012,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) {
@@ -191891,7 +192029,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 [];
   }
@@ -191902,7 +192040,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");
@@ -191940,7 +192078,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;
   }
@@ -191982,7 +192120,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);
       }
     }
@@ -192010,7 +192148,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 {
@@ -192054,8 +192192,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());
@@ -192074,13 +192212,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;
@@ -194357,7 +194495,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], {
@@ -194443,9 +194581,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 });
@@ -194465,8 +194603,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);
@@ -194529,13 +194667,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);
@@ -194604,8 +194742,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, `'\\''`)}'`;
@@ -194744,8 +194882,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));
@@ -194901,7 +195039,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() {
@@ -195214,7 +195352,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`;
@@ -195713,7 +195851,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,
@@ -195742,7 +195880,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);
@@ -196315,7 +196453,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)}`,
@@ -196342,7 +196480,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 });
@@ -197830,13 +197968,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;
@@ -202879,7 +203017,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);
 }
@@ -202912,9 +203050,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) {
@@ -204347,6 +204485,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(
@@ -204388,20 +204555,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) {
@@ -205617,14 +205778,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;
@@ -209564,7 +209732,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(
@@ -209858,7 +210026,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 {
@@ -210779,7 +210947,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 {
           }
@@ -210793,7 +210961,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;
       }
@@ -211029,14 +211197,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;
@@ -212698,7 +212862,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;
               }
@@ -213085,7 +213249,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;
@@ -213155,7 +213319,7 @@ var init_self_healing = __esm({
             }
             if (entries.length === 0) continue;
             for (const entry of entries) {
-              const path14 = join73(tempRoot, entry);
+              const path14 = join74(tempRoot, entry);
               let canonicalPath = path14;
               let cleanupReason = "stale";
               try {
@@ -213393,8 +213557,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));
@@ -213445,10 +213609,10 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
   if (!attachments || attachments.length === 0) {
     return { attachmentContents, imageContents };
   }
-  const { readFile: readFile63 } = await import("node:fs/promises");
-  const { join: join155 } = await import("node:path");
+  const { readFile: readFile64 } = await import("node:fs/promises");
+  const { join: join156 } = await import("node:path");
   for (const att of attachments) {
-    const filePath = join155(
+    const filePath = join156(
       rootDir,
       ".fusion",
       "tasks",
@@ -213458,7 +213622,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
     );
     try {
       if (IMAGE_MIME_TYPES.has(att.mimeType)) {
-        const data = await readFile63(filePath);
+        const data = await readFile64(filePath);
         const detectedMimeType = detectImageMimeFromBytes(data);
         const imageMimeType2 = detectedMimeType ?? att.mimeType;
         if (detectedMimeType && detectedMimeType !== att.mimeType) {
@@ -213475,7 +213639,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
           text: null
         });
       } else {
-        const data = await readFile63(filePath, "utf-8");
+        const data = await readFile64(filePath, "utf-8");
         const text3 = data.length > TEXT_INLINE_LIMIT ? data.slice(0, TEXT_INLINE_LIMIT) + "\n... (truncated at 50KB)" : data;
         attachmentContents.push({
           originalName: att.originalName,
@@ -213716,6 +213880,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();
@@ -214272,8 +214437,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 "";
@@ -214311,8 +214476,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 "";
@@ -214476,8 +214641,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);
             }
@@ -214688,7 +214853,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 () => {
@@ -215024,8 +215189,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);
@@ -215642,7 +215821,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 });
             }
@@ -215653,7 +215832,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,
@@ -215694,7 +215873,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,
@@ -215759,7 +215938,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");
@@ -215771,6 +215950,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: [],
@@ -216017,10 +216200,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);
 }
@@ -216046,7 +216229,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 {
@@ -216064,7 +216247,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" };
     }
@@ -216213,16 +216396,16 @@ async function persistBranchState(persistence, state) {
     );
   }
 }
-function resolveJoinConfig(join155) {
-  const rawMode = join155.config?.mode;
+function resolveJoinConfig(join156) {
+  const rawMode = join156.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 '${join155.id}' quorum must be a positive integer`);
+    else throw new WorkflowIrError(`join '${join156.id}' quorum must be a positive integer`);
   }
-  const rawFail = join155.config?.onBranchFailure;
+  const rawFail = join156.config?.onBranchFailure;
   const onBranchFailure = rawFail === "collect" ? "collect" : "fail-fast";
   return { mode, onBranchFailure };
 }
@@ -216238,9 +216421,9 @@ async function runSplitJoin(split, env) {
   if (branchEdges.length === 0) {
     throw new WorkflowIrError(`split '${split.id}' has no traversable branches`);
   }
-  const join155 = findMatchingJoin(branchEdges[0].to, env);
-  if (!join155) throw new WorkflowIrError(`split '${split.id}' has no reachable matching join`);
-  const joinConfig = resolveJoinConfig(env.nodeMap.get(join155));
+  const join156 = findMatchingJoin(branchEdges[0].to, env);
+  if (!join156) throw new WorkflowIrError(`split '${split.id}' has no reachable matching join`);
+  const joinConfig = resolveJoinConfig(env.nodeMap.get(join156));
   const controller = new AbortController();
   const branchCount = branchEdges.length;
   const required2 = requiredCompletions(joinConfig.mode, branchCount);
@@ -216276,7 +216459,7 @@ async function runSplitJoin(split, env) {
   };
   const branchPromises = branchEdges.map((edge) => {
     const branchId = edge.to;
-    return walkBranch(branchId, join155, env, controller.signal, visitedNodeIds).then((result2) => {
+    return walkBranch(branchId, join156, env, controller.signal, visitedNodeIds).then((result2) => {
       branchOutcomes.push({ branchId, outcome: result2.outcome, nodeId: result2.lastNodeId });
       if (result2.outcome === "success") succeeded += 1;
       else failed += 1;
@@ -216294,7 +216477,7 @@ async function runSplitJoin(split, env) {
   });
   const outcome = await joinReached;
   await Promise.allSettled(branchPromises);
-  return { joinNodeId: join155, outcome, branchOutcomes, visitedNodeIds };
+  return { joinNodeId: join156, outcome, branchOutcomes, visitedNodeIds };
 }
 async function walkBranch(startNodeId, joinId, env, signal, visitedNodeIds) {
   let currentId = startNodeId;
@@ -219710,7 +219893,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, `'\\''`)}'`;
 }
@@ -219782,8 +219965,8 @@ exit 0
 async function writeSessionHookScripts(opts) {
   const { sessionId, token, endpointUrl, dir: dir2 } = opts;
   await mkdir28(dir2, { recursive: true, mode: 448 });
-  const hookScriptPath = join76(dir2, HOOK_SCRIPT_NAMES.hook);
-  const notifyScriptPath = join76(dir2, HOOK_SCRIPT_NAMES.notify);
+  const hookScriptPath = join77(dir2, HOOK_SCRIPT_NAMES.hook);
+  const notifyScriptPath = join77(dir2, HOOK_SCRIPT_NAMES.notify);
   await writeFile29(hookScriptPath, buildHookScriptContent({ sessionId, token, endpointUrl }), {
     mode: 448
   });
@@ -219942,7 +220125,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);
 }
@@ -220008,9 +220191,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)
@@ -220252,7 +220435,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 platform6 = process.platform === "darwin" ? "darwin" : process.platform === "linux" ? "linux" : process.platform === "win32" ? "win32" : "unknown";
   const arch = process.arch === "arm64" ? "arm64" : process.arch === "x64" ? "x64" : "unknown";
@@ -220262,12 +220445,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;
@@ -220278,14 +220461,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;
@@ -220308,8 +220491,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 {
@@ -220339,7 +220522,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: {} };
@@ -221878,7 +222061,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 = [];
@@ -221993,7 +222176,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;
@@ -222008,7 +222191,7 @@ function findWorkspacePackageDir(rootDir, packageName) {
   while (queue2.length > 0) {
     const current = queue2.shift();
     if (!current) break;
-    const abs = join79(rootDir, current.dir);
+    const abs = join80(rootDir, current.dir);
     let entries;
     try {
       entries = readdirSync11(abs, { withFileTypes: true });
@@ -222018,9 +222201,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;
@@ -222040,7 +222223,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;
@@ -222297,7 +222480,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;
       }
@@ -222330,7 +222513,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.`;
@@ -222675,9 +222858,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) {
@@ -222691,7 +222874,7 @@ function isWorkflowStepSkillDiscoverable(skillName, additionalSkillPaths, ceSkil
     return false;
   }
   return (additionalSkillPaths ?? []).some(
-    (skillPath) => basename19(skillPath) === bareSkillName2 && existsSync65(join80(skillPath, "SKILL.md")) || existsSync65(join80(skillPath, bareSkillName2, "SKILL.md"))
+    (skillPath) => basename19(skillPath) === bareSkillName2 && existsSync65(join81(skillPath, "SKILL.md")) || existsSync65(join81(skillPath, bareSkillName2, "SKILL.md"))
   );
 }
 function getPromptSection(prompt, heading) {
@@ -223000,7 +223183,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();
@@ -226448,7 +226631,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 } : {}
             });
@@ -230908,7 +231091,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) {
@@ -234769,10 +234952,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, retry2) {
-        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;
@@ -241311,7 +241494,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, {
@@ -241342,7 +241525,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");
@@ -241374,7 +241557,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 {
     }
@@ -241397,7 +241580,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);
@@ -241820,7 +242003,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,
@@ -241892,7 +242075,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 {
     }
@@ -241905,7 +242088,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;
 }
@@ -242239,7 +242422,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;
@@ -242735,7 +242918,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(
@@ -243052,7 +243235,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);
@@ -243359,7 +243542,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, `'\\''`)}'`;
@@ -243809,7 +243992,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" };
@@ -243876,7 +244059,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 });
@@ -244001,7 +244184,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 });
@@ -244342,7 +244525,7 @@ async function readOptionalTextFile(filePath) {
 }
 async function discoverMcpServers(opts) {
   const homeDir = opts.homeDir ?? process.env.HOME ?? process.env.USERPROFILE ?? osHomedir();
-  const readFile63 = opts.readFile ?? readOptionalTextFile;
+  const readFile64 = opts.readFile ?? readOptionalTextFile;
   const sources = getMcpDiscoverySources({
     homeDir,
     platform: osPlatform(),
@@ -244353,7 +244536,7 @@ async function discoverMcpServers(opts) {
   for (const source of sources) {
     let contents;
     try {
-      contents = await readFile63(source.path);
+      contents = await readFile64(source.path);
     } catch (error3) {
       errors.push(`${source.label}: ${error3 instanceof Error ? error3.message : String(error3)}`);
       continue;
@@ -244903,7 +245086,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({
@@ -245462,7 +245645,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());
             }
@@ -247570,7 +247753,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(path14) {
   try {
@@ -247599,7 +247782,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;
@@ -247607,9 +247790,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 parent2 = dirname34(current);
@@ -255912,7 +256095,7 @@ __export(child_process_runtime_exports, {
 import { EventEmitter as EventEmitter29 } 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"() {
@@ -256074,7 +256257,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.
@@ -262341,7 +262524,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);
@@ -262351,10 +262534,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 {
@@ -262364,7 +262547,7 @@ async function ensureLockTargetExists(lockPath) {
   }
 }
 async function acquireLockfile(workingDir, onCompromised) {
-  const dir2 = join86(workingDir, ".fusion");
+  const dir2 = join87(workingDir, ".fusion");
   mkdirSync12(dir2, { recursive: true });
   const path14 = computeEngineLockFilePath(workingDir);
   await ensureLockTargetExists(path14);
@@ -272048,8 +272231,8 @@ var init_project_store_resolver = __esm({
 
 // ../dashboard/src/plugin-routes.ts
 import { Router } from "express";
-import { access as access11, stat as stat10, readFile as readFile40 } from "node:fs/promises";
-import { join as join87, isAbsolute as isAbsolute22, dirname as dirname36, basename as basename21 } from "node:path";
+import { access as access11, stat as stat10, readFile as readFile41 } from "node:fs/promises";
+import { join as join88, isAbsolute as isAbsolute22, dirname as dirname36, basename as basename21 } from "node:path";
 function isPluginRouteResponse(result2) {
   if (!result2 || typeof result2 !== "object" || Array.isArray(result2)) {
     return false;
@@ -272062,7 +272245,7 @@ async function loadRegistryManifest() {
     return cachedRegistryManifest;
   }
   try {
-    const raw = await readFile40(registryManifestUrl, "utf-8");
+    const raw = await readFile41(registryManifestUrl, "utf-8");
     cachedRegistryManifest = JSON.parse(raw);
     return cachedRegistryManifest;
   } catch (error3) {
@@ -272159,7 +272342,7 @@ async function resolvePluginManifest(sourcePath) {
   if (!sourceStat.isDirectory()) {
     throw badRequest(`Path is not a directory: ${sourcePath}`);
   }
-  const directManifestPath = join87(sourcePath, "manifest.json");
+  const directManifestPath = join88(sourcePath, "manifest.json");
   try {
     await access11(directManifestPath);
     const manifest = await readAndValidateManifest(directManifestPath);
@@ -272170,7 +272353,7 @@ async function resolvePluginManifest(sourcePath) {
   const dirName = basename21(sourcePath).toLowerCase();
   if (DIST_DIR_NAMES.has(dirName)) {
     const parentDir = dirname36(sourcePath);
-    const parentManifestPath = join87(parentDir, "manifest.json");
+    const parentManifestPath = join88(parentDir, "manifest.json");
     try {
       await access11(parentManifestPath);
       const manifest = await readAndValidateManifest(parentManifestPath);
@@ -272186,7 +272369,7 @@ async function resolvePluginManifest(sourcePath) {
 async function readAndValidateManifest(manifestPath) {
   let content;
   try {
-    content = await readFile40(manifestPath, "utf-8");
+    content = await readFile41(manifestPath, "utf-8");
   } catch (err) {
     throw badRequest(`Cannot read manifest at ${manifestPath}: ${err.message}`);
   }
@@ -273255,7 +273438,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 join88 } from "node:path";
+import { join as join89 } from "node:path";
 import { promisify as promisify65 } from "node:util";
 function resolveCommentAuthor(input) {
   const login = input.login || "unknown";
@@ -274501,8 +274684,8 @@ var init_github = __esm({
               { timeout: 3e4, maxBuffer: 10 * 1024 * 1024 }
             );
             const mergeBase = mergeBaseStdout.trim();
-            const indexDir = await mkdtemp6(join88(tmpdir13(), "fn-pr-conflict-"));
-            const indexPath = join88(indexDir, "index");
+            const indexDir = await mkdtemp6(join89(tmpdir13(), "fn-pr-conflict-"));
+            const indexPath = join89(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)}`, {
@@ -276717,7 +276900,7 @@ var init_github = __esm({
 });
 
 // ../dashboard/src/artifact-media.ts
-import { readFile as readFile41 } from "node:fs/promises";
+import { readFile as readFile42 } from "node:fs/promises";
 import { resolve as resolve41, sep as sep13 } from "node:path";
 function resolveArtifactMediaPath(scopedStore, artifact) {
   if (!artifact.uri) return null;
@@ -276733,7 +276916,7 @@ function resolveArtifactMediaPath(scopedStore, artifact) {
 async function readArtifactMediaBytes(scopedStore, artifact) {
   const mediaPath = resolveArtifactMediaPath(scopedStore, artifact);
   if (!mediaPath) throw badRequest("Artifact has no stored media");
-  return readFile41(mediaPath);
+  return readFile42(mediaPath);
 }
 var init_artifact_media = __esm({
   "../dashboard/src/artifact-media.ts"() {
@@ -279758,8 +279941,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 access12, readFile as readFile42 } from "node:fs/promises";
-import { join as join89 } from "node:path";
+import { access as access12, readFile as readFile43 } from "node:fs/promises";
+import { join as join90 } from "node:path";
 function buildFallbackPrMetadata(task) {
   return {
     title: task.title ?? task.id,
@@ -279959,14 +280142,14 @@ async function generatePrMetadata(input) {
     ]), combinedSignal);
     let promptContent = "";
     try {
-      const promptPath = join89(repoRoot, ".fusion", "tasks", task.id, "PROMPT.md");
-      promptContent = (await raceWithAbort(readFile42(promptPath, "utf8"), combinedSignal)).trim();
+      const promptPath = join90(repoRoot, ".fusion", "tasks", task.id, "PROMPT.md");
+      promptContent = (await raceWithAbort(readFile43(promptPath, "utf8"), combinedSignal)).trim();
     } catch {
       promptContent = "";
     }
-    const templatePath = join89(repoRoot, ".github", "pull_request_template.md");
+    const templatePath = join90(repoRoot, ".github", "pull_request_template.md");
     const templateExists = await raceWithAbort(access12(templatePath).then(() => true).catch(() => false), combinedSignal);
-    const template = templateExists ? await raceWithAbort(readFile42(templatePath, "utf8"), combinedSignal) : "";
+    const template = templateExists ? await raceWithAbort(readFile43(templatePath, "utf8"), combinedSignal) : "";
     const model = resolveTitleSummarizerSettingsModel(settings);
     const systemPrompt = [PR_METADATA_SYSTEM_PROMPT];
     const titleGuidance = settings.prTitlePromptInstructions?.trim();
@@ -280151,8 +280334,8 @@ var init_resolve_diff_base = __esm({
 });
 
 // ../dashboard/src/pr-conflict-resolver.ts
-import { access as access13, mkdir as mkdir29, readFile as readFile43, rm as rm16 } from "node:fs/promises";
-import { join as join90, resolve as resolve43 } from "node:path";
+import { access as access13, mkdir as mkdir29, readFile as readFile44, rm as rm16 } from "node:fs/promises";
+import { join as join91, resolve as resolve43 } from "node:path";
 function asSessionPluginRunner(runner) {
   if (!runner) return void 0;
   if (typeof runner.getRuntimeById === "function") {
@@ -280201,7 +280384,7 @@ async function findFilesWithConflictMarkers2(rootDir, files) {
   const conflicted = [];
   for (const file of files) {
     try {
-      const contents = await readFile43(join90(rootDir, file), "utf8");
+      const contents = await readFile44(join91(rootDir, file), "utf8");
       if (/^<<<<<<< /m.test(contents) || /^=======$/m.test(contents) || /^>>>>>>> /m.test(contents)) {
         conflicted.push(file);
       }
@@ -280286,11 +280469,11 @@ async function resolvePrConflicts(input) {
   const task = await store.getTask(taskId);
   const branchName = getHeadBranch(taskId);
   const reusableWorktree = await resolveUsableWorktree(task.worktree, branchName);
-  const tempWorktreePath = join90(rootDir, ".fusion", "worktrees", `conflict-${taskId.toLowerCase()}`);
+  const tempWorktreePath = join91(rootDir, ".fusion", "worktrees", `conflict-${taskId.toLowerCase()}`);
   const cwd = reusableWorktree ?? tempWorktreePath;
   const createdTemporaryWorktree = !reusableWorktree;
   if (createdTemporaryWorktree) {
-    await mkdir29(join90(rootDir, ".fusion", "worktrees"), { recursive: true });
+    await mkdir29(join91(rootDir, ".fusion", "worktrees"), { recursive: true });
     await rm16(tempWorktreePath, { recursive: true, force: true });
     await runGitCommand2(["worktree", "add", "--force", tempWorktreePath, branchName], rootDir, GIT_TIMEOUT_MS10);
   }
@@ -288118,7 +288301,7 @@ var init_auth_middleware = __esm({
 // ../dashboard/src/routes/register-task-workflow-routes.ts
 import { createReadStream } from "node:fs";
 import { stat as stat11 } from "node:fs/promises";
-import { join as join91 } from "node:path";
+import { join as join92 } from "node:path";
 async function clearRebuiltSpecWorkflowPins(store, taskId) {
   const maybeStore = store;
   try {
@@ -289301,13 +289484,16 @@ ${normalizedDescription}`;
       const existing = await scopedStore.getTask(req.params.id);
       const rootDir = scopedStore.getRootDir();
       const allocateWorktree = existing ? (task2, reservedNames) => planTaskWorktreePath(task2, rootDir, settings.worktreeNaming, reservedNames, settings) : void 0;
-      const result2 = await promoteHeldTask(scopedStore, req.params.id, { allocateWorktree });
+      const force = req.body?.force === true;
+      const result2 = await promoteHeldTask(scopedStore, req.params.id, { allocateWorktree }, { force });
       if (!result2.released) {
         if (result2.rejection === "unplanned-for-execution") {
           throw new ApiError(409, "Task is not ready for execution (plan review or planning still outstanding)", {
             code: "unplanned-for-execution",
             messageKey: "board.rejection.unplannedForExecution",
-            retryable: true
+            retryable: true,
+            // Tells the board this rejection has an operator override available.
+            forceable: true
           });
         }
         if (result2.rejection === "capacity-exhausted-or-no-slot") {
@@ -289449,14 +289635,14 @@ ${normalizedDescription}`;
             }
             const cleanupPreparedBranches = async () => {
               for (const repoBranch of prepared.repos) {
-                const repoRootDir = join91(rootDir, repoBranch.repo);
+                const repoRootDir = join92(rootDir, repoBranch.repo);
                 await runGitCommand3(["checkout", repoBranch.integrationBranch], repoRootDir, 1e4).catch(() => void 0);
                 await runGitCommand3(["branch", "-D", revertBranch], repoRootDir, 1e4).catch(() => void 0);
               }
             };
             const targets = [];
             for (const repoBranch of prepared.repos) {
-              const gitRepo = getCurrentRepo(join91(rootDir, repoBranch.repo));
+              const gitRepo = getCurrentRepo(join92(rootDir, repoBranch.repo));
               if (!gitRepo) {
                 await cleanupPreparedBranches();
                 res.json({
@@ -289499,7 +289685,7 @@ ${normalizedDescription}`;
                 resultRepos.push({ repo: target.repoBranch.repo, revertBranch, prUrl: prInfo2.url, prNumber: prInfo2.number, existingPr: true });
                 continue;
               }
-              await runGitCommand3(["push", "-u", "origin", revertBranch], join91(rootDir, target.repoBranch.repo), 6e4);
+              await runGitCommand3(["push", "-u", "origin", revertBranch], join92(rootDir, target.repoBranch.repo), 6e4);
               const prTitle = `revert(${task.id}): undo landed work (${target.repoBranch.repo})`;
               const prBody = `This PR reverts the work landed by task ${task.id} in sub-repo \`${target.repoBranch.repo}\`.
 
@@ -289813,8 +289999,8 @@ See \`GET /api/tasks/${task.id}/diff\` for the landed diff being reverted.
       });
       if (retrySpecification) {
         const { rm: rm23 } = await import("node:fs/promises");
-        const { join: join155 } = await import("node:path");
-        const promptPath = join155(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+        const { join: join156 } = await import("node:path");
+        const promptPath = join156(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
         await rm23(promptPath, { force: true });
         await scopedStore.logEntry(req.params.id, "Retry requested from dashboard (planning retry budget reset)");
         const updated2 = await scopedStore.getTask(req.params.id);
@@ -290526,10 +290712,10 @@ See \`GET /api/tasks/${task.id}/diff\` for the landed diff being reverted.
       await scopedStore.logEntry(task.id, "Plan approved by user");
       let approvedPlanFingerprint;
       try {
-        const { readFile: readFile63 } = await import("node:fs/promises");
-        const { join: join155 } = await import("node:path");
-        const promptPath = join155(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
-        const promptText2 = await readFile63(promptPath, "utf8");
+        const { readFile: readFile64 } = await import("node:fs/promises");
+        const { join: join156 } = await import("node:path");
+        const promptPath = join156(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+        const promptText2 = await readFile64(promptPath, "utf8");
         approvedPlanFingerprint = computePlanApprovalFingerprint(promptText2);
       } catch {
       }
@@ -290562,8 +290748,8 @@ See \`GET /api/tasks/${task.id}/diff\` for the landed diff being reverted.
       await scopedStore.logEntry(task.id, "Plan rejected by user", "Specification will be regenerated");
       await scopedStore.updateTask(task.id, { status: void 0, approvedPlanFingerprint: null });
       const { rm: rm23 } = await import("node:fs/promises");
-      const { join: join155 } = await import("node:path");
-      const promptPath = join155(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+      const { join: join156 } = await import("node:path");
+      const promptPath = join156(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
       await rm23(promptPath, { force: true });
       const updated = await scopedStore.getTask(task.id);
       res.json(updated);
@@ -290586,7 +290772,7 @@ See \`GET /api/tasks/${task.id}/diff\` for the landed diff being reverted.
   router.get("/tasks/:id/stranded-refinement", async (req, res) => {
     try {
       const { existsSync: existsSync118 } = await import("node:fs");
-      const { join: join155 } = await import("node:path");
+      const { join: join156 } = await import("node:path");
       const { store: scopedStore } = await getProjectContext2(req);
       const task = await scopedStore.getTask(req.params.id);
       if (task.sourceType !== "task_refine") {
@@ -290602,7 +290788,7 @@ See \`GET /api/tasks/${task.id}/diff\` for the landed diff being reverted.
         nextRecoveryAt: task.nextRecoveryAt,
         ageMs: Math.max(0, Date.now() - Date.parse(task.createdAt))
       };
-      const promptPath = join155(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+      const promptPath = join156(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
       const promptExists = existsSync118(promptPath);
       const dependencyDetails = await Promise.all((task.dependencies ?? []).map(async (dependencyId) => {
         try {
@@ -291221,8 +291407,8 @@ See \`GET /api/tasks/${task.id}/diff\` for the landed diff being reverted.
       if (task.column === "triage" || task.column === respecifyTarget) {
         await scopedStore.logEntry(task.id, "AI spec revision requested", feedback);
         const { rm: rm24 } = await import("node:fs/promises");
-        const { join: join156 } = await import("node:path");
-        const promptPath2 = join156(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+        const { join: join157 } = await import("node:path");
+        const promptPath2 = join157(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
         await rm24(promptPath2, { force: true });
         await scopedStore.updateTask(task.id, { status: "needs-replan" });
         const updated2 = await scopedStore.getTask(task.id);
@@ -291238,8 +291424,8 @@ See \`GET /api/tasks/${task.id}/diff\` for the landed diff being reverted.
       await scopedStore.logEntry(task.id, "AI spec revision requested", feedback);
       const updated = await scopedStore.moveTask(task.id, respecifyTarget);
       const { rm: rm23 } = await import("node:fs/promises");
-      const { join: join155 } = await import("node:path");
-      const promptPath = join155(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+      const { join: join156 } = await import("node:path");
+      const promptPath = join156(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
       await rm23(promptPath, { force: true });
       await scopedStore.updateTask(task.id, { status: "needs-replan" });
       res.json(updated);
@@ -291272,8 +291458,8 @@ See \`GET /api/tasks/${task.id}/diff\` for the landed diff being reverted.
         });
       }
       const { rm: rm23 } = await import("node:fs/promises");
-      const { join: join155 } = await import("node:path");
-      const promptPath = join155(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+      const { join: join156 } = await import("node:path");
+      const promptPath = join156(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
       await rm23(promptPath, { force: true });
       await scopedStore.updateTask(task.id, { status: "needs-replan" });
       const updated = await scopedStore.getTask(task.id);
@@ -291659,7 +291845,7 @@ See \`GET /api/tasks/${task.id}/diff\` for the landed diff being reverted.
       const task = await scopedStore.updateTask(req.params.id, updates);
       if (dismissNearDuplicate === true && task.sourceMetadata?.duplicateSource === "triage-marker") {
         const { rm: rm23 } = await import("node:fs/promises");
-        await rm23(join91(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+        await rm23(join92(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
       }
       const manualUnlinkRequested = hasBodyField("githubTracking") && validatedGithubTracking !== null && typeof validatedGithubTracking === "object" && validatedGithubTracking.issue === null;
       const disableRequested = hasBodyField("githubTracking") && validatedGithubTracking !== null && typeof validatedGithubTracking === "object" && validatedGithubTracking.enabled === false;
@@ -294524,7 +294710,7 @@ var init_chat_attachment_config = __esm({
 });
 
 // ../dashboard/src/chat-attachment-content.ts
-import { readFile as readFile44 } from "node:fs/promises";
+import { readFile as readFile45 } from "node:fs/promises";
 import { basename as basename22, resolve as resolve46 } from "node:path";
 function getAttachmentDirectory(rootDir, scope) {
   if (scope.kind === "session") {
@@ -294570,7 +294756,7 @@ async function readChatAttachmentContents(rootDir, scope, attachments, diagnosti
     const filePath = resolve46(attachmentDir, safeName);
     try {
       if (IMAGE_MIME_TYPES2.has(attachment.mimeType)) {
-        const data2 = await readFile44(filePath);
+        const data2 = await readFile45(filePath);
         const detectedMimeType = detectImageMimeFromBytes(data2);
         const imageMimeType2 = detectedMimeType ?? attachment.mimeType;
         if (detectedMimeType && detectedMimeType !== attachment.mimeType) {
@@ -294594,7 +294780,7 @@ async function readChatAttachmentContents(rootDir, scope, attachments, diagnosti
         diagnostics9?.warn(`Skipping non-inlineable chat attachment '${attachment.filename}' (${attachment.mimeType}) for ${getScopeLabel(scope)}`);
         continue;
       }
-      const data = await readFile44(filePath, "utf-8");
+      const data = await readFile45(filePath, "utf-8");
       const text3 = data.length > CHAT_TEXT_INLINE_LIMIT ? `${data.slice(0, CHAT_TEXT_INLINE_LIMIT)}${TRUNCATION_SUFFIX}` : data;
       attachmentContents.push({
         originalName: attachment.originalName,
@@ -295253,7 +295439,7 @@ __export(chat_exports, {
 import { EventEmitter as EventEmitter40 } from "node:events";
 import { randomUUID as randomUUID53 } from "node:crypto";
 import { existsSync as existsSync70 } from "node:fs";
-import { join as join92, resolve as resolve47, relative as relative20 } from "node:path";
+import { join as join93, resolve as resolve47, relative as relative20 } from "node:path";
 import { SessionManager as SessionManager3 } from "@earendil-works/pi-coding-agent";
 function __getChatDiagnostics() {
   return _diagnostics;
@@ -295788,7 +295974,7 @@ function validateFilePath(basePath, filePath) {
     throw new Error(`Access denied: Absolute paths not allowed`);
   }
   const resolvedBase = resolve47(basePath);
-  const resolvedPath = resolve47(join92(resolvedBase, decodedPath));
+  const resolvedPath = resolve47(join93(resolvedBase, decodedPath));
   const relativePath = relative20(resolvedBase, resolvedPath);
   if (relativePath.startsWith("..") || relativePath.startsWith("../") || relativePath === "..") {
     throw new Error(`Access denied: Path traversal detected`);
@@ -297583,7 +297769,7 @@ var init_rate_limit = __esm({
 import { randomUUID as randomUUID54 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
 import { mkdir as mkdir30, rm as rm17, writeFile as writeFile33 } from "node:fs/promises";
-import { basename as basename23, join as join93, resolve as resolve48 } from "node:path";
+import { basename as basename23, join as join94, resolve as resolve48 } from "node:path";
 function resolveAttachmentPath(rootDir, sessionId, filename) {
   const sessionDir = resolve48(rootDir, ".fusion", "chat-attachments", sessionId);
   const safeName = basename23(filename);
@@ -297636,7 +297822,7 @@ function registerChatRoutes(ctx, deps) {
     await mkdir30(sessionDir, { recursive: true });
     const sanitizedFilename = (file.originalname || "attachment").replace(/[^a-zA-Z0-9._-]/g, "_");
     const filename = `${Date.now()}-${sanitizedFilename}`;
-    const filePath = join93(sessionDir, filename);
+    const filePath = join94(sessionDir, filename);
     await writeFile33(filePath, file.buffer);
     return {
       id: `att-${randomUUID54().slice(0, 8)}`,
@@ -298408,7 +298594,7 @@ var init_register_chat_routes = __esm({
 import { randomUUID as randomUUID55 } from "node:crypto";
 import { createReadStream as createReadStream3 } from "node:fs";
 import { mkdir as mkdir31, writeFile as writeFile34 } from "node:fs/promises";
-import { basename as basename24, join as join94, resolve as resolve49 } from "node:path";
+import { basename as basename24, join as join95, resolve as resolve49 } from "node:path";
 function isSlugCollisionError(err) {
   const message = err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
   return message.includes("slug") || message.includes("exists");
@@ -298743,7 +298929,7 @@ function registerChatRoomRoutes(ctx, deps) {
       await mkdir31(roomDir, { recursive: true });
       const sanitizedFilename = (file.originalname || "attachment").replace(/[^a-zA-Z0-9._-]/g, "_");
       const filename = `${Date.now()}-${sanitizedFilename}`;
-      const filePath = join94(roomDir, filename);
+      const filePath = join95(roomDir, filename);
       await writeFile34(filePath, file.buffer);
       const attachment = {
         id: `att-${randomUUID55().slice(0, 8)}`,
@@ -307323,7 +307509,7 @@ var init_terminal = __esm({
 });
 
 // ../dashboard/src/file-service.ts
-import { join as join95, resolve as resolve52, relative as relative21, dirname as dirname38, basename as basename26 } from "node:path";
+import { join as join96, resolve as resolve52, relative as relative21, dirname as dirname38, basename as basename26 } from "node:path";
 import { readdir as readdir10, readFile as fsReadFile2, writeFile as fsWriteFile, stat as stat13, copyFile as fsCopyFile, rename as fsRename, rm as fsRm, mkdir as mkdir33, access as access14 } from "node:fs/promises";
 async function getTaskBasePath(store, taskId) {
   try {
@@ -307336,7 +307522,7 @@ async function getTaskBasePath(store, taskId) {
       }
     }
     const rootDir = store.getRootDir();
-    return resolve52(join95(rootDir, ".fusion", "tasks", taskId));
+    return resolve52(join96(rootDir, ".fusion", "tasks", taskId));
   } catch (err) {
     const error3 = err;
     if (error3.code === "ENOENT" || error3.message && error3.message.includes("not found")) {
@@ -307368,7 +307554,7 @@ function validatePath(basePath, filePath, options = {}) {
     throw new FileServiceError(`Access denied: Absolute paths not allowed`, "EINVAL");
   }
   const resolvedBase = resolve52(basePath);
-  const resolvedPath = resolve52(join95(resolvedBase, filePath));
+  const resolvedPath = resolve52(join96(resolvedBase, filePath));
   const relativePath = relative21(resolvedBase, resolvedPath);
   if (relativePath.startsWith("..") || relativePath.startsWith("../") || relativePath === "..") {
     throw new FileServiceError(`Access denied: Path traversal detected`, "EINVAL");
@@ -307409,7 +307595,7 @@ async function listFilesForBasePath(basePath, subPath, options = {}) {
     const entries = await readdir10(targetPath, { withFileTypes: true });
     const fileNodes = [];
     for (const entry of entries) {
-      const entryPath = join95(targetPath, entry.name);
+      const entryPath = join96(targetPath, entry.name);
       const entryStats = await stat13(entryPath);
       fileNodes.push({
         name: entry.name,
@@ -307535,7 +307721,7 @@ async function listFiles2(store, taskId, subPath) {
   const taskBase = await getTaskBasePath(store, taskId);
   return listFilesForBasePath(taskBase, subPath);
 }
-async function readFile45(store, taskId, filePath) {
+async function readFile46(store, taskId, filePath) {
   const taskBase = await getTaskBasePath(store, taskId);
   return readFileForBasePath(taskBase, filePath);
 }
@@ -307790,7 +307976,7 @@ async function renameWorkspaceFile(store, workspace, filePath, newName) {
     }
     throw err;
   }
-  const destPath = join95(dirname38(resolvedPath), newName);
+  const destPath = join96(dirname38(resolvedPath), newName);
   if (pathOptions.allowAbsolutePaths !== true || !filePath.startsWith("/")) {
     const destRelative = relative21(resolve52(workspaceBase), destPath);
     if (destRelative.startsWith("..") || destRelative.startsWith("../") || destRelative === "..") {
@@ -307887,7 +308073,7 @@ function isHiddenPathSegment(name2) {
   return name2.startsWith(".");
 }
 async function walkDirForMarkdown(basePath, currentRelative, results, options) {
-  const currentPath = currentRelative ? join95(basePath, currentRelative) : basePath;
+  const currentPath = currentRelative ? join96(basePath, currentRelative) : basePath;
   let entries;
   try {
     entries = await readdir10(currentPath, { withFileTypes: true });
@@ -307895,7 +308081,7 @@ async function walkDirForMarkdown(basePath, currentRelative, results, options) {
     return;
   }
   for (const entry of entries) {
-    const entryRelativePath = currentRelative ? join95(currentRelative, entry.name) : entry.name;
+    const entryRelativePath = currentRelative ? join96(currentRelative, entry.name) : entry.name;
     if (entry.isDirectory()) {
       if (MARKDOWN_SCAN_EXCLUDED_DIRS.has(entry.name)) {
         continue;
@@ -307912,7 +308098,7 @@ async function walkDirForMarkdown(basePath, currentRelative, results, options) {
     if (!options.showHidden && isHiddenPathSegment(entry.name)) {
       continue;
     }
-    const fullPath = join95(basePath, entryRelativePath);
+    const fullPath = join96(basePath, entryRelativePath);
     let fileStats;
     try {
       fileStats = await stat13(fullPath);
@@ -307962,7 +308148,7 @@ async function scanMarkdownFiles(store, options) {
       return;
     }
     for (const entry of entries) {
-      const entryRelativePath = relativeDir ? join95(relativeDir, entry.name) : entry.name;
+      const entryRelativePath = relativeDir ? join96(relativeDir, entry.name) : entry.name;
       let shouldRecurse = entry.isDirectory();
       if (!shouldRecurse && typeof entry.isSymbolicLink === "function" && entry.isSymbolicLink()) {
         let symlinkPath;
@@ -308052,8 +308238,8 @@ async function searchWorkspaceFiles(store, workspace, query) {
       if (entry.isDirectory() && EXCLUDED_DIRS.has(entry.name)) {
         continue;
       }
-      const fullPath = join95(dir2, entry.name);
-      const relPath = join95(relativeDir, entry.name);
+      const fullPath = join96(dir2, entry.name);
+      const relPath = join96(relativeDir, entry.name);
       if (entry.isFile()) {
         if (entry.name.toLowerCase().includes(lowerQuery)) {
           results.push({
@@ -308074,8 +308260,8 @@ async function copyDirectoryRecursive(source, destination) {
   await mkdir33(destination, { recursive: true });
   const entries = await readdir10(source, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join95(source, entry.name);
-    const destPath = join95(destination, entry.name);
+    const sourcePath = join96(source, entry.name);
+    const destPath = join96(destination, entry.name);
     if (entry.isDirectory()) {
       await copyDirectoryRecursive(sourcePath, destPath);
     } else {
@@ -311364,7 +311550,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join155(s3) {
+      BufferList.prototype.join = function join156(s3) {
         if (this.length === 0) return "";
         var p2 = this.head;
         var ret = "" + p2.data;
@@ -332924,7 +333110,7 @@ function registerFileWorkspaceRoutes(ctx) {
     try {
       const { store: scopedStore } = await getProjectContext2(req);
       const filePath = Array.isArray(req.params.filepath) ? req.params.filepath[0] : req.params.filepath ?? "";
-      const result2 = await readFile45(scopedStore, req.params.id, filePath);
+      const result2 = await readFile46(scopedStore, req.params.id, filePath);
       res.json(result2);
     } catch (err) {
       if (err instanceof ApiError) {
@@ -333393,7 +333579,7 @@ var init_attribute_done_range_files = __esm({
 
 // ../dashboard/src/routes/register-session-diff-routes.ts
 import { access as access16 } from "node:fs/promises";
-import { join as join96 } from "node:path";
+import { join as join97 } from "node:path";
 async function worktreeStillBelongsToTask(worktree, expectedBranch) {
   if (!expectedBranch) return true;
   try {
@@ -333711,7 +333897,7 @@ async function computeWorkspaceTaskFiles(task, rootDir, timeoutMs) {
       }
     }
     if (repoFiles.length === 0 && entry.baseCommitSha && entry.landedSha) {
-      const repoRootDir = join96(rootDir, repoRel);
+      const repoRootDir = join97(rootDir, repoRel);
       try {
         const rangeFiles = await collectDoneRangeFiles(`${entry.baseCommitSha}..${entry.landedSha}`, repoRootDir);
         repoFiles = rangeFiles.map((file) => ({
@@ -334658,7 +334844,7 @@ var init_exec_file = __esm({
 
 // ../dashboard/src/lib/codebase-metrics.ts
 import { spawn as spawn12 } from "node:child_process";
-import { lstat as lstat2, readdir as readdir11, readFile as readFile46, realpath as realpath2 } from "node:fs/promises";
+import { lstat as lstat2, readdir as readdir11, readFile as readFile47, realpath as realpath2 } from "node:fs/promises";
 import { basename as basename27, resolve as resolve53, sep as sep14 } from "node:path";
 function countPreTokenPieces(text3) {
   let pieces = 0;
@@ -334808,7 +334994,7 @@ async function computeCodebaseMetrics(rootDir, options = {}) {
       truncated = true;
       break;
     }
-    const contents = await readFile46(candidate);
+    const contents = await readFile47(candidate);
     if (isBinary(contents)) continue;
     sourceByteCount += contents.length;
     sourceFileCount++;
@@ -334875,7 +335061,7 @@ var init_codebase_metrics = __esm({
 
 // ../dashboard/src/routes/register-project-routes.ts
 import * as fsPromises from "node:fs/promises";
-import { dirname as dirname39, isAbsolute as isAbsolute26, join as join97 } from "node:path";
+import { dirname as dirname39, isAbsolute as isAbsolute26, join as join98 } from "node:path";
 var access17, stat14, mkdir34, readdir12, rm18, registerProjectRoutes;
 var init_register_project_routes = __esm({
   "../dashboard/src/routes/register-project-routes.ts"() {
@@ -335149,7 +335335,7 @@ var init_register_project_routes = __esm({
             }
           }
           let hasFusionDir = false;
-          const fusionDirPath = join97(normalizedPath, ".fusion");
+          const fusionDirPath = join98(normalizedPath, ".fusion");
           try {
             await access17(fusionDirPath);
             hasFusionDir = true;
@@ -335264,9 +335450,9 @@ var init_register_project_routes = __esm({
             const entries = await readdir12(searchPath, { withFileTypes: true });
             for (const entry of entries) {
               if (!entry.isDirectory()) continue;
-              const dirPath = join97(searchPath, entry.name);
-              const fusionDir = join97(dirPath, ".fusion");
-              if (readProjectIdentity(fusionDir) !== null || isValidSqliteDatabaseFile(join97(fusionDir, "fusion.db"))) {
+              const dirPath = join98(searchPath, entry.name);
+              const fusionDir = join98(dirPath, ".fusion");
+              if (readProjectIdentity(fusionDir) !== null || isValidSqliteDatabaseFile(join98(fusionDir, "fusion.db"))) {
                 detected.push({
                   path: dirPath,
                   suggestedName: entry.name,
@@ -342633,7 +342819,7 @@ var init_register_secrets_sync_inbound_routes = __esm({
 });
 
 // ../dashboard/src/routes/register-agent-core-routes.ts
-import { mkdir as mkdir35, readdir as readdir13, readFile as readFile47, rm as rm19, writeFile as writeFile36 } from "node:fs/promises";
+import { mkdir as mkdir35, readdir as readdir13, readFile as readFile48, rm as rm19, writeFile as writeFile36 } from "node:fs/promises";
 import path8 from "node:path";
 function parsePermissionsInput(input) {
   if (typeof input !== "object" || input === null || Array.isArray(input)) {
@@ -343068,7 +343254,7 @@ function registerAgentCoreRoutes(ctx, deps) {
       if (!mimeType) {
         throw notFound("Avatar not found");
       }
-      const fileBuffer = await readFile47(path8.join(agentDir, avatarFile));
+      const fileBuffer = await readFile48(path8.join(agentDir, avatarFile));
       res.setHeader("Content-Type", mimeType);
       res.setHeader("Cache-Control", "public, max-age=3600");
       res.send(fileBuffer);
@@ -345723,7 +345909,7 @@ Rules:
 import { createWriteStream } from "node:fs";
 import * as fsPromises2 from "node:fs/promises";
 import { tmpdir as tmpdir14 } from "node:os";
-import { join as join98, resolve as resolve54 } from "node:path";
+import { join as join99, resolve as resolve54 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline as streamPipeline } from "node:stream/promises";
 function registerAgentImportExportRoutes(ctx) {
@@ -345764,7 +345950,7 @@ function registerAgentImportExportRoutes(ctx) {
       } else if (typeof outputDir === "string") {
         throw badRequest("outputDir cannot be empty");
       } else {
-        resolvedOutputDir = await mkdtemp7(join98(tmpdir14(), "fusion-agent-export-"));
+        resolvedOutputDir = await mkdtemp7(join99(tmpdir14(), "fusion-agent-export-"));
       }
       const result2 = await exportAgentsToDirectory2(agentsToExport, resolvedOutputDir, {
         companyName: typeof companyName === "string" ? companyName : void 0,
@@ -345923,7 +346109,7 @@ ${body}`;
       return result2;
     }
     const safeCompanySlug = companySlug ? slugifyPathSegment2(companySlug, "unknown-company") : "unknown-company";
-    const skillsBaseDir = join98(projectRoot, "skills", "imported", safeCompanySlug);
+    const skillsBaseDir = join99(projectRoot, "skills", "imported", safeCompanySlug);
     const usedSlugs = /* @__PURE__ */ new Set();
     for (const skill of skills) {
       const name2 = typeof skill.name === "string" && skill.name.trim().length > 0 ? skill.name.trim() : null;
@@ -345940,8 +346126,8 @@ ${body}`;
         skillSlug = `${skillSlug}-${counter2}`;
       }
       usedSlugs.add(skillSlug);
-      const skillDir = join98(skillsBaseDir, skillSlug);
-      const skillPath = join98(skillDir, "SKILL.md");
+      const skillDir = join99(skillsBaseDir, skillSlug);
+      const skillPath = join99(skillDir, "SKILL.md");
       try {
         await access18(skillPath);
         result2.skipped.push(name2);
@@ -346115,8 +346301,8 @@ ${body}`;
         const archiveUrl = `https://github.com/${repoOwner}/${repoName}/archive/refs/heads/${preferredBranch}.tar.gz`;
         let tempDir = null;
         try {
-          tempDir = await mkdtemp7(join98(tmpdir14(), `fn-agent-import-${importCompanySlug}-`));
-          const archivePath = join98(tempDir, "archive.tar.gz");
+          tempDir = await mkdtemp7(join99(tmpdir14(), `fn-agent-import-${importCompanySlug}-`));
+          const archivePath = join99(tempDir, "archive.tar.gz");
           const downloadController = new AbortController();
           const downloadTimeout = setTimeout(() => downloadController.abort(), 3e4);
           let archiveResponse;
@@ -347755,12 +347941,12 @@ import {
   unlinkSync as unlinkSync4
 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
-import { basename as basename29, dirname as dirname40, join as join99, resolve as resolve55 } from "node:path";
+import { basename as basename29, dirname as dirname40, join as join100, resolve as resolve55 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function resolveHermesHome(profile) {
-  const base = process.env.HERMES_HOME ?? join99(homedir14(), ".hermes");
+  const base = process.env.HERMES_HOME ?? join100(homedir14(), ".hermes");
   if (!profile || profile === "default") return base;
-  return join99(base, "profiles", profile);
+  return join100(base, "profiles", profile);
 }
 function getFusionSkillSourceCandidates(moduleUrl = import.meta.url) {
   const here = fileURLToPath6(moduleUrl);
@@ -347775,13 +347961,13 @@ function getFusionSkillSourceCandidates(moduleUrl = import.meta.url) {
 function resolveBundledFusionSkillSource() {
   const candidates = getFusionSkillSourceCandidates();
   for (const candidate of candidates) {
-    if (existsSync72(join99(candidate, "SKILL.md"))) return candidate;
+    if (existsSync72(join100(candidate, "SKILL.md"))) return candidate;
   }
   return null;
 }
 function installFusionSkillIntoHermesHome(options = {}) {
   const sourceDir = options.sourceDir ?? resolveBundledFusionSkillSource();
-  const targetDir = join99(resolveHermesHome(options.profile), "skills", FUSION_SKILL_NAME);
+  const targetDir = join100(resolveHermesHome(options.profile), "skills", FUSION_SKILL_NAME);
   if (!sourceDir) {
     return {
       outcome: "warning",
@@ -347870,7 +348056,7 @@ function isBrokenSymlink(path14) {
   }
 }
 function looksLikePriorFusionInstall(path14) {
-  const skillMd = join99(path14, "SKILL.md");
+  const skillMd = join100(path14, "SKILL.md");
   if (!existsSync72(skillMd)) return false;
   try {
     const body = readFileSync28(skillMd, "utf-8");
@@ -347882,7 +348068,7 @@ function looksLikePriorFusionInstall(path14) {
 function looksLikeFusionSkillTarget(path14) {
   if (!path14) return false;
   if (basename29(path14).toLowerCase() === FUSION_SKILL_NAME) return true;
-  return existsSync72(join99(path14, "SKILL.md"));
+  return existsSync72(join100(path14, "SKILL.md"));
 }
 var FUSION_SKILL_NAME;
 var init_fusion_skill_install = __esm({
@@ -348150,7 +348336,7 @@ var init_src8 = __esm({
 // ../../plugins/fusion-plugin-openclaw-runtime/src/pi-module.ts
 import { spawn as spawn15 } from "node:child_process";
 import { randomUUID as randomUUID60 } from "node:crypto";
-import { readFile as readFile48 } from "node:fs/promises";
+import { readFile as readFile49 } from "node:fs/promises";
 function asString2(v2) {
   return typeof v2 === "string" && v2.trim() !== "" ? v2.trim() : void 0;
 }
@@ -348221,7 +348407,7 @@ function createCliSession(opts) {
   };
 }
 async function configureOpenClawMcpServer(opts) {
-  const serverValue = await readFile48(opts.serverConfigPath, "utf-8");
+  const serverValue = await readFile49(opts.serverConfigPath, "utf-8");
   await new Promise((resolve103, reject2) => {
     const child = spawn15(opts.binaryPath, ["--no-color", "--profile", opts.profile, "mcp", "set", opts.serverName, serverValue], {
       stdio: ["ignore", "pipe", "pipe"]
@@ -348365,7 +348551,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 tmpdir15 } from "node:os";
-import { join as join100 } from "node:path";
+import { join as join101 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 import { dirname as dirname41 } from "node:path";
 function toolsToMcpToolDefs(tools) {
@@ -348378,16 +348564,16 @@ function toolsToMcpToolDefs(tools) {
 }
 function writeOpenClawMcpBridgeFiles(toolDefs, cacheKey) {
   const suffix = cacheKey ? `${process.pid}-${cacheKey}` : `${process.pid}`;
-  const schemaPath = join100(tmpdir15(), `openclaw-runtime-mcp-schemas-${suffix}.json`);
+  const schemaPath = join101(tmpdir15(), `openclaw-runtime-mcp-schemas-${suffix}.json`);
   writeFileSync13(schemaPath, JSON.stringify(toolDefs));
   const __filename = fileURLToPath7(import.meta.url);
   const __dirname3 = dirname41(__filename);
-  const serverPath = join100(__dirname3, "mcp-schema-server.cjs");
+  const serverPath = join101(__dirname3, "mcp-schema-server.cjs");
   const serverConfig = {
     command: "node",
     args: [serverPath, schemaPath]
   };
-  const serverConfigPath = join100(tmpdir15(), `openclaw-runtime-mcp-server-${suffix}.json`);
+  const serverConfigPath = join101(tmpdir15(), `openclaw-runtime-mcp-server-${suffix}.json`);
   writeFileSync13(serverConfigPath, JSON.stringify(serverConfig));
   return {
     schemaPath,
@@ -348619,7 +348805,7 @@ var init_src9 = __esm({
 });
 
 // ../dashboard/src/routes/plugin-bundled-runtimes.ts
-import { resolve as resolve56, join as join101 } from "node:path";
+import { resolve as resolve56, join as join102 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 import * as nodeFs from "node:fs";
 function extractBundledPluginId(pathInput) {
@@ -348638,12 +348824,12 @@ function resolveBundledPluginDirInDashboard(pluginId) {
   const moduleDir = resolve56(fileURLToPath8(import.meta.url), "..");
   const dashboardPackageRoot = resolve56(moduleDir, "..");
   const candidates = [
-    join101(dashboardPackageRoot, "dist", "plugins", pluginId),
-    join101(dashboardPackageRoot, "plugins", pluginId),
-    join101(dashboardPackageRoot, "..", "..", "plugins", pluginId)
+    join102(dashboardPackageRoot, "dist", "plugins", pluginId),
+    join102(dashboardPackageRoot, "plugins", pluginId),
+    join102(dashboardPackageRoot, "..", "..", "plugins", pluginId)
   ];
   for (const candidate of candidates) {
-    if (nodeFs.existsSync(join101(candidate, "manifest.json"))) {
+    if (nodeFs.existsSync(join102(candidate, "manifest.json"))) {
       return candidate;
     }
   }
@@ -350735,9 +350921,9 @@ var init_cli_spawn3 = __esm({
 });
 
 // ../../plugins/fusion-plugin-grok-runtime/src/probe.ts
-import { readFile as readFile49 } from "node:fs/promises";
+import { readFile as readFile50 } from "node:fs/promises";
 import { homedir as homedir15 } from "node:os";
-import { join as join102 } from "node:path";
+import { join as join103 } from "node:path";
 function buildCandidates2(binaryPath) {
   const configuredBinaryPath = binaryPath?.trim() || void 0;
   const ordered = configuredBinaryPath ? [configuredBinaryPath, ...CANDIDATES3] : [...CANDIDATES3];
@@ -350754,10 +350940,10 @@ async function probeGrokApiKeyPresence() {
   if (typeof envKey === "string" && envKey.trim().length > 0) {
     return { detected: true };
   }
-  const settingsPath = join102(homedir15(), ".grok", "user-settings.json");
+  const settingsPath = join103(homedir15(), ".grok", "user-settings.json");
   let raw;
   try {
-    raw = await readFile49(settingsPath, "utf-8");
+    raw = await readFile50(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." };
   }
@@ -350906,7 +351092,7 @@ var init_provider2 = __esm({
 
 // ../../plugins/fusion-plugin-grok-runtime/src/acp/cli-spawn.ts
 import { existsSync as existsSync74 } from "node:fs";
-import { dirname as dirname42, isAbsolute as isAbsolute28, join as join103, resolve as resolve58 } from "node:path";
+import { dirname as dirname42, isAbsolute as isAbsolute28, join as join104, resolve as resolve58 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 function asTrimmedString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
@@ -350924,7 +351110,7 @@ function pluginRootDir() {
 }
 function bundledClaudeBridgeBinPath(pluginRoot = pluginRootDir()) {
   const extension = process.platform === "win32" ? ".cmd" : "";
-  return join103(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY}${extension}`);
+  return join104(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY}${extension}`);
 }
 function resolveBundledClaudeBridgeBinary(options = {}) {
   const root = options.pluginRoot ?? pluginRootDir();
@@ -352287,10 +352473,10 @@ import {
 } from "node:fs";
 import { createRequire as createRequire8 } from "node:module";
 import { tmpdir as tmpdir16 } from "node:os";
-import { basename as basename31, dirname as dirname44, join as join105, resolve as resolve60 } from "node:path";
+import { basename as basename31, dirname as dirname44, join as join106, resolve as resolve60 } from "node:path";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
 function isSkillDir(dir2) {
-  return existsSync75(join105(dir2, "SKILL.md"));
+  return existsSync75(join106(dir2, "SKILL.md"));
 }
 function pushUnique(out, candidate) {
   if (!candidate) return;
@@ -352298,8 +352484,8 @@ function pushUnique(out, candidate) {
   if (!out.includes(resolved)) out.push(resolved);
 }
 function pushSkillLayoutsAtRoot(out, root) {
-  pushUnique(out, join105(root, "skill", FUSION_SKILL_NAME2));
-  pushUnique(out, join105(root, "packages", "cli", "skill", FUSION_SKILL_NAME2));
+  pushUnique(out, join106(root, "skill", FUSION_SKILL_NAME2));
+  pushUnique(out, join106(root, "packages", "cli", "skill", FUSION_SKILL_NAME2));
 }
 function walkAncestorSkillCandidates(out, startDir, maxParents = 8) {
   let dir2 = startDir;
@@ -352314,7 +352500,7 @@ function pushPackageRequireCandidates(out, from) {
   try {
     const require6 = createRequire8(from);
     const pkgJson = require6.resolve("@runfusion/fusion/package.json");
-    pushUnique(out, join105(dirname44(pkgJson), "skill", FUSION_SKILL_NAME2));
+    pushUnique(out, join106(dirname44(pkgJson), "skill", FUSION_SKILL_NAME2));
   } catch {
   }
 }
@@ -352382,21 +352568,21 @@ function collectSkillsFromRoot(root, out) {
     return;
   }
   for (const entry of entries) {
-    const child = join105(root, entry);
+    const child = join106(root, entry);
     if (isSkillDir(child)) {
       out.set(entry, child);
     }
   }
 }
 function stageGrokSessionSkills(options = {}) {
-  const pluginDir = mkdtempSync3(join105(tmpdir16(), "fusion-grok-plugin-"));
-  const skillsDir = join105(pluginDir, "skills");
+  const pluginDir = mkdtempSync3(join106(tmpdir16(), "fusion-grok-plugin-"));
+  const skillsDir = join106(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, join105(skillsDir, FUSION_SKILL_NAME2))) {
+    if (fusionSource && installSkillDir(fusionSource, join106(skillsDir, FUSION_SKILL_NAME2))) {
       installed.set(FUSION_SKILL_NAME2, fusionSource);
     }
   }
@@ -352406,15 +352592,15 @@ function stageGrokSessionSkills(options = {}) {
   }
   for (const [name2, source] of installed) {
     if (name2 === FUSION_SKILL_NAME2 && includeFusion) continue;
-    installSkillDir(source, join105(skillsDir, name2));
+    installSkillDir(source, join106(skillsDir, name2));
   }
   for (const [name2, source] of installed) {
-    if (!existsSync75(join105(skillsDir, name2))) {
-      installSkillDir(source, join105(skillsDir, name2));
+    if (!existsSync75(join106(skillsDir, name2))) {
+      installSkillDir(source, join106(skillsDir, name2));
     }
   }
   writeFileSync14(
-    join105(pluginDir, "plugin.json"),
+    join106(pluginDir, "plugin.json"),
     JSON.stringify(
       {
         name: "fusion-session-skills",
@@ -352480,7 +352666,7 @@ var init_skill_loader = __esm({
 import { createServer as createServer2 } from "node:http";
 import { existsSync as existsSync76, writeFileSync as writeFileSync15 } from "node:fs";
 import { tmpdir as tmpdir17 } from "node:os";
-import { dirname as dirname45, join as join106 } from "node:path";
+import { dirname as dirname45, join as join107 } from "node:path";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 import { randomUUID as randomUUID62 } from "node:crypto";
 function toolsToMcpToolDefs2(tools) {
@@ -352492,7 +352678,7 @@ function toolsToMcpToolDefs2(tools) {
   }));
 }
 function fusionToolsMcpServerPath() {
-  return join106(dirname45(fileURLToPath11(import.meta.url)), "mcp-schema-server.cjs");
+  return join107(dirname45(fileURLToPath11(import.meta.url)), "mcp-schema-server.cjs");
 }
 function missingMcpSchemaServerError(serverPath) {
   const error3 = new Error(`Fusion MCP schema server is missing: ${serverPath}`);
@@ -352533,7 +352719,7 @@ async function startFusionToolBridge(tools) {
       byName.set(tool.name, tool);
     }
   }
-  const schemaPath = join106(tmpdir17(), `fusion-grok-mcp-schemas-${process.pid}-${randomUUID62()}.json`);
+  const schemaPath = join107(tmpdir17(), `fusion-grok-mcp-schemas-${process.pid}-${randomUUID62()}.json`);
   writeFileSync15(schemaPath, JSON.stringify(defs));
   const server = createServer2(async (req, res) => {
     if (req.method !== "POST" || req.url !== "/tool-call") {
@@ -352966,7 +353152,7 @@ var init_src11 = __esm({
 
 // ../../plugins/fusion-plugin-claude-runtime/src/acp/cli-spawn.ts
 import { existsSync as existsSync77 } from "node:fs";
-import { dirname as dirname46, isAbsolute as isAbsolute29, join as join107, resolve as resolve61 } from "node:path";
+import { dirname as dirname46, isAbsolute as isAbsolute29, join as join108, resolve as resolve61 } from "node:path";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
 function asTrimmedString2(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
@@ -352984,7 +353170,7 @@ function pluginRootDir2() {
 }
 function bundledClaudeBridgeBinPath2(pluginRoot = pluginRootDir2()) {
   const extension = process.platform === "win32" ? ".cmd" : "";
-  return join107(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY2}${extension}`);
+  return join108(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY2}${extension}`);
 }
 function resolveBundledClaudeBridgeBinary2(options = {}) {
   const root = options.pluginRoot ?? pluginRootDir2();
@@ -354224,14 +354410,14 @@ var init_acp2 = __esm({
 // ../../plugins/fusion-plugin-claude-runtime/src/cli-spawn.ts
 import { spawn as spawn21 } from "node:child_process";
 import { existsSync as existsSync78 } from "node:fs";
-import { basename as basename33, dirname as dirname48, isAbsolute as isAbsolute30, join as join109, resolve as resolve63 } from "node:path";
+import { basename as basename33, dirname as dirname48, isAbsolute as isAbsolute30, join as join110, resolve as resolve63 } from "node:path";
 import { fileURLToPath as fileURLToPath13 } from "node:url";
 function pluginRootDir3() {
   const moduleDir = dirname48(fileURLToPath13(import.meta.url));
   return ["src", "dist"].includes(basename33(moduleDir)) ? resolve63(moduleDir, "..") : moduleDir;
 }
 function bundledClaudeBridgeBinPath3(pluginRoot = pluginRootDir3()) {
-  return join109(pluginRoot, "bridge", `${CLAUDE_CODE_CLI_ACP_BINARY3}${process.platform === "win32" ? ".cmd" : ""}`);
+  return join110(pluginRoot, "bridge", `${CLAUDE_CODE_CLI_ACP_BINARY3}${process.platform === "win32" ? ".cmd" : ""}`);
 }
 function resolveBundledClaudeBridgeBinary3(options = {}) {
   const candidate = bundledClaudeBridgeBinPath3(options.pluginRoot ?? pluginRootDir3());
@@ -354408,10 +354594,10 @@ import {
 } from "node:fs";
 import { createRequire as createRequire9 } from "node:module";
 import { tmpdir as tmpdir18 } from "node:os";
-import { basename as basename34, dirname as dirname49, join as join110, resolve as resolve64 } from "node:path";
+import { basename as basename34, dirname as dirname49, join as join111, resolve as resolve64 } from "node:path";
 import { fileURLToPath as fileURLToPath14 } from "node:url";
 function isSkillDir2(dir2) {
-  return existsSync79(join110(dir2, "SKILL.md"));
+  return existsSync79(join111(dir2, "SKILL.md"));
 }
 function pushUnique2(out, candidate) {
   if (!candidate) return;
@@ -354419,8 +354605,8 @@ function pushUnique2(out, candidate) {
   if (!out.includes(resolved)) out.push(resolved);
 }
 function pushSkillLayoutsAtRoot2(out, root) {
-  pushUnique2(out, join110(root, "skill", FUSION_SKILL_NAME3));
-  pushUnique2(out, join110(root, "packages", "cli", "skill", FUSION_SKILL_NAME3));
+  pushUnique2(out, join111(root, "skill", FUSION_SKILL_NAME3));
+  pushUnique2(out, join111(root, "packages", "cli", "skill", FUSION_SKILL_NAME3));
 }
 function walkAncestorSkillCandidates2(out, startDir, maxParents = 8) {
   let dir2 = startDir;
@@ -354435,7 +354621,7 @@ function pushPackageRequireCandidates2(out, from) {
   try {
     const require6 = createRequire9(from);
     const pkgJson = require6.resolve("@runfusion/fusion/package.json");
-    pushUnique2(out, join110(dirname49(pkgJson), "skill", FUSION_SKILL_NAME3));
+    pushUnique2(out, join111(dirname49(pkgJson), "skill", FUSION_SKILL_NAME3));
   } catch {
   }
 }
@@ -354503,21 +354689,21 @@ function collectSkillsFromRoot2(root, out) {
     return;
   }
   for (const entry of entries) {
-    const child = join110(root, entry);
+    const child = join111(root, entry);
     if (isSkillDir2(child)) {
       out.set(entry, child);
     }
   }
 }
 function stageClaudeSessionSkills(options = {}) {
-  const pluginDir = mkdtempSync4(join110(tmpdir18(), "fusion-claude-plugin-"));
-  const skillsDir = join110(pluginDir, "skills");
+  const pluginDir = mkdtempSync4(join111(tmpdir18(), "fusion-claude-plugin-"));
+  const skillsDir = join111(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, join110(skillsDir, FUSION_SKILL_NAME3))) {
+    if (fusionSource && installSkillDir2(fusionSource, join111(skillsDir, FUSION_SKILL_NAME3))) {
       installed.set(FUSION_SKILL_NAME3, fusionSource);
     }
   }
@@ -354527,15 +354713,15 @@ function stageClaudeSessionSkills(options = {}) {
   }
   for (const [name2, source] of installed) {
     if (name2 === FUSION_SKILL_NAME3 && includeFusion) continue;
-    installSkillDir2(source, join110(skillsDir, name2));
+    installSkillDir2(source, join111(skillsDir, name2));
   }
   for (const [name2, source] of installed) {
-    if (!existsSync79(join110(skillsDir, name2))) {
-      installSkillDir2(source, join110(skillsDir, name2));
+    if (!existsSync79(join111(skillsDir, name2))) {
+      installSkillDir2(source, join111(skillsDir, name2));
     }
   }
   writeFileSync16(
-    join110(pluginDir, "plugin.json"),
+    join111(pluginDir, "plugin.json"),
     JSON.stringify(
       {
         name: "fusion-session-skills",
@@ -354601,7 +354787,7 @@ var init_skill_loader2 = __esm({
 import { createServer as createServer3 } from "node:http";
 import { existsSync as existsSync80, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
 import { tmpdir as tmpdir19 } from "node:os";
-import { dirname as dirname50, join as join111 } from "node:path";
+import { dirname as dirname50, join as join112 } from "node:path";
 import { fileURLToPath as fileURLToPath15 } from "node:url";
 import { randomBytes as randomBytes8, randomUUID as randomUUID63 } from "node:crypto";
 function toolsToMcpToolDefs3(tools) {
@@ -354613,7 +354799,7 @@ function toolsToMcpToolDefs3(tools) {
   }));
 }
 function fusionToolsMcpServerPath2() {
-  return join111(dirname50(fileURLToPath15(import.meta.url)), "mcp-schema-server.cjs");
+  return join112(dirname50(fileURLToPath15(import.meta.url)), "mcp-schema-server.cjs");
 }
 function missingMcpSchemaServerError2(serverPath) {
   const error3 = new Error(`Fusion MCP schema server is missing: ${serverPath}`);
@@ -354654,7 +354840,7 @@ async function startFusionToolBridge2(tools, options = {}) {
       byName.set(tool.name, tool);
     }
   }
-  const schemaPath = join111(tmpdir19(), `fusion-claude-mcp-schemas-${process.pid}-${randomUUID63()}.json`);
+  const schemaPath = join112(tmpdir19(), `fusion-claude-mcp-schemas-${process.pid}-${randomUUID63()}.json`);
   writeFileSync17(schemaPath, JSON.stringify(defs));
   const capabilityToken = randomBytes8(32).toString("base64url");
   const server = createServer3(async (req, res) => {
@@ -355458,7 +355644,7 @@ var init_provider6 = __esm({
 
 // ../../plugins/fusion-plugin-omp-runtime/src/acp/cli-spawn.ts
 import { existsSync as existsSync81 } from "node:fs";
-import { dirname as dirname51, isAbsolute as isAbsolute31, join as join112, resolve as resolve65 } from "node:path";
+import { dirname as dirname51, isAbsolute as isAbsolute31, join as join113, resolve as resolve65 } from "node:path";
 import { fileURLToPath as fileURLToPath16 } from "node:url";
 function asTrimmedString3(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
@@ -355476,7 +355662,7 @@ function pluginRootDir4() {
 }
 function bundledClaudeBridgeBinPath4(pluginRoot = pluginRootDir4()) {
   const extension = process.platform === "win32" ? ".cmd" : "";
-  return join112(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY4}${extension}`);
+  return join113(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY4}${extension}`);
 }
 function resolveBundledClaudeBridgeBinary4(options = {}) {
   const root = options.pluginRoot ?? pluginRootDir4();
@@ -356794,7 +356980,7 @@ var init_mcp_forwarding3 = __esm({
 import { createServer as createServer4 } from "node:http";
 import { existsSync as existsSync82, unlinkSync as unlinkSync5, writeFileSync as writeFileSync18 } from "node:fs";
 import { tmpdir as tmpdir20 } from "node:os";
-import { dirname as dirname53, join as join114 } from "node:path";
+import { dirname as dirname53, join as join115 } from "node:path";
 import { fileURLToPath as fileURLToPath17 } from "node:url";
 import { randomUUID as randomUUID64 } from "node:crypto";
 function toolsToMcpToolDefs4(tools) {
@@ -356811,12 +356997,12 @@ function fusionToolsMcpServerPath3() {
   const here = dirname53(fileURLToPath17(import.meta.url));
   const candidates = [
     // Packaged CLI / same-dir as bundled.js or tool-bridge source.
-    join114(here, "mcp-schema-server.cjs"),
+    join115(here, "mcp-schema-server.cjs"),
     // Source layout when running from dist/ that still has ../src assets.
-    join114(here, "src", "mcp-schema-server.cjs"),
-    join114(here, "..", "src", "mcp-schema-server.cjs"),
+    join115(here, "src", "mcp-schema-server.cjs"),
+    join115(here, "..", "src", "mcp-schema-server.cjs"),
     // Monorepo plugin root relative to src/ or dist/plugins/.../bundled.js.
-    join114(here, "..", "mcp-schema-server.cjs")
+    join115(here, "..", "mcp-schema-server.cjs")
   ];
   for (const candidate of candidates) {
     if (existsSync82(candidate)) return candidate;
@@ -356853,7 +357039,7 @@ async function startFusionToolBridge3(tools) {
       byName.set(tool.name, tool);
     }
   }
-  const schemaPath = join114(tmpdir20(), `fusion-omp-mcp-schemas-${process.pid}-${randomUUID64()}.json`);
+  const schemaPath = join115(tmpdir20(), `fusion-omp-mcp-schemas-${process.pid}-${randomUUID64()}.json`);
   writeFileSync18(schemaPath, JSON.stringify(defs));
   const server = createServer4(async (req, res) => {
     if (req.method !== "POST" || req.url !== "/tool-call") {
@@ -358805,9 +358991,9 @@ var init_hermes_model_cache = __esm({
 });
 
 // ../dashboard/src/routes/register-model-routes.ts
-import { access as access19, readFile as readFile50 } from "node:fs/promises";
+import { access as access19, readFile as readFile51 } from "node:fs/promises";
 import { homedir as homedir16 } from "node:os";
-import { join as join115 } from "node:path";
+import { join as join116 } from "node:path";
 function isRawAnthropicApiKeyCredential(credential) {
   return Boolean(
     credential && typeof credential === "object" && credential.type === "api_key" && typeof credential.key === "string" && credential.key.length > 0
@@ -358848,14 +359034,14 @@ async function getConfiguredProviderNames(authStorage) {
   const providers = /* @__PURE__ */ new Set();
   addAuthStorageConfiguredProviders(authStorage, providers);
   const authPaths = [
-    join115(home, ".fusion", "agent", "auth.json"),
-    join115(home, ".pi", "agent", "auth.json"),
-    join115(home, ".pi", "auth.json")
+    join116(home, ".fusion", "agent", "auth.json"),
+    join116(home, ".pi", "agent", "auth.json"),
+    join116(home, ".pi", "auth.json")
   ];
   for (const authPath of authPaths) {
     try {
       await access19(authPath);
-      const parsed = JSON.parse(await readFile50(authPath, "utf-8"));
+      const parsed = JSON.parse(await readFile51(authPath, "utf-8"));
       for (const [key, credential] of Object.entries(parsed)) {
         if (key === ANTHROPIC_SUBSCRIPTION_PROVIDER_ID4) {
           providers.add(ANTHROPIC_PROVIDER_ID3);
@@ -358877,14 +359063,14 @@ async function getConfiguredProviderNames(authStorage) {
     providers.add(ANTHROPIC_PROVIDER_ID3);
   }
   const modelsPaths = [
-    join115(home, ".fusion", "agent", "models.json"),
-    join115(home, ".pi", "agent", "models.json"),
-    join115(home, ".pi", "models.json")
+    join116(home, ".fusion", "agent", "models.json"),
+    join116(home, ".pi", "agent", "models.json"),
+    join116(home, ".pi", "models.json")
   ];
   for (const modelsPath of modelsPaths) {
     try {
       await access19(modelsPath);
-      const parsed = JSON.parse(await readFile50(modelsPath, "utf-8"));
+      const parsed = JSON.parse(await readFile51(modelsPath, "utf-8"));
       const provs = parsed?.providers;
       if (provs) {
         for (const [providerId, config3] of Object.entries(provs)) {
@@ -359634,7 +359820,7 @@ var init_register_custom_provider_routes = __esm({
 // ../dashboard/src/usage.ts
 import * as os11 from "node:os";
 import * as path13 from "node:path";
-import { readFile as readFile51 } from "node:fs/promises";
+import { readFile as readFile52 } from "node:fs/promises";
 import * as https from "node:https";
 import * as child_process from "node:child_process";
 function getHomeDir6() {
@@ -359755,7 +359941,7 @@ function decodeJwtPayload(token) {
 }
 async function readAuthKeyFromFile(authPath, provider) {
   try {
-    const auth2 = JSON.parse(await readFile51(authPath, "utf-8"));
+    const auth2 = JSON.parse(await readFile52(authPath, "utf-8"));
     const entry = auth2?.[provider];
     if (entry && (entry.type === "api_key" || entry.type === "key") && entry.key) {
       return entry.key;
@@ -360173,7 +360359,7 @@ async function fetchClaudeUsage(authStorage) {
     ];
     for (const p2 of credPaths) {
       try {
-        creds = JSON.parse(await readFile51(p2, "utf-8"));
+        creds = JSON.parse(await readFile52(p2, "utf-8"));
         break;
       } catch {
       }
@@ -360366,7 +360552,7 @@ async function loadCodexCredential() {
   const authPath = path13.join(codexHome, "auth.json");
   let auth2 = null;
   try {
-    auth2 = JSON.parse(await readFile51(authPath, "utf-8"));
+    auth2 = JSON.parse(await readFile52(authPath, "utf-8"));
   } catch {
     auth2 = null;
   }
@@ -360486,7 +360672,7 @@ async function fetchGeminiUsage() {
   const oauthPath = path13.join(getHomeDir6(), ".gemini", "oauth_creds.json");
   let oauthCreds = null;
   try {
-    oauthCreds = JSON.parse(await readFile51(oauthPath, "utf-8"));
+    oauthCreds = JSON.parse(await readFile52(oauthPath, "utf-8"));
   } catch {
     usage.error = "No Gemini credentials \u2014 run 'gemini' to login";
     return usage;
@@ -360501,7 +360687,7 @@ async function fetchGeminiUsage() {
   }
   const settingsPath = path13.join(getHomeDir6(), ".gemini", "settings.json");
   try {
-    const settings = JSON.parse(await readFile51(settingsPath, "utf-8"));
+    const settings = JSON.parse(await readFile52(settingsPath, "utf-8"));
     const authType = settings?.security?.auth?.selectedType;
     if (authType === "api-key" || authType === "vertex-ai") {
       usage.status = "no-auth";
@@ -360689,7 +360875,7 @@ async function fetchMinimaxUsage(authStorage) {
 async function readGrokUserSettingsApiKey2() {
   try {
     const settingsPath = path13.join(getHomeDir6(), ".grok", "user-settings.json");
-    const raw = await readFile51(settingsPath, "utf-8");
+    const raw = await readFile52(settingsPath, "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed?.apiKey === "string" && parsed.apiKey.trim().length > 0 ? parsed.apiKey.trim() : null;
   } catch {
@@ -360698,7 +360884,7 @@ async function readGrokUserSettingsApiKey2() {
 }
 async function readGrokCliOidcToken() {
   try {
-    const raw = await readFile51(path13.join(getHomeDir6(), ".grok", "auth.json"), "utf-8");
+    const raw = await readFile52(path13.join(getHomeDir6(), ".grok", "auth.json"), "utf-8");
     const parsed = JSON.parse(raw);
     for (const entry of Object.values(parsed)) {
       if (entry && typeof entry.key === "string" && entry.key.trim().length > 0) {
@@ -363823,11 +364009,11 @@ var init_droid_cli_probe = __esm({
 });
 
 // ../dashboard/src/llama-cpp-probe.ts
-import { readFile as readFile52 } from "node:fs/promises";
-import { join as join117 } from "node:path";
+import { readFile as readFile53 } from "node:fs/promises";
+import { join as join118 } from "node:path";
 async function readJson(path14) {
   try {
-    const raw = await readFile52(path14, "utf-8");
+    const raw = await readFile53(path14, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -363837,18 +364023,18 @@ function normalizeUrl(url2) {
   return url2.trim().replace(/\/+$/, "");
 }
 async function resolveLlamaServerUrl(cwd) {
-  const projectCfg = await readJson(join117(cwd, ".pi", "llama-server.json"));
+  const projectCfg = await readJson(join118(cwd, ".pi", "llama-server.json"));
   if (projectCfg?.url) return normalizeUrl(projectCfg.url);
   const envUrl = process.env.LLAMA_SERVER_URL;
   if (envUrl) return normalizeUrl(envUrl);
   const globalCfg = await readJson(
-    join117(process.env.HOME ?? ".", ".pi", "agent", "settings.json")
+    join118(process.env.HOME ?? ".", ".pi", "agent", "settings.json")
   );
   if (globalCfg?.llamaServerUrl) return normalizeUrl(globalCfg.llamaServerUrl);
   return DEFAULT_LLAMA_SERVER_URL;
 }
 async function resolveLlamaServerApiKey() {
-  const authCfg = await readJson(join117(process.env.HOME ?? ".", ".pi", "agent", "auth.json"));
+  const authCfg = await readJson(join118(process.env.HOME ?? ".", ".pi", "agent", "auth.json"));
   const key = authCfg?.["llama-server"]?.key?.trim();
   return key ? key : void 0;
 }
@@ -363929,7 +364115,7 @@ var init_auth_provider_catalog = __esm({
 
 // ../dashboard/src/routes/register-auth-routes.ts
 import { tmpdir as tmpdir21 } from "node:os";
-import { join as join118 } from "node:path";
+import { join as join119 } from "node:path";
 import { existsSync as existsSync84, readFileSync as readFileSync29 } from "node:fs";
 function parseGitHubCopilotDeviceCode(instructions) {
   const match = instructions.match(/Enter code:\s*([A-Z0-9-]+)\b/i);
@@ -364594,7 +364780,7 @@ var init_register_auth_routes = __esm({
           let acpAuthFailed = false;
           let acpAuthReason;
           try {
-            const signalPath = join118(tmpdir21(), "fusion-acp-bridge-auth.json");
+            const signalPath = join119(tmpdir21(), "fusion-acp-bridge-auth.json");
             if (existsSync84(signalPath)) {
               const sig = JSON.parse(readFileSync29(signalPath, "utf8"));
               if (sig?.authFailed) {
@@ -365619,7 +365805,7 @@ var init_register_fn_binary_routes = __esm({
 import { exec as exec46 } from "node:child_process";
 import { readFileSync as readFileSync30, realpathSync as realpathSync14 } from "node:fs";
 import { mkdir as mkdir37, rm as rm21, writeFile as writeFile37 } from "node:fs/promises";
-import { join as join119 } from "node:path";
+import { join as join120 } from "node:path";
 import { promisify as promisify71 } from "node:util";
 function ttlForFrequency(frequency) {
   switch (frequency) {
@@ -365634,7 +365820,7 @@ function ttlForFrequency(frequency) {
   }
 }
 function getCachePath(fusionDir) {
-  return join119(fusionDir, CACHE_FILENAME);
+  return join120(fusionDir, CACHE_FILENAME);
 }
 function buildInstallCommand(version3, force = false) {
   if (!SAFE_VERSION_RE.test(version3)) {
@@ -365959,8 +366145,8 @@ var init_types6 = __esm({
 
 // ../dashboard/src/stt/model-manager.ts
 import { createHash as createHash27, randomUUID as randomUUID67 } from "node:crypto";
-import { mkdir as mkdir38, open as open4, readFile as readFile53, readdir as readdir14, rename as rename10, rm as rm22, stat as stat16, writeFile as writeFile38 } from "node:fs/promises";
-import { join as join120, relative as relative22, resolve as resolve67, sep as sep18 } from "node:path";
+import { mkdir as mkdir38, open as open4, readFile as readFile54, readdir as readdir14, rename as rename10, rm as rm22, stat as stat16, writeFile as writeFile38 } from "node:fs/promises";
+import { join as join121, relative as relative22, resolve as resolve67, sep as sep18 } from "node:path";
 function parseSafeTarListing(listing) {
   for (const line2 of listing.split("\n").filter(Boolean)) {
     const type = line2[0];
@@ -365975,8 +366161,8 @@ function parseSafeTarListing(listing) {
 function createVoiceModelManager(options = {}) {
   const asset = options.asset ?? PARAKEET_V3_ASSET;
   let configuredCacheDir = options.cacheDir;
-  const cacheDir = () => configuredCacheDir ??= join120(resolveGlobalDir(), "models", "parakeet-v3");
-  const finalDir = () => join120(cacheDir(), "model");
+  const cacheDir = () => configuredCacheDir ??= join121(resolveGlobalDir(), "models", "parakeet-v3");
+  const finalDir = () => join121(cacheDir(), "model");
   let state = { status: "not-installed" };
   let generation = 0;
   let cleanupBarrier = Promise.resolve();
@@ -366039,8 +366225,8 @@ function createVoiceModelManager(options = {}) {
       if (!current(g2, signal)) return state;
       await mkdir38(cacheDir(), { recursive: true });
       if (!current(g2, signal)) return state;
-      partial2 = join120(cacheDir(), `.partial-${g2}-${randomUUID67()}`);
-      staging = join120(cacheDir(), `.staging-${g2}-${randomUUID67()}`);
+      partial2 = join121(cacheDir(), `.partial-${g2}-${randomUUID67()}`);
+      staging = join121(cacheDir(), `.staging-${g2}-${randomUUID67()}`);
       const file = await open4(partial2, "wx");
       try {
         const response = await (options.fetch ?? globalThis.fetch)(asset.url, { signal });
@@ -366085,10 +366271,10 @@ function createVoiceModelManager(options = {}) {
         }
       }
       if (!current(g2, signal)) return state;
-      await writeFile38(join120(staging, "manifest.json"), JSON.stringify({ filename: asset.filename, sha256: asset.sha256, installedAt: (/* @__PURE__ */ new Date()).toISOString(), expectedFiles: asset.expectedFiles }));
+      await writeFile38(join121(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 = join120(cacheDir(), `.backup-${g2}-${randomUUID67()}`);
+      const backup = join121(cacheDir(), `.backup-${g2}-${randomUUID67()}`);
       let movedPrevious = false;
       try {
         try {
@@ -366168,9 +366354,9 @@ function createVoiceModelManager(options = {}) {
           publish(absent);
           return absent;
         }
-        const manifest = JSON.parse(await readFile53(join120(finalDir(), "manifest.json"), "utf8"));
+        const manifest = JSON.parse(await readFile54(join121(finalDir(), "manifest.json"), "utf8"));
         if (manifest.sha256 !== asset.sha256) throw new Error("stale manifest digest");
-        for (const expected of asset.expectedFiles) if (!await existsFile(join120(finalDir(), expected))) throw new Error("missing expected model file");
+        for (const expected of asset.expectedFiles) if (!await existsFile(join121(finalDir(), expected))) throw new Error("missing expected model file");
         const installed = { status: "installed", checksumVerified: true, installedPath: finalDir() };
         publish(installed);
         return installed;
@@ -366182,7 +366368,7 @@ function createVoiceModelManager(options = {}) {
         try {
           for (const entry of await readdir14(cacheDir())) {
             const own = /^\.(partial|staging|backup)-(\d+)-/.exec(entry);
-            if (own && Number(own[2]) !== active?.generation) await rm22(join120(cacheDir(), entry), { recursive: true, force: true });
+            if (own && Number(own[2]) !== active?.generation) await rm22(join121(cacheDir(), entry), { recursive: true, force: true });
           }
         } catch {
         }
@@ -366204,7 +366390,7 @@ function createVoiceModelManager(options = {}) {
         try {
           for (const entry of await readdir14(cacheDir())) {
             const match = /^\.(partial|staging|backup)-(\d+)-/.exec(entry);
-            if (match && Number(match[2]) <= g2) await rm22(join120(cacheDir(), entry), { recursive: true, force: true });
+            if (match && Number(match[2]) <= g2) await rm22(join121(cacheDir(), entry), { recursive: true, force: true });
           }
         } catch {
         }
@@ -366582,16 +366768,16 @@ import {
   unlinkSync as unlinkSync6
 } from "node:fs";
 import { homedir as homedir18 } from "node:os";
-import { dirname as dirname54, join as join121, resolve as resolve68 } from "node:path";
+import { dirname as dirname54, join as join122, resolve as resolve68 } from "node:path";
 function resolveFnBinaryLocalPaths(home = homedir18()) {
-  const installDir = join121(home, ".local", "share", "fusion");
-  const binDir = join121(home, ".local", "bin");
+  const installDir = join122(home, ".local", "share", "fusion");
+  const binDir = join122(home, ".local", "bin");
   return {
     installDir,
     binDir,
-    binaryPath: join121(installDir, "fn"),
-    fnShimPath: join121(binDir, "fn"),
-    fusionShimPath: join121(binDir, "fusion")
+    binaryPath: join122(installDir, "fn"),
+    fnShimPath: join122(binDir, "fn"),
+    fusionShimPath: join122(binDir, "fusion")
   };
 }
 function runStreamingCommand(command, args, options) {
@@ -366687,17 +366873,17 @@ function runStreamingCommand(command, args, options) {
 }
 function resolveBunExecutable() {
   if (process.env.BUN_INSTALL) {
-    const candidate = join121(process.env.BUN_INSTALL, "bin", process.platform === "win32" ? "bun.exe" : "bun");
+    const candidate = join122(process.env.BUN_INSTALL, "bin", process.platform === "win32" ? "bun.exe" : "bun");
     if (existsSync85(candidate)) return candidate;
   }
-  const homeBun = join121(homedir18(), ".bun", "bin", process.platform === "win32" ? "bun.exe" : "bun");
+  const homeBun = join122(homedir18(), ".bun", "bin", process.platform === "win32" ? "bun.exe" : "bun");
   if (existsSync85(homeBun)) return homeBun;
   return "bun";
 }
 function installLocalFnBinary(distDir, onLog, paths2 = resolveFnBinaryLocalPaths()) {
-  const srcBinary = join121(distDir, process.platform === "win32" ? "fn.exe" : "fn");
-  const srcClient = join121(distDir, "client");
-  const srcRuntime = join121(distDir, "runtime");
+  const srcBinary = join122(distDir, process.platform === "win32" ? "fn.exe" : "fn");
+  const srcClient = join122(distDir, "client");
+  const srcRuntime = join122(distDir, "runtime");
   if (!existsSync85(srcBinary)) {
     throw new Error(`Built binary missing at ${srcBinary}. Did the Bun compile step fail?`);
   }
@@ -366712,13 +366898,13 @@ function installLocalFnBinary(distDir, onLog, paths2 = resolveFnBinaryLocalPaths
     chmodSync4(paths2.binaryPath, 493);
   } catch {
   }
-  onLog("system", `Installing client assets \u2192 ${join121(paths2.installDir, "client")}`);
-  rmSync14(join121(paths2.installDir, "client"), { recursive: true, force: true });
-  cpSync5(srcClient, join121(paths2.installDir, "client"), { recursive: true });
+  onLog("system", `Installing client assets \u2192 ${join122(paths2.installDir, "client")}`);
+  rmSync14(join122(paths2.installDir, "client"), { recursive: true, force: true });
+  cpSync5(srcClient, join122(paths2.installDir, "client"), { recursive: true });
   if (existsSync85(srcRuntime)) {
-    onLog("system", `Installing runtime assets \u2192 ${join121(paths2.installDir, "runtime")}`);
-    rmSync14(join121(paths2.installDir, "runtime"), { recursive: true, force: true });
-    cpSync5(srcRuntime, join121(paths2.installDir, "runtime"), { recursive: true });
+    onLog("system", `Installing runtime assets \u2192 ${join122(paths2.installDir, "runtime")}`);
+    rmSync14(join122(paths2.installDir, "runtime"), { recursive: true, force: true });
+    cpSync5(srcRuntime, join122(paths2.installDir, "runtime"), { recursive: true });
   }
   for (const shim of [paths2.fnShimPath, paths2.fusionShimPath]) {
     try {
@@ -366773,9 +366959,9 @@ function removeLocalFnShims(onLog, paths2 = resolveFnBinaryLocalPaths()) {
   return { removed };
 }
 async function runLinkLocalFnBinary(sourceRoot, onLog) {
-  const buildScript = join121(sourceRoot, "scripts", "build-workspace.mjs");
-  const cliBuild = join121(sourceRoot, "packages", "cli", "build.ts");
-  const distDir = join121(sourceRoot, "packages", "cli", "dist");
+  const buildScript = join122(sourceRoot, "scripts", "build-workspace.mjs");
+  const cliBuild = join122(sourceRoot, "packages", "cli", "build.ts");
+  const distDir = join122(sourceRoot, "packages", "cli", "dist");
   if (!existsSync85(buildScript)) {
     return { success: false, error: `Build script missing: ${buildScript}` };
   }
@@ -366856,7 +367042,7 @@ var init_fn_binary_local_install = __esm({
 // ../dashboard/src/routes/register-system-routes.ts
 import { randomUUID as randomUUID69 } from "node:crypto";
 import { existsSync as existsSync86 } from "node:fs";
-import { join as join122 } from "node:path";
+import { join as join123 } from "node:path";
 function rejectCrossOrigin(req, res) {
   const origin = req.headers.origin;
   if (typeof origin !== "string" || origin.length === 0) return false;
@@ -367046,7 +367232,7 @@ function registerSystemRoutes(ctx, deps) {
     }
     const restartAfter = body.restart !== false && scope !== "plugins";
     const { args, label } = rebuildScopes[scope];
-    const scriptPath = join122(root, args[0]);
+    const scriptPath = join123(root, args[0]);
     if (!existsSync86(scriptPath)) {
       throw new ApiError(409, `Build script missing: ${scriptPath}`);
     }
@@ -372392,11 +372578,11 @@ var init_roadmap_routes3 = __esm({
 });
 
 // ../dashboard/src/dev-server-detect.ts
-import { glob, readFile as readFile54 } from "node:fs/promises";
-import { dirname as dirname55, join as join123, relative as relative23, resolve as resolve69 } from "node:path";
+import { glob, readFile as readFile55 } from "node:fs/promises";
+import { dirname as dirname55, join as join124, relative as relative23, resolve as resolve69 } from "node:path";
 async function readPackageJson(filePath) {
   try {
-    const raw = await readFile54(filePath, "utf-8");
+    const raw = await readFile55(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -372436,7 +372622,7 @@ function scoreCandidate(scriptName, pkg) {
 async function collectWorkspacePackageJsons(projectRoot) {
   const discovered = /* @__PURE__ */ new Set();
   try {
-    await readFile54(join123(projectRoot, "pnpm-workspace.yaml"), "utf-8");
+    await readFile55(join124(projectRoot, "pnpm-workspace.yaml"), "utf-8");
   } catch {
   }
   for (const pattern of ["packages/*/package.json", "apps/*/package.json"]) {
@@ -372470,7 +372656,7 @@ function toSource(projectRoot, packageJsonPath) {
 async function detectDevServerScripts(projectRoot) {
   const root = resolve69(projectRoot);
   const candidates = [];
-  const rootPackagePath = join123(root, "package.json");
+  const rootPackagePath = join124(root, "package.json");
   const rootPackage = await readPackageJson(rootPackagePath);
   if (rootPackage) {
     for (const script of extractScripts(rootPackage)) {
@@ -372536,10 +372722,10 @@ var init_dev_server_detect = __esm({
 });
 
 // ../dashboard/src/dev-server-store.ts
-import { mkdir as mkdir39, readFile as readFile55, writeFile as writeFile39 } from "node:fs/promises";
-import { dirname as dirname56, join as join124, resolve as resolve70 } from "node:path";
+import { mkdir as mkdir39, readFile as readFile56, writeFile as writeFile39 } from "node:fs/promises";
+import { dirname as dirname56, join as join125, resolve as resolve70 } from "node:path";
 function devServerFilePath(projectDir) {
-  return join124(resolve70(projectDir), ".fusion", "dev-server.json");
+  return join125(resolve70(projectDir), ".fusion", "dev-server.json");
 }
 function normalizeState(candidate) {
   const defaults = DEV_SERVER_DEFAULT_STATE();
@@ -372614,7 +372800,7 @@ var init_dev_server_store = __esm({
       }
       async load() {
         try {
-          const content = await readFile55(this.filePath, "utf-8");
+          const content = await readFile56(this.filePath, "utf-8");
           const parsed = JSON.parse(content);
           this.state = normalizeState(parsed?.state);
           this.config = normalizeConfig(parsed?.config);
@@ -375261,7 +375447,7 @@ var init_register_config_mcp_pi_settings_routes = __esm({
 
 // ../dashboard/src/routes.ts
 import multer from "multer";
-import { resolve as resolve71, sep as sep19, join as join125, isAbsolute as isAbsolute32 } from "node:path";
+import { resolve as resolve71, sep as sep19, join as join126, isAbsolute as isAbsolute32 } from "node:path";
 import * as nodeFs3 from "node:fs";
 async function readJsonObject3(path14) {
   try {
@@ -375287,8 +375473,8 @@ async function getPiPackageManagerAgentDir() {
   const fusionAgentDir = getFusionAgentDir();
   const legacyAgentDir = getLegacyPiAgentDir();
   const [fusionSettings, legacySettings, legacyExists, fusionExists] = await Promise.all([
-    readJsonObject3(join125(fusionAgentDir, "settings.json")),
-    readJsonObject3(join125(legacyAgentDir, "settings.json")),
+    readJsonObject3(join126(fusionAgentDir, "settings.json")),
+    readJsonObject3(join126(legacyAgentDir, "settings.json")),
     pathExists2(legacyAgentDir),
     pathExists2(fusionAgentDir)
   ]);
@@ -375315,9 +375501,9 @@ async function discoverDashboardPiExtensions(cwd) {
     const { DefaultPackageManager: DefaultPackageManager5 } = await import("@earendil-works/pi-coding-agent");
     const [agentDir, legacyGlobalSettings, fusionGlobalSettings, projectSettings] = await Promise.all([
       getPiPackageManagerAgentDir(),
-      readJsonObject3(join125(getLegacyPiAgentDir(), "settings.json")),
-      readJsonObject3(join125(getFusionAgentDir(), "settings.json")),
-      readJsonObject3(join125(cwd, ".fusion", "settings.json"))
+      readJsonObject3(join126(getLegacyPiAgentDir(), "settings.json")),
+      readJsonObject3(join126(getFusionAgentDir(), "settings.json")),
+      readJsonObject3(join126(cwd, ".fusion", "settings.json"))
     ]);
     const globalSettings = { ...legacyGlobalSettings, ...fusionGlobalSettings };
     const mergedSettings = { ...globalSettings, ...projectSettings };
@@ -376246,7 +376432,7 @@ function createApiRoutes(store, options) {
           return;
         }
       }
-      const { resolve: resolve103, dirname: dirname76, join: join155 } = await import("node:path");
+      const { resolve: resolve103, dirname: dirname76, join: join156 } = await import("node:path");
       const { readdir: readdir17, stat: stat20 } = await import("node:fs/promises");
       const rawPath = req.query.path || process.env.HOME || process.env.USERPROFILE || "/";
       const showHidden = req.query.showHidden === "true";
@@ -376271,7 +376457,7 @@ function createApiRoutes(store, options) {
       for (const entry of dirEntries) {
         if (!entry.isDirectory()) continue;
         if (!showHidden && entry.name.startsWith(".")) continue;
-        const entryPath = join155(resolvedPath, entry.name);
+        const entryPath = join156(resolvedPath, entry.name);
         let hasChildren = false;
         try {
           const subEntries = await readdir17(entryPath, { withFileTypes: true });
@@ -377988,7 +378174,7 @@ var init_reliability_metrics = __esm({
 
 // ../dashboard/src/view-chunk-manifest.ts
 import { existsSync as existsSync87, readFileSync as readFileSync31, statSync as statSync15 } from "node:fs";
-import { join as join126, resolve as resolve72 } from "node:path";
+import { join as join127, resolve as resolve72 } from "node:path";
 function warnOnce(set, key, message) {
   if (set.has(key)) {
     return;
@@ -377998,7 +378184,7 @@ function warnOnce(set, key, message) {
 }
 function loadViewChunkManifest(clientDir) {
   const cacheKey = resolve72(clientDir);
-  const manifestPath = join126(cacheKey, ".vite", "manifest.json");
+  const manifestPath = join127(cacheKey, ".vite", "manifest.json");
   let mtimeMs = null;
   try {
     mtimeMs = statSync15(manifestPath).mtimeMs;
@@ -378584,7 +378770,7 @@ var init_provider_health_monitor = __esm({
 // ../dashboard/src/server.ts
 import express3 from "express";
 import { randomUUID as randomUUID70 } from "node:crypto";
-import { join as join127, dirname as dirname57 } from "node:path";
+import { join as join128, dirname as dirname57 } from "node:path";
 import { existsSync as existsSync88, readFileSync as readFileSync32, statSync as statSync16 } from "node:fs";
 import { fileURLToPath as fileURLToPath18 } from "node:url";
 import { createSecureServer as createHttp2SecureServer } from "node:http2";
@@ -378907,14 +379093,14 @@ function createServer5(store, options) {
   getTerminalService(store.getRootDir());
   const isHeadless = options?.headless === true;
   const execDir = dirname57(process.execPath);
-  const clientDir = process.env.FUSION_CLIENT_DIR ? process.env.FUSION_CLIENT_DIR : existsSync88(join127(execDir, "client", "index.html")) ? join127(execDir, "client") : existsSync88(join127(__dirname2, "..", "dist", "client")) ? join127(__dirname2, "..", "dist", "client") : join127(__dirname2, "..", "client");
+  const clientDir = process.env.FUSION_CLIENT_DIR ? process.env.FUSION_CLIENT_DIR : existsSync88(join128(execDir, "client", "index.html")) ? join128(execDir, "client") : existsSync88(join128(__dirname2, "..", "dist", "client")) ? join128(__dirname2, "..", "dist", "client") : join128(__dirname2, "..", "client");
   let cachedIndexClientDir = null;
   let cachedIndexHtml = null;
   let cachedIndexMtimeMs = null;
   let cachedTemplatedIndexHtml = null;
   const renderIndexHtml = () => {
     const resolvedClientDir = process.env.FUSION_CLIENT_DIR ? process.env.FUSION_CLIENT_DIR : clientDir;
-    const indexPath = join127(resolvedClientDir, "index.html");
+    const indexPath = join128(resolvedClientDir, "index.html");
     let indexMtimeMs = null;
     try {
       indexMtimeMs = statSync16(indexPath).mtimeMs;
@@ -378956,13 +379142,13 @@ ${injection}`) : cachedIndexHtml.replace("</head>", `${injection}</head>`);
   if (!isHeadless) {
     app.get("/version.json", (_req, res) => {
       res.setHeader("Cache-Control", "no-store, max-age=0");
-      res.sendFile(join127(clientDir, "version.json"), (err) => {
+      res.sendFile(join128(clientDir, "version.json"), (err) => {
         if (err) {
           res.status(404).json({ version: null });
         }
       });
     });
-    if (existsSync88(join127(clientDir, "index.html"))) {
+    if (existsSync88(join128(clientDir, "index.html"))) {
       app.get(["/", "/index.html"], serveIndexHtml);
       app.use(express3.static(clientDir, { index: false }));
     }
@@ -380292,8 +380478,8 @@ var init_server2 = __esm({
 });
 
 // ../dashboard/src/skills-adapter.ts
-import { access as access20, readFile as readFile56, writeFile as writeFile40, mkdir as mkdir40, readdir as readdir15, stat as stat17 } from "node:fs/promises";
-import { join as join128, relative as relative24, dirname as dirname58, resolve as resolve73, sep as sep21 } from "node:path";
+import { access as access20, readFile as readFile57, writeFile as writeFile40, mkdir as mkdir40, readdir as readdir15, stat as stat17 } from "node:fs/promises";
+import { join as join129, relative as relative24, dirname as dirname58, resolve as resolve73, sep as sep21 } from "node:path";
 async function pathExists3(path14) {
   try {
     await access20(path14);
@@ -380343,7 +380529,7 @@ function createSkillsAdapter(options) {
       let settings = {};
       if (await pathExists3(settingsPath)) {
         try {
-          settings = JSON.parse(await readFile56(settingsPath, "utf-8"));
+          settings = JSON.parse(await readFile57(settingsPath, "utf-8"));
         } catch {
         }
       }
@@ -380423,7 +380609,7 @@ function createSkillsAdapter(options) {
       let settings = {};
       if (await pathExists3(settingsPath)) {
         try {
-          settings = JSON.parse(await readFile56(settingsPath, "utf-8"));
+          settings = JSON.parse(await readFile57(settingsPath, "utf-8"));
         } catch {
         }
       }
@@ -380623,10 +380809,10 @@ function createSkillsAdapter(options) {
       } catch {
         skillDir = dirname58(skill.path);
       }
-      const skillMdPath = join128(skillDir, "SKILL.md");
+      const skillMdPath = join129(skillDir, "SKILL.md");
       let skillMd = "";
       try {
-        skillMd = await readFile56(skillMdPath, "utf-8");
+        skillMd = await readFile57(skillMdPath, "utf-8");
       } catch (error3) {
         const err = error3;
         if (err.code !== "ENOENT") {
@@ -380686,7 +380872,7 @@ function createSkillsAdapter(options) {
       if (fileStat.size > MAX_PREVIEW_BYTES) {
         return { name: name2, relativePath: normalizedRelative, content: "", isText: false };
       }
-      const buffer2 = await readFile56(targetPath);
+      const buffer2 = await readFile57(targetPath);
       const sample = buffer2.subarray(0, Math.min(buffer2.length, 8e3));
       const isBinary2 = sample.includes(0);
       if (isBinary2) {
@@ -380885,7 +381071,7 @@ function normalizeEntry(entry) {
   };
 }
 function getProjectSettingsPath(rootDir) {
-  return join128(rootDir, ".fusion", "settings.json");
+  return join129(rootDir, ".fusion", "settings.json");
 }
 var MIN_PUBLIC_SEARCH_QUERY_LENGTH;
 var init_skills_adapter = __esm({
@@ -380986,7 +381172,7 @@ var init_src15 = __esm({
 // src/extension.ts
 import { Type as Type9 } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
-import { resolve as resolve74, relative as relative25, isAbsolute as isAbsolute33, sep as sep22, basename as basename37, extname as extname5, join as join129 } from "node:path";
+import { resolve as resolve74, relative as relative25, isAbsolute as isAbsolute33, sep as sep22, basename as basename37, extname as extname5, join as join130 } from "node:path";
 import { existsSync as existsSync89 } from "node:fs";
 import { AsyncLocalStorage as AsyncLocalStorage8 } from "node:async_hooks";
 function resolveProjectRoot2(cwd) {
@@ -380995,12 +381181,12 @@ function resolveProjectRoot2(cwd) {
     warnedMissingProjectRootResolver = true;
     console.warn("[fusion-extension] @fusion/core.getProjectRootFromWorktree is unavailable; using filesystem fallback resolution.");
   }
-  if (worktreeProjectRoot && existsSync89(join129(worktreeProjectRoot, ".fusion"))) {
+  if (worktreeProjectRoot && existsSync89(join130(worktreeProjectRoot, ".fusion"))) {
     return worktreeProjectRoot;
   }
   let current = resolve74(cwd);
   while (true) {
-    if (existsSync89(join129(current, ".fusion"))) {
+    if (existsSync89(join130(current, ".fusion"))) {
       return current;
     }
     const parent2 = resolve74(current, "..");
@@ -381866,11 +382052,11 @@ var init_migration_holding_server = __esm({
 // src/commands/ensure-project-registered.ts
 import { exec as exec48 } from "node:child_process";
 import { existsSync as existsSync90, mkdirSync as mkdirSync17 } from "node:fs";
-import { basename as basename38, join as join130 } from "node:path";
+import { basename as basename38, join as join131 } from "node:path";
 import { promisify as promisify73 } from "node:util";
 function stampProjectIdentityBestEffort(cwd, project, logPrefix) {
   try {
-    writeProjectIdentity(join130(cwd, ".fusion"), {
+    writeProjectIdentity(join131(cwd, ".fusion"), {
       id: project.id,
       createdAt: project.createdAt
     });
@@ -381892,7 +382078,7 @@ async function ensureCwdProjectRegistered(options) {
     return null;
   }
   try {
-    const fusionDir = join130(cwd, ".fusion");
+    const fusionDir = join131(cwd, ".fusion");
     if (!existsSync90(fusionDir)) {
       mkdirSync17(fusionDir, { recursive: true });
     }
@@ -381923,7 +382109,7 @@ async function ensureCwdProjectRegistered(options) {
   }
 }
 async function detectProjectName(dir2) {
-  if (!existsSync90(join130(dir2, ".git"))) {
+  if (!existsSync90(join131(dir2, ".git"))) {
     return basename38(dir2) || "my-project";
   }
   try {
@@ -381956,12 +382142,12 @@ var init_ensure_project_registered = __esm({
 
 // src/commands/provider-settings.ts
 import { existsSync as existsSync91, readFileSync as readFileSync33, writeFileSync as writeFileSync19, mkdirSync as mkdirSync18 } from "node:fs";
-import { join as join131, dirname as dirname59, basename as basename39 } from "node:path";
+import { join as join132, dirname as dirname59, basename as basename39 } from "node:path";
 function siblingAgentDir2(agentDir, siblingRoot) {
   if (basename39(agentDir) !== "agent") {
     return void 0;
   }
-  return join131(dirname59(dirname59(agentDir)), siblingRoot, "agent");
+  return join132(dirname59(dirname59(agentDir)), siblingRoot, "agent");
 }
 function readJsonObject4(path14) {
   if (!existsSync91(path14)) {
@@ -381975,13 +382161,13 @@ function readJsonObject4(path14) {
   }
 }
 function createReadOnlyProviderSettingsView(cwd, agentDir) {
-  const fusionAgentDir = agentDir.includes(`${join131(".fusion", "agent")}`) ? agentDir : siblingAgentDir2(agentDir, ".fusion");
-  const legacyAgentDir = agentDir.includes(`${join131(".pi", "agent")}`) ? agentDir : siblingAgentDir2(agentDir, ".pi");
-  const legacyGlobalSettings = legacyAgentDir ? readJsonObject4(join131(legacyAgentDir, "settings.json")) : {};
-  const fusionGlobalSettings = fusionAgentDir ? readJsonObject4(join131(fusionAgentDir, "settings.json")) : {};
-  const directGlobalSettings = readJsonObject4(join131(agentDir, "settings.json"));
+  const fusionAgentDir = agentDir.includes(`${join132(".fusion", "agent")}`) ? agentDir : siblingAgentDir2(agentDir, ".fusion");
+  const legacyAgentDir = agentDir.includes(`${join132(".pi", "agent")}`) ? agentDir : siblingAgentDir2(agentDir, ".pi");
+  const legacyGlobalSettings = legacyAgentDir ? readJsonObject4(join132(legacyAgentDir, "settings.json")) : {};
+  const fusionGlobalSettings = fusionAgentDir ? readJsonObject4(join132(fusionAgentDir, "settings.json")) : {};
+  const directGlobalSettings = readJsonObject4(join132(agentDir, "settings.json"));
   const globalSettings = { ...legacyGlobalSettings, ...directGlobalSettings, ...fusionGlobalSettings };
-  const fusionProjectSettings = readJsonObject4(join131(cwd, ".fusion", "settings.json"));
+  const fusionProjectSettings = readJsonObject4(join132(cwd, ".fusion", "settings.json"));
   const mergedSettings = { ...globalSettings, ...fusionProjectSettings };
   return {
     getGlobalSettings: () => structuredClone(globalSettings),
@@ -382010,20 +382196,20 @@ var init_provider_auth2 = __esm({
 // src/commands/auth-paths.ts
 import { homedir as homedir19 } from "node:os";
 import { existsSync as existsSync92, readFileSync as readFileSync34 } from "node:fs";
-import { join as join132 } from "node:path";
+import { join as join133 } from "node:path";
 function getFusionAgentDir2(home = process.env.HOME || process.env.USERPROFILE || homedir19()) {
-  return join132(home, ".fusion", "agent");
+  return join133(home, ".fusion", "agent");
 }
 function getLegacyAgentDir(home = process.env.HOME || process.env.USERPROFILE || homedir19()) {
-  return join132(home, ".pi", "agent");
+  return join133(home, ".pi", "agent");
 }
 function getFusionModelsPath2(home = process.env.HOME || process.env.USERPROFILE || homedir19()) {
-  return join132(getFusionAgentDir2(home), "models.json");
+  return join133(getFusionAgentDir2(home), "models.json");
 }
 function getLegacyModelsPaths2(home = process.env.HOME || process.env.USERPROFILE || homedir19()) {
   return [
-    join132(home, ".pi", "agent", "models.json"),
-    join132(home, ".pi", "models.json")
+    join133(home, ".pi", "agent", "models.json"),
+    join133(home, ".pi", "models.json")
   ];
 }
 function getModelRegistryModelsPath2(home = process.env.HOME || process.env.USERPROFILE || homedir19()) {
@@ -382050,8 +382236,8 @@ function hasPackageManagerSettings3(settings) {
 function getPackageManagerAgentDir2(home = process.env.HOME || process.env.USERPROFILE || homedir19()) {
   const fusionAgentDir = getFusionAgentDir2(home);
   const legacyAgentDir = getLegacyAgentDir(home);
-  const fusionSettings = readJsonObject5(join132(fusionAgentDir, "settings.json"));
-  const legacySettings = readJsonObject5(join132(legacyAgentDir, "settings.json"));
+  const fusionSettings = readJsonObject5(join133(fusionAgentDir, "settings.json"));
+  const legacySettings = readJsonObject5(join133(legacyAgentDir, "settings.json"));
   if (hasPackageManagerSettings3(fusionSettings) || !existsSync92(legacyAgentDir)) {
     return fusionAgentDir;
   }
@@ -382308,7 +382494,7 @@ import {
   symlinkSync as symlinkSync6,
   unlinkSync as unlinkSync7
 } from "node:fs";
-import { dirname as dirname61, join as join133, resolve as resolve76 } from "node:path";
+import { dirname as dirname61, join as join134, resolve as resolve76 } from "node:path";
 import { fileURLToPath as fileURLToPath19 } from "node:url";
 function isPiClaudeCliConfigured(globalSettings) {
   if (!globalSettings || typeof globalSettings !== "object") {
@@ -382332,7 +382518,7 @@ function resolveFusionSkillSource() {
   return existsSync93(candidate) ? candidate : null;
 }
 function installFusionSkillIntoProject(projectPath, options = {}) {
-  const target = join133(projectPath, ".claude", "skills", FUSION_SKILL_NAME4);
+  const target = join134(projectPath, ".claude", "skills", FUSION_SKILL_NAME4);
   if (options.enabled === false) {
     return { outcome: "skipped", target, reason: "pi-claude-cli not configured" };
   }
@@ -382357,7 +382543,7 @@ function installFusionSkillIntoProject(projectPath, options = {}) {
         unlinkSync7(target);
         replaced = true;
       } else {
-        const skillMd = join133(target, "SKILL.md");
+        const skillMd = join134(target, "SKILL.md");
         if (!existsSync93(skillMd)) {
           return {
             outcome: "failed",
@@ -382404,7 +382590,7 @@ function ensureFusionSkillForProjects(projects2, options = { enabled: false }) {
   if (!options.enabled) {
     return projects2.map((p2) => ({
       outcome: "skipped",
-      target: join133(p2.path, ".claude", "skills", FUSION_SKILL_NAME4),
+      target: join134(p2.path, ".claude", "skills", FUSION_SKILL_NAME4),
       reason: "pi-claude-cli not configured"
     }));
   }
@@ -382797,10 +382983,10 @@ var init_llama_cpp_extension = __esm({
 
 // src/update-cache.ts
 import { readFileSync as readFileSync38 } from "node:fs";
-import { join as join134 } from "node:path";
+import { join as join135 } from "node:path";
 function getCachedUpdateStatus(currentVersion) {
   try {
-    const cachePath = join134(resolveGlobalDir(), "update-check.json");
+    const cachePath = join135(resolveGlobalDir(), "update-check.json");
     const raw = readFileSync38(cachePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.updateAvailable === true && typeof parsed.latestVersion === "string" && parsed.latestVersion.length > 0 && typeof parsed.currentVersion === "string" && parsed.currentVersion.length > 0) {
@@ -382906,7 +383092,7 @@ var init_self_extension = __esm({
 });
 
 // src/plugins/bundled-plugin-install.ts
-import { dirname as dirname66, join as join135, resolve as resolve81 } from "node:path";
+import { dirname as dirname66, join as join136, resolve as resolve81 } from "node:path";
 import { fileURLToPath as fileURLToPath24 } from "node:url";
 function getCandidatePluginDirs(pluginId) {
   const moduleDir = dirname66(fileURLToPath24(import.meta.url));
@@ -382914,13 +383100,13 @@ function getCandidatePluginDirs(pluginId) {
   return [
     // Bundled/global runtime: moduleDir is typically <cli>/dist, and plugins are
     // staged under <cli>/dist/plugins/<id>. Keep first for the global-install regression.
-    join135(moduleDir, "plugins", pluginId),
+    join136(moduleDir, "plugins", pluginId),
     // Source checkout: prefer the live workspace plugin (freshness-checked by
     // resolvePluginEntryPath) over the stale staged tsup bundle below.
-    join135(cliPackageRoot, "..", "..", "plugins", pluginId),
+    join136(cliPackageRoot, "..", "..", "plugins", pluginId),
     // Source/dev fallbacks.
-    join135(cliPackageRoot, "dist", "plugins", pluginId),
-    join135(cliPackageRoot, "plugins", pluginId)
+    join136(cliPackageRoot, "dist", "plugins", pluginId),
+    join136(cliPackageRoot, "plugins", pluginId)
   ];
 }
 async function ensureBundledPluginInstalled2(pluginStore, pluginLoader, pluginId) {
@@ -386972,6 +387158,7 @@ var init_common2 = __esm({
           guardRejected: "This move is not allowed by the workflow.",
           mergeBlocked: "This task is blocked from completing until its merge step finishes.",
           unknownColumn: "That column doesn't exist in this task's workflow.",
+          unplannedForExecution: "This task isn't ready for execution yet \u2014 planning or plan review is still outstanding.",
           workflowMismatch: "Drag can't move a card between workflows. Use the workflow switcher instead."
         }
       },
@@ -387463,6 +387650,7 @@ var init_common3 = __esm({
           guardRejected: "",
           mergeBlocked: "",
           unknownColumn: "",
+          unplannedForExecution: "",
           workflowMismatch: ""
         }
       },
@@ -387954,6 +388142,7 @@ var init_common4 = __esm({
           guardRejected: "",
           mergeBlocked: "",
           unknownColumn: "",
+          unplannedForExecution: "",
           workflowMismatch: ""
         }
       },
@@ -388445,6 +388634,7 @@ var init_common5 = __esm({
           guardRejected: "",
           mergeBlocked: "",
           unknownColumn: "",
+          unplannedForExecution: "",
           workflowMismatch: ""
         }
       },
@@ -388936,6 +389126,7 @@ var init_common6 = __esm({
           guardRejected: "",
           mergeBlocked: "",
           unknownColumn: "",
+          unplannedForExecution: "",
           workflowMismatch: ""
         }
       },
@@ -389427,6 +389618,7 @@ var init_common7 = __esm({
           guardRejected: "",
           mergeBlocked: "",
           unknownColumn: "",
+          unplannedForExecution: "",
           workflowMismatch: ""
         }
       },
@@ -391344,7 +391536,7 @@ __export(dashboard_exports, {
   runDashboardSupervised: () => runDashboardSupervised,
   shouldSuperviseDashboard: () => shouldSuperviseDashboard
 });
-import { join as join136, resolve as pathResolve2 } from "node:path";
+import { join as join137, resolve as pathResolve2 } from "node:path";
 import { execFile as execFileCb, spawn as spawn31 } from "node:child_process";
 import { promisify as promisify74 } from "node:util";
 import { stat as stat18, readdir as readdir16, readFile as fsReadFile4 } from "node:fs/promises";
@@ -391686,7 +391878,7 @@ async function buildFileListDirectory(projectPath, relativePath) {
     let size2 = 0;
     let modifiedAt = (/* @__PURE__ */ new Date(0)).toISOString();
     try {
-      const s3 = await stat18(join136(absDir, d.name));
+      const s3 = await stat18(join137(absDir, d.name));
       size2 = d.isDirectory() ? 0 : s3.size;
       modifiedAt = s3.mtime.toISOString();
     } catch {
@@ -392374,7 +392566,7 @@ async function runDashboard(port, opts = {}) {
         ...llamaCppPaths
       ],
       cwd,
-      join136(cwd, ".fusion", "disabled-auto-extension-discovery")
+      join137(cwd, ".fusion", "disabled-auto-extension-discovery")
     ), logPhase);
     for (const { path: path14, error: error3 } of extensionsResult.errors) {
       logSink.log(`Failed to load ${path14}: ${error3}`, "extensions");
@@ -393642,9 +393834,9 @@ function resolveFusionSourceWorkspaceRoot() {
   try {
     let dir2 = pathResolve2(fileURLToPath25(import.meta.url), "..");
     for (let i = 0; i < 10; i++) {
-      if (existsSync98(join136(dir2, "pnpm-workspace.yaml"))) {
+      if (existsSync98(join137(dir2, "pnpm-workspace.yaml"))) {
         try {
-          const pkg = JSON.parse(readFileSync40(join136(dir2, "package.json"), "utf8"));
+          const pkg = JSON.parse(readFileSync40(join137(dir2, "package.json"), "utf8"));
           return pkg?.name === "fusion-workspace" ? dir2 : void 0;
         } catch {
           return void 0;
@@ -394349,7 +394541,7 @@ var serve_exports = {};
 __export(serve_exports, {
   runServe: () => runServe
 });
-import { join as join137, resolve as pathResolve3 } from "node:path";
+import { join as join138, resolve as pathResolve3 } from "node:path";
 import {
   DefaultPackageManager as DefaultPackageManager3,
   discoverAndLoadExtensions as discoverAndLoadExtensions3,
@@ -394809,7 +395001,7 @@ async function runServe(port, opts = {}) {
           ...llamaCppPaths
         ],
         primaryCwd,
-        join137(primaryCwd, ".fusion", "disabled-auto-extension-discovery")
+        join138(primaryCwd, ".fusion", "disabled-auto-extension-discovery")
       );
       for (const { path: path14, error: error3 } of extensionsResult.errors) {
         console.log(`[extensions] Failed to load ${path14}: ${error3}`);
@@ -395234,7 +395426,7 @@ var daemon_exports = {};
 __export(daemon_exports, {
   runDaemon: () => runDaemon
 });
-import { join as join138, resolve as pathResolve4 } from "node:path";
+import { join as join139, resolve as pathResolve4 } from "node:path";
 import {
   DefaultPackageManager as DefaultPackageManager4,
   discoverAndLoadExtensions as discoverAndLoadExtensions4,
@@ -395658,7 +395850,7 @@ async function runDaemon(opts = {}) {
     const extensionsResult = await discoverAndLoadExtensions4(
       [...reconciledExtensionPaths, ...droidCliPaths, ...llamaCppPaths],
       primaryCwd,
-      join138(primaryCwd, ".fusion", "disabled-auto-extension-discovery")
+      join139(primaryCwd, ".fusion", "disabled-auto-extension-discovery")
     );
     for (const { path: path14, error: error3 } of extensionsResult.errors) {
       console.log(`[extensions] Failed to load ${path14}: ${error3}`);
@@ -396005,7 +396197,7 @@ __export(desktop_exports, {
 import { spawn as spawn32 } from "node:child_process";
 import { once as once2 } from "node:events";
 import { existsSync as existsSync99 } from "node:fs";
-import { dirname as dirname67, isAbsolute as isAbsolute34, join as join139, resolve as resolve82 } from "node:path";
+import { dirname as dirname67, isAbsolute as isAbsolute34, join as join140, resolve as resolve82 } from "node:path";
 import { createRequire as createRequire13 } from "node:module";
 import { fileURLToPath as fileURLToPath26 } from "node:url";
 import * as os14 from "node:os";
@@ -396112,7 +396304,7 @@ function terminateProcess(child, signal = "SIGTERM") {
   child.kill(signal);
 }
 function resolveDevDesktopEntry(rootDir) {
-  const desktopEntry = join139(rootDir, "packages", "desktop", "dist", "main.js");
+  const desktopEntry = join140(rootDir, "packages", "desktop", "dist", "main.js");
   if (existsSync99(desktopEntry)) {
     return desktopEntry;
   }
@@ -396749,7 +396941,7 @@ __export(task_exports, {
 });
 import { createInterface as createInterface3 } from "node:readline/promises";
 import { watchFile, unwatchFile, statSync as statSync17, existsSync as existsSync100, readFileSync as readFileSync41 } from "node:fs";
-import { basename as basename41, join as join140 } from "node:path";
+import { basename as basename41, join as join141 } from "node:path";
 function columnLabel2(column) {
   return COLUMN_LABELS[column] ?? column;
 }
@@ -397107,7 +397299,7 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName,
     }
     console.log(`    Path:   .fusion/tasks/${resolvedTask.id}/`);
     if (attachFiles && attachFiles.length > 0) {
-      const { readFile: readFile63 } = await import("node:fs/promises");
+      const { readFile: readFile64 } = await import("node:fs/promises");
       const { basename: basename46, extname: extname7, resolve: resolve103 } = await import("node:path");
       for (const filePath of attachFiles) {
         const resolvedPath = resolve103(filePath);
@@ -397120,7 +397312,7 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName,
         }
         let content;
         try {
-          content = await readFile63(resolvedPath);
+          content = await readFile64(resolvedPath);
         } catch {
           console.error(`    \u2717 Cannot read file: ${filePath}`);
           continue;
@@ -397291,7 +397483,7 @@ async function runTaskLogs(id, options = {}, projectName) {
   printEntries(filteredEntries);
   if (options.follow) {
     const projectPath = context.projectPath ?? process.cwd();
-    const logPath = join140(projectPath, ".fusion", "tasks", id, "agent.log");
+    const logPath = join141(projectPath, ".fusion", "tasks", id, "agent.log");
     if (!existsSync100(logPath)) {
       console.log(`
   Waiting for log file to be created...`);
@@ -397496,7 +397688,7 @@ async function runTaskMerge(id, projectName) {
   }
 }
 async function runTaskAttach(id, filePath, projectName) {
-  const { readFile: readFile63 } = await import("node:fs/promises");
+  const { readFile: readFile64 } = await import("node:fs/promises");
   const { basename: basename46, extname: extname7 } = await import("node:path");
   const { resolve: resolve103 } = await import("node:path");
   const resolvedPath = resolve103(filePath);
@@ -397510,7 +397702,7 @@ async function runTaskAttach(id, filePath, projectName) {
   }
   let content;
   try {
-    content = await readFile63(resolvedPath);
+    content = await readFile64(resolvedPath);
   } catch {
     console.error(`Cannot read file: ${filePath}`);
     process.exit(1);
@@ -398882,7 +399074,7 @@ __export(settings_export_exports, {
   runSettingsExport: () => runSettingsExport
 });
 import { writeFile as writeFile41 } from "node:fs/promises";
-import { resolve as resolve83, join as join141 } from "node:path";
+import { resolve as resolve83, join as join142 } from "node:path";
 async function runSettingsExport(options = {}) {
   const scope = options.scope ?? "both";
   let project;
@@ -398912,7 +399104,7 @@ async function runSettingsExport(options = {}) {
       targetPath = resolve83(outputPath);
     } else {
       const filename = generateExportFilename();
-      targetPath = join141(process.cwd(), filename);
+      targetPath = join142(process.cwd(), filename);
     }
     const jsonContent = JSON.stringify(exportData, null, 2);
     await writeFile41(targetPath, jsonContent);
@@ -399086,7 +399278,7 @@ __export(mcp_exports, {
   runMcpValidate: () => runMcpValidate
 });
 import { existsSync as existsSync102 } from "node:fs";
-import { readFile as readFile57, writeFile as writeFile42 } from "node:fs/promises";
+import { readFile as readFile58, writeFile as writeFile42 } from "node:fs/promises";
 import { resolve as resolve85 } from "node:path";
 async function createGlobalSettingsStore() {
   const store = new GlobalSettingsStore();
@@ -399424,7 +399616,7 @@ async function runMcpImport(filePath, opts = {}) {
     context = await loadContext(opts.projectName, scope === "project");
     const resolvedPath = resolve85(filePath);
     if (!existsSync102(resolvedPath)) throw new Error(`File not found: ${filePath}`);
-    const imported = importMcpServersJson(await readFile57(resolvedPath, "utf-8"), { scope });
+    const imported = importMcpServersJson(await readFile58(resolvedPath, "utf-8"), { scope });
     if (imported.errors.length > 0) throw new Error(`Invalid MCP import file:
 ${imported.errors.map((error3) => `  - ${error3}`).join("\n")}`);
     console.log();
@@ -399541,7 +399733,7 @@ var init_mcp = __esm({
 
 // src/project-resolver.ts
 import { existsSync as existsSync103, statSync as statSync18 } from "node:fs";
-import { basename as basename42, dirname as dirname68, join as join142, normalize as normalize9, resolve as resolve86 } from "node:path";
+import { basename as basename42, dirname as dirname68, join as join143, normalize as normalize9, resolve as resolve86 } from "node:path";
 import { createInterface as createInterface4 } from "node:readline/promises";
 async function getCentralCore() {
   if (!centralCoreInstance) {
@@ -399655,7 +399847,7 @@ Run \`fn project remove ` + match.name + "` to clean up the registry entry.",
     if (interactive) {
       console.log(`
   Found fn project at ${fusionDir} but it's not registered.`);
-      const projectFusionDir = join142(fusionDir, ".fusion");
+      const projectFusionDir = join143(fusionDir, ".fusion");
       const identity = readProjectIdentity(projectFusionDir);
       if (identity) {
         const recover = await promptConfirm2(
@@ -399900,7 +400092,7 @@ var workflow_exports = {};
 __export(workflow_exports, {
   runWorkflowValidate: () => runWorkflowValidate
 });
-import { readFile as readFile58 } from "node:fs/promises";
+import { readFile as readFile59 } from "node:fs/promises";
 import { resolve as resolve87 } from "node:path";
 async function resolveStore(projectName) {
   try {
@@ -399939,7 +400131,7 @@ async function runWorkflowValidate(opts) {
     if (opts.file) {
       const filePath = resolve87(opts.file);
       try {
-        ir2 = JSON.parse(await readFile58(filePath, "utf8"));
+        ir2 = JSON.parse(await readFile59(filePath, "utf8"));
       } catch (error3) {
         const message = `Failed to read or parse workflow IR file '${opts.file}': ${error3 instanceof Error ? error3.message : String(error3)}`;
         if (opts.json) return await exitWithStore({ valid: false, error: message }, 2);
@@ -400759,7 +400951,7 @@ __export(db_exports, {
 });
 import { existsSync as existsSync104 } from "node:fs";
 import { copyFile as copyFile3, mkdir as mkdir41 } from "node:fs/promises";
-import { join as join143 } from "node:path";
+import { join as join144 } from "node:path";
 function formatBytes9(bytes) {
   if (bytes <= 0) return "0 B";
   const units = ["B", "KB", "MB", "GB"];
@@ -400835,7 +401027,7 @@ async function runDbMigrate(projectName, opts = {}) {
   } catch {
     projectRoot = process.cwd();
   }
-  const fusionDir = join143(projectRoot, ".fusion");
+  const fusionDir = join144(projectRoot, ".fusion");
   const globalDir = resolveGlobalDir();
   const sources = defaultMigrationSources(fusionDir, globalDir);
   const presentSources = sources.filter((s3) => existsSync104(s3.sqlitePath));
@@ -400962,11 +401154,11 @@ function describeBackendSafe(backend) {
 }
 async function createPreMigrationBackup(fusionDir, globalDir, sources) {
   const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
-  const backupDir = join143(globalDir, "migration-backups", `pre-migrate-${ts2}`);
+  const backupDir = join144(globalDir, "migration-backups", `pre-migrate-${ts2}`);
   await mkdir41(backupDir, { recursive: true });
   for (const s3 of sources) {
     if (existsSync104(s3.sqlitePath)) {
-      const dest = join143(backupDir, s3.sqlitePath.split("/").pop() ?? "source.db");
+      const dest = join144(backupDir, s3.sqlitePath.split("/").pop() ?? "source.db");
       await copyFile3(s3.sqlitePath, dest);
     }
   }
@@ -401860,7 +402052,7 @@ __export(project_exports2, {
   runProjectSetDefault: () => runProjectSetDefault,
   runProjectShow: () => runProjectShow
 });
-import { resolve as resolve88, isAbsolute as isAbsolute35, relative as relative26, basename as basename43, join as join144 } from "node:path";
+import { resolve as resolve88, isAbsolute as isAbsolute35, relative as relative26, basename as basename43, join as join145 } from "node:path";
 import { existsSync as existsSync105, statSync as statSync19 } from "node:fs";
 import { createInterface as createInterface8 } from "node:readline/promises";
 function formatDisplayPath(projectPath) {
@@ -402105,7 +402297,7 @@ async function runProjectAdd(name2, path14, options = {}) {
     const project = ensured.project;
     await central.updateProject(project.id, { status: "active" });
     try {
-      writeProjectIdentity(join144(absolutePath, ".fusion"), {
+      writeProjectIdentity(join145(absolutePath, ".fusion"), {
         id: project.id,
         createdAt: project.createdAt
       });
@@ -402348,13 +402540,13 @@ var init_project2 = __esm({
 // src/commands/skill-installation.ts
 import { cpSync as cpSync7, existsSync as existsSync106, mkdirSync as mkdirSync20 } from "node:fs";
 import { homedir as homedir20 } from "node:os";
-import { dirname as dirname69, join as join145, resolve as resolve89 } from "node:path";
+import { dirname as dirname69, join as join146, resolve as resolve89 } from "node:path";
 import { fileURLToPath as fileURLToPath27 } from "node:url";
 function getSupportedSkillInstallTargets(homeDir = process.env.HOME || process.env.USERPROFILE || homedir20()) {
   return [
-    { client: "claude", targetDir: join145(homeDir, ".claude", "skills", FUSION_SKILL_NAME5) },
-    { client: "codex", targetDir: join145(homeDir, ".codex", "skills", FUSION_SKILL_NAME5) },
-    { client: "gemini", targetDir: join145(homeDir, ".gemini", "skills", FUSION_SKILL_NAME5) }
+    { client: "claude", targetDir: join146(homeDir, ".claude", "skills", FUSION_SKILL_NAME5) },
+    { client: "codex", targetDir: join146(homeDir, ".codex", "skills", FUSION_SKILL_NAME5) },
+    { client: "gemini", targetDir: join146(homeDir, ".gemini", "skills", FUSION_SKILL_NAME5) }
   ];
 }
 function resolveBundledFusionSkillSource4() {
@@ -402418,13 +402610,13 @@ __export(init_exports, {
   runInit: () => runInit
 });
 import { existsSync as existsSync107, mkdirSync as mkdirSync21, writeFileSync as writeFileSync20, readFileSync as readFileSync42 } from "node:fs";
-import { join as join146, resolve as resolve90, basename as basename44 } from "node:path";
+import { join as join147, resolve as resolve90, basename as basename44 } from "node:path";
 import { exec as exec50 } from "node:child_process";
 import { promisify as promisify76 } from "node:util";
 async function runInit(options = {}) {
   const cwd = options.path ? resolve90(options.path) : process.cwd();
-  const fusionDir = join146(cwd, ".fusion");
-  const dbPath = join146(fusionDir, "fusion.db");
+  const fusionDir = join147(cwd, ".fusion");
+  const dbPath = join147(fusionDir, "fusion.db");
   const hasDbPath = existsSync107(dbPath);
   const hasValidDb = hasDbPath && isValidSqliteDatabaseFile(dbPath);
   const hasIdentity = hasProjectIdentity(fusionDir);
@@ -402434,7 +402626,7 @@ async function runInit(options = {}) {
     const existing = await central2.getProjectByPath(cwd);
     if (existing) {
       try {
-        writeProjectIdentity(join146(cwd, ".fusion"), {
+        writeProjectIdentity(join147(cwd, ".fusion"), {
           id: existing.id,
           createdAt: existing.createdAt
         });
@@ -402511,7 +402703,7 @@ async function runInit(options = {}) {
     const project = ensured.project;
     await central.updateProject(project.id, { status: "active" });
     try {
-      writeProjectIdentity(join146(cwd, ".fusion"), {
+      writeProjectIdentity(join147(cwd, ".fusion"), {
         id: project.id,
         createdAt: project.createdAt
       });
@@ -402546,7 +402738,7 @@ async function runInit(options = {}) {
   }
 }
 async function detectProjectName2(dir2) {
-  if (!existsSync107(join146(dir2, ".git"))) {
+  if (!existsSync107(join147(dir2, ".git"))) {
     return basename44(dir2) || "my-project";
   }
   try {
@@ -402566,7 +402758,7 @@ async function detectProjectName2(dir2) {
   return basename44(dir2) || "my-project";
 }
 async function addLocalStorageToGitignore(cwd) {
-  const gitignorePath = join146(cwd, ".gitignore");
+  const gitignorePath = join147(cwd, ".gitignore");
   let content = "";
   if (existsSync107(gitignorePath)) {
     try {
@@ -402609,7 +402801,7 @@ async function initializeGitRepo(cwd) {
   }
   await ensureGitConfig(cwd, "user.name", "Fusion");
   await ensureGitConfig(cwd, "user.email", "noreply@runfusion.ai");
-  const gitkeepPath = join146(cwd, ".gitkeep");
+  const gitkeepPath = join147(cwd, ".gitkeep");
   if (!existsSync107(gitkeepPath)) {
     writeFileSync20(gitkeepPath, "\n");
   }
@@ -403539,11 +403731,11 @@ var org_import_exports = {};
 __export(org_import_exports, {
   runOrgImport: () => runOrgImport
 });
-import { readFile as readFile59 } from "node:fs/promises";
+import { readFile as readFile60 } from "node:fs/promises";
 import { resolve as resolve94 } from "node:path";
 async function runOrgImport(file, options = {}) {
   const rootDir = options.project ? await resolveProjectPathOnly(options.project) : process.cwd();
-  const bundle = JSON.parse(await readFile59(resolve94(file), "utf8"));
+  const bundle = JSON.parse(await readFile60(resolve94(file), "utf8"));
   const boot = await createTaskStoreForBackend({ rootDir });
   const agents2 = new AgentStore({ rootDir: `${rootDir}/.fusion`, asyncLayer: boot.taskStore.asyncLayer });
   try {
@@ -404157,8 +404349,8 @@ __export(plugin_exports2, {
   runPluginUninstall: () => runPluginUninstall
 });
 import { existsSync as existsSync110 } from "node:fs";
-import { dirname as dirname71, extname as extname6, join as join147, resolve as resolve95 } from "node:path";
-import { readFile as readFile60, stat as stat19 } from "node:fs/promises";
+import { dirname as dirname71, extname as extname6, join as join148, resolve as resolve95 } from "node:path";
+import { readFile as readFile61, stat as stat19 } from "node:fs/promises";
 import * as readline from "node:readline";
 async function getProjectPath(projectName) {
   if (projectName) {
@@ -404249,10 +404441,10 @@ async function resolvePluginEntryFile(pluginDir) {
     }
     throw new Error(`Plugin entry file must end with .js, .mjs, or .cjs: ${absoluteInputPath}`);
   }
-  const packageJsonPath = join147(absoluteInputPath, "package.json");
+  const packageJsonPath = join148(absoluteInputPath, "package.json");
   let selectedCandidate;
   if (existsSync110(packageJsonPath)) {
-    const packageJson = JSON.parse(await readFile60(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(await readFile61(packageJsonPath, "utf-8"));
     const exportsRecord = asRecord6(packageJson.exports);
     const dotExport = exportsRecord?.["."];
     const dotExportRecord = asRecord6(dotExport);
@@ -404299,11 +404491,11 @@ async function loadManifestFromPath(pluginPath) {
   const absoluteInputPath = resolve95(pluginPath);
   const inputStats = await statPath(absoluteInputPath);
   const manifestDir = inputStats?.isFile() ? dirname71(absoluteInputPath) : absoluteInputPath;
-  const manifestPath = join147(manifestDir, "manifest.json");
+  const manifestPath = join148(manifestDir, "manifest.json");
   if (!existsSync110(manifestPath)) {
     throw new Error(`Plugin manifest not found at: ${manifestPath}`);
   }
-  const content = await readFile60(manifestPath, "utf-8");
+  const content = await readFile61(manifestPath, "utf-8");
   const manifest = JSON.parse(content);
   const validation = validatePluginManifest(manifest);
   if (!validation.valid) {
@@ -404682,7 +404874,7 @@ __export(plugin_scaffold_exports, {
   runPluginNew: () => runPluginNew
 });
 import { mkdirSync as mkdirSync24, writeFileSync as writeFileSync23, existsSync as existsSync111, readFileSync as readFileSync45 } from "node:fs";
-import { join as join148, dirname as dirname72, resolve as resolve96 } from "node:path";
+import { join as join149, dirname as dirname72, resolve as resolve96 } from "node:path";
 import { fileURLToPath as fileURLToPath28 } from "node:url";
 function toTitleCase(str) {
   return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
@@ -405004,16 +405196,16 @@ async function runPluginCreate(name2, options) {
   ensureTargetPathAvailable(targetDir, targetPath);
   try {
     mkdirSync24(targetPath, { recursive: true });
-    mkdirSync24(join148(targetPath, "src", "__tests__"), { recursive: true });
-    writeFileSync23(join148(targetPath, "package.json"), generatePackageJson(name2));
-    writeFileSync23(join148(targetPath, "tsconfig.json"), generateTsconfig());
-    writeFileSync23(join148(targetPath, "vitest.config.ts"), generateVitestConfig());
-    writeFileSync23(join148(targetPath, "src", "index.ts"), generateIndexTs(name2));
+    mkdirSync24(join149(targetPath, "src", "__tests__"), { recursive: true });
+    writeFileSync23(join149(targetPath, "package.json"), generatePackageJson(name2));
+    writeFileSync23(join149(targetPath, "tsconfig.json"), generateTsconfig());
+    writeFileSync23(join149(targetPath, "vitest.config.ts"), generateVitestConfig());
+    writeFileSync23(join149(targetPath, "src", "index.ts"), generateIndexTs(name2));
     writeFileSync23(
-      join148(targetPath, "src", "__tests__", "index.test.ts"),
+      join149(targetPath, "src", "__tests__", "index.test.ts"),
       generateTestTs(name2)
     );
-    writeFileSync23(join148(targetPath, "README.md"), generateReadme(name2));
+    writeFileSync23(join149(targetPath, "README.md"), generateReadme(name2));
   } catch (err) {
     console.error(
       `Error creating plugin files: ${err instanceof Error ? err.message : String(err)}`
@@ -405038,14 +405230,14 @@ async function runPluginNew(name2, options) {
   ensureTargetPathAvailable(targetDir, targetPath);
   try {
     mkdirSync24(targetPath, { recursive: true });
-    mkdirSync24(join148(targetPath, "src", "__tests__"), { recursive: true });
-    writeFileSync23(join148(targetPath, "package.json"), generateStandalonePackageJson(name2, options?.scope));
-    writeFileSync23(join148(targetPath, "tsconfig.json"), generateStandaloneTsconfig());
-    writeFileSync23(join148(targetPath, "vitest.config.ts"), generateVitestConfig());
-    writeFileSync23(join148(targetPath, "manifest.json"), generateManifest(name2));
-    writeFileSync23(join148(targetPath, "src", "index.ts"), generateStandaloneIndexTs(name2));
-    writeFileSync23(join148(targetPath, "src", "__tests__", "index.test.ts"), generateStandaloneTestTs(name2));
-    writeFileSync23(join148(targetPath, "README.md"), generateStandaloneReadme(name2));
+    mkdirSync24(join149(targetPath, "src", "__tests__"), { recursive: true });
+    writeFileSync23(join149(targetPath, "package.json"), generateStandalonePackageJson(name2, options?.scope));
+    writeFileSync23(join149(targetPath, "tsconfig.json"), generateStandaloneTsconfig());
+    writeFileSync23(join149(targetPath, "vitest.config.ts"), generateVitestConfig());
+    writeFileSync23(join149(targetPath, "manifest.json"), generateManifest(name2));
+    writeFileSync23(join149(targetPath, "src", "index.ts"), generateStandaloneIndexTs(name2));
+    writeFileSync23(join149(targetPath, "src", "__tests__", "index.test.ts"), generateStandaloneTestTs(name2));
+    writeFileSync23(join149(targetPath, "README.md"), generateStandaloneReadme(name2));
   } catch (err) {
     console.error(
       `Error creating plugin files: ${err instanceof Error ? err.message : String(err)}`
@@ -405080,7 +405272,7 @@ __export(plugin_dev_exports, {
   runPluginDev: () => runPluginDev
 });
 import { existsSync as existsSync112, watch as watch3 } from "node:fs";
-import { join as join149, resolve as resolve97 } from "node:path";
+import { join as join150, resolve as resolve97 } from "node:path";
 async function runSupervisedCommand(command, cwd, timeoutMs = 12e4) {
   await new Promise((resolvePromise, rejectPromise) => {
     const child = superviseSpawn(command, [], {
@@ -405125,7 +405317,7 @@ async function defaultBuildFn(pluginDir) {
   await runSupervisedCommand("npm run build", pluginDir);
 }
 function defaultWatchFn(pluginDir, onChange) {
-  const watchPath = existsSync112(join149(pluginDir, "src")) ? join149(pluginDir, "src") : pluginDir;
+  const watchPath = existsSync112(join150(pluginDir, "src")) ? join150(pluginDir, "src") : pluginDir;
   try {
     const watcher = watch3(watchPath, { recursive: true }, onChange);
     return { close: () => watcher.close() };
@@ -405262,8 +405454,8 @@ __export(plugin_publish_exports, {
   runPluginPublish: () => runPluginPublish
 });
 import { existsSync as existsSync113 } from "node:fs";
-import { readFile as readFile61 } from "node:fs/promises";
-import { join as join150, resolve as resolve98 } from "node:path";
+import { readFile as readFile62 } from "node:fs/promises";
+import { join as join151, resolve as resolve98 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 function classifyVersionBump(previous, next) {
   const previousMatch = STRICT_SEMVER.exec(previous);
@@ -405288,8 +405480,8 @@ function asRecord7(value) {
   return value && typeof value === "object" ? value : void 0;
 }
 async function readPackageJsonVersion(pluginDir) {
-  const packageJsonPath = join150(pluginDir, "package.json");
-  const packageJson = JSON.parse(await readFile61(packageJsonPath, "utf-8"));
+  const packageJsonPath = join151(pluginDir, "package.json");
+  const packageJson = JSON.parse(await readFile62(packageJsonPath, "utf-8"));
   return typeof packageJson.version === "string" ? packageJson.version : void 0;
 }
 function collectDeclaredFunctionHooks(value, prefix, checks) {
@@ -405592,7 +405784,7 @@ __export(research_exports, {
   runResearchShow: () => runResearchShow
 });
 import { writeFile as writeFile43 } from "node:fs/promises";
-import { join as join151, resolve as resolve99 } from "node:path";
+import { join as join152, resolve as resolve99 } from "node:path";
 async function withResolvedStore(projectName, fn2) {
   const owned = await getStore2(projectName);
   try {
@@ -405792,7 +405984,7 @@ async function runResearchExport(options) {
       }
       const content = format === "json" ? JSON.stringify(run2, null, 2) : renderMarkdown(run2);
       const ext = format === "json" ? "json" : "md";
-      const outputPath = options.output ? resolve99(options.output) : join151(process.cwd(), `research-${run2.id.toLowerCase()}.${ext}`);
+      const outputPath = options.output ? resolve99(options.output) : join152(process.cwd(), `research-${run2.id.toLowerCase()}.${ext}`);
       await writeFile43(outputPath, content, "utf8");
       await retryOnLock(
         async () => store.getResearchStore().createExport(run2.id, format, content),
@@ -405870,7 +406062,7 @@ var experiment_finalize_exports = {};
 __export(experiment_finalize_exports, {
   runExperimentFinalize: () => runExperimentFinalize
 });
-import { readFile as readFile62 } from "node:fs/promises";
+import { readFile as readFile63 } from "node:fs/promises";
 import { resolve as resolve100 } from "node:path";
 function printJson(payload) {
   result(JSON.stringify(payload, null, 2) + "\n");
@@ -405883,7 +406075,7 @@ function printPlan(plan) {
   }
 }
 async function parsePlanOverride(path14) {
-  const content = await readFile62(resolve100(path14), "utf8");
+  const content = await readFile63(resolve100(path14), "utf8");
   return JSON.parse(content);
 }
 async function exitWithError(error3, shutdown) {
@@ -406336,7 +406528,7 @@ __export(onboard_autolaunch_exports, {
   shouldAutoLaunchOnboarding: () => shouldAutoLaunchOnboarding
 });
 import { existsSync as existsSync115 } from "node:fs";
-import { join as join152 } from "node:path";
+import { join as join153 } from "node:path";
 function shouldAutoLaunchOnboarding(input) {
   const env = input.env ?? process.env;
   if (input.command === "serve" || input.command === "daemon") {
@@ -406403,8 +406595,8 @@ async function maybeAutoLaunchOnboarding(deps) {
     const pathExists4 = deps.pathExists ?? existsSync115;
     const centralDbPath = deps.centralDbPath ?? getDefaultCentralDbPath();
     const cwd = deps.cwd ?? process.cwd();
-    const projectMarkerPath = join152(cwd, ".fusion", "project.json");
-    const legacyProjectDbPath = join152(cwd, ".fusion", "fusion.db");
+    const projectMarkerPath = join153(cwd, ".fusion", "project.json");
+    const legacyProjectDbPath = join153(cwd, ".fusion", "fusion.db");
     centralDbExists = pathExists4(centralDbPath);
     projectInitialized = deps.projectInitialized ?? (pathExists4(projectMarkerPath) || pathExists4(legacyProjectDbPath));
   } catch (error3) {
@@ -406460,7 +406652,7 @@ __export(native_patch_exports, {
   isTerminalAvailable: () => isTerminalAvailable,
   setupNativeResolution: () => setupNativeResolution
 });
-import { join as join153, basename as basename45, dirname as dirname74 } from "node:path";
+import { join as join154, basename as basename45, dirname as dirname74 } from "node:path";
 import { existsSync as existsSync116, copyFileSync as copyFileSync2, mkdirSync as mkdirSync25, symlinkSync as symlinkSync7, rmSync as rmSync16, lstatSync as lstatSync7, readlinkSync as readlinkSync5 } from "node:fs";
 import { tmpdir as tmpdir22 } from "node:os";
 function findStagedNativeDir2() {
@@ -406468,13 +406660,13 @@ function findStagedNativeDir2() {
   const arch = process.arch === "arm64" ? "arm64" : process.arch === "x64" ? "x64" : "unknown";
   const prebuildName = `${platform6}-${arch}`;
   const execDir = dirname74(process.execPath);
-  const nextToBinary = join153(execDir, "runtime", prebuildName);
-  if (existsSync116(join153(nextToBinary, "pty.node"))) {
+  const nextToBinary = join154(execDir, "runtime", prebuildName);
+  if (existsSync116(join154(nextToBinary, "pty.node"))) {
     return nextToBinary;
   }
   if (process.env.FUSION_RUNTIME_DIR) {
-    const envPath = join153(process.env.FUSION_RUNTIME_DIR, prebuildName);
-    if (existsSync116(join153(envPath, "pty.node"))) {
+    const envPath = join154(process.env.FUSION_RUNTIME_DIR, prebuildName);
+    if (existsSync116(join154(envPath, "pty.node"))) {
       return envPath;
     }
   }
@@ -406507,17 +406699,17 @@ function setupNativeResolution() {
     process.env.NODE_PTY_SPAWN_HELPER_DIR = nativeDir;
   }
   process.env.FUSION_NATIVE_ASSETS_PATH = nativeDir;
-  const tmpRoot = join153(tmpdir22(), `fn-bunfs-${process.pid}`);
-  const fnDir = join153(tmpRoot, "fn");
-  const prebuildsDir = join153(fnDir, "prebuilds");
-  const platformDir = join153(prebuildsDir, basename45(nativeDir));
+  const tmpRoot = join154(tmpdir22(), `fn-bunfs-${process.pid}`);
+  const fnDir = join154(tmpRoot, "fn");
+  const prebuildsDir = join154(fnDir, "prebuilds");
+  const platformDir = join154(prebuildsDir, basename45(nativeDir));
   try {
     cleanupStaleBunfsLinks();
     mkdirSync25(platformDir, { recursive: true });
-    const ptyNodeDest = join153(platformDir, "pty.node");
-    copyFileSync2(join153(nativeDir, "pty.node"), ptyNodeDest);
-    if (existsSync116(join153(nativeDir, "spawn-helper"))) {
-      copyFileSync2(join153(nativeDir, "spawn-helper"), join153(platformDir, "spawn-helper"));
+    const ptyNodeDest = join154(platformDir, "pty.node");
+    copyFileSync2(join154(nativeDir, "pty.node"), ptyNodeDest);
+    if (existsSync116(join154(nativeDir, "spawn-helper"))) {
+      copyFileSync2(join154(nativeDir, "spawn-helper"), join154(platformDir, "spawn-helper"));
     }
     process.env.FUSION_FAKE_BUNFS_ROOT = tmpRoot;
     if (process.platform !== "win32") {
@@ -406595,7 +406787,7 @@ var init_native_patch = __esm({
 init_output();
 import { existsSync as existsSync117, mkdtempSync as mkdtempSync5, readFileSync as readFileSync47, symlinkSync as symlinkSync8, writeFileSync as writeFileSync24 } from "node:fs";
 import { createRequire as createRequire14 } from "node:module";
-import { join as join154, dirname as dirname75, resolve as resolve102 } from "node:path";
+import { join as join155, dirname as dirname75, resolve as resolve102 } from "node:path";
 import { tmpdir as tmpdir23 } from "node:os";
 import { performance as performance4 } from "node:perf_hooks";
 import { Readable as Readable5 } from "node:stream";
@@ -406605,7 +406797,7 @@ function configurePiPackage() {
   if (process.env.PI_PACKAGE_DIR) {
     return;
   }
-  const tmp = mkdtempSync5(join154(tmpdir23(), "fn-pkg-"));
+  const tmp = mkdtempSync5(join155(tmpdir23(), "fn-pkg-"));
   let packageJson = {
     name: "pi",
     version: "0.1.0",
@@ -406617,9 +406809,9 @@ function configurePiPackage() {
     const piPackageDir = dirname75(piPackagePath);
     packageJson = JSON.parse(readFileSync47(piPackagePath, "utf-8"));
     for (const entry of ["dist", "docs", "examples", "README.md", "CHANGELOG.md"]) {
-      const source = join154(piPackageDir, entry);
+      const source = join155(piPackageDir, entry);
       if (existsSync117(source)) {
-        symlinkSync8(source, join154(tmp, entry));
+        symlinkSync8(source, join155(tmp, entry));
       }
     }
   } catch {
@@ -406628,7 +406820,7 @@ function configurePiPackage() {
     ...packageJson.piConfig ?? {},
     configDir: ".fusion"
   };
-  writeFileSync24(join154(tmp, "package.json"), JSON.stringify(packageJson, null, 2) + "\n");
+  writeFileSync24(join155(tmp, "package.json"), JSON.stringify(packageJson, null, 2) + "\n");
   process.env.PI_PACKAGE_DIR = tmp;
 }
 configurePiPackage();
@@ -406657,8 +406849,8 @@ function loadEnvFile(path14) {
 }
 function loadLocalEnv() {
   const cwd = process.cwd();
-  loadEnvFile(join154(cwd, ".env"));
-  loadEnvFile(join154(cwd, ".env.local"));
+  loadEnvFile(join155(cwd, ".env"));
+  loadEnvFile(join155(cwd, ".env.local"));
 }
 loadLocalEnv();
 async function loadCommandHandlers() {