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

package/dist/child-process-worker.js

@@ -5603,7 +5603,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       sql2.raw = raw;
-      function join84(chunks, separator) {
+      function join85(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -5613,7 +5613,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      sql2.join = join84;
+      sql2.join = join85;
       function identifier(value) {
         return new Name(value);
       }
@@ -10261,7 +10261,7 @@ var init_select2 = __esm({
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table)) this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join84) => join84.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join85) => join85.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -11796,7 +11796,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join84) => join84.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join85) => join85.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -11892,10 +11892,10 @@ var init_update = __esm({
               const fromFields = this.getTableLikeFields(this.config.from);
               fields[tableName] = fromFields;
             }
-            for (const join84 of this.config.joins) {
-              const tableName2 = getTableLikeName(join84.table);
-              if (typeof tableName2 === "string" && !is(join84.table, SQL)) {
-                const fromFields = this.getTableLikeFields(join84.table);
+            for (const join85 of this.config.joins) {
+              const tableName2 = getTableLikeName(join85.table);
+              if (typeof tableName2 === "string" && !is(join85.table, SQL)) {
+                const fromFields = this.getTableLikeFields(join85.table);
                 fields[tableName2] = fromFields;
               }
             }
@@ -20499,26 +20499,26 @@ function validateParallelism(nodes2, outgoing, nodesById) {
     }
     const joinsReached = /* @__PURE__ */ new Set();
     for (const edge of branchEdges) {
-      const join85 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
-      if (!join85) {
+      const join86 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
+      if (!join86) {
         throw new WorkflowIrError(`split '${split.id}' has a branch with no reachable matching join`);
       }
-      joinsReached.add(join85);
+      joinsReached.add(join86);
     }
     if (joinsReached.size !== 1) {
       throw new WorkflowIrError(`split '${split.id}' branches converge on more than one join`);
     }
     const joinId = [...joinsReached][0];
-    const join84 = nodesById.get(joinId);
-    const mode = join84.config?.mode;
+    const join85 = nodesById.get(joinId);
+    const mode = join85.config?.mode;
     if (mode && typeof mode === "object" && "quorum" in mode) {
       const n = mode.quorum;
       if (typeof n !== "number" || !Number.isInteger(n) || n < 1) {
-        throw new WorkflowIrError(`join '${join84.id}' quorum must be a positive integer`);
+        throw new WorkflowIrError(`join '${join85.id}' quorum must be a positive integer`);
       }
       if (n > branchEdges.length) {
         throw new WorkflowIrError(
-          `join '${join84.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
+          `join '${join85.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
         );
       }
     }
@@ -24074,14 +24074,14 @@ async function detectWorkspaceRepos(dir, runner = runGitCommand, timeout = DEFAU
     return [];
   }
   const { stat: stat10 } = await import("node:fs/promises");
-  const { join: join84 } = await import("node:path");
+  const { join: join85 } = await import("node:path");
   const found = [];
   const EXCLUDED_ENTRIES = /* @__PURE__ */ new Set(["node_modules", ".fusion", ".git", ".pi"]);
   for (const entry of entries) {
     if (EXCLUDED_ENTRIES.has(entry)) continue;
-    const childDir = join84(dir, entry);
+    const childDir = join85(dir, entry);
     try {
-      const s3 = await stat10(join84(childDir, ".git"));
+      const s3 = await stat10(join85(childDir, ".git"));
       if (!s3.isDirectory() && !s3.isFile()) continue;
     } catch {
       continue;
@@ -24094,9 +24094,9 @@ async function detectWorkspaceRepos(dir, runner = runGitCommand, timeout = DEFAU
 }
 async function isWorkspaceModeExplicitlyDisabled(projectPath) {
   try {
-    const { readFile: readFile40 } = await import("node:fs/promises");
-    const { join: join84 } = await import("node:path");
-    const raw = await readFile40(join84(projectPath, ".fusion", "config.json"), "utf-8");
+    const { readFile: readFile41 } = await import("node:fs/promises");
+    const { join: join85 } = await import("node:path");
+    const raw = await readFile41(join85(projectPath, ".fusion", "config.json"), "utf-8");
     const config3 = JSON.parse(raw);
     return config3.settings?.workspaceMode === false;
   } catch {
@@ -24104,12 +24104,12 @@ async function isWorkspaceModeExplicitlyDisabled(projectPath) {
   }
 }
 async function setWorkspaceModeInConfig(projectPath, value) {
-  const { readFile: readFile40, writeFile: writeFile31, mkdir: mkdir29 } = await import("node:fs/promises");
-  const { join: join84 } = await import("node:path");
-  const configPath = join84(projectPath, ".fusion", "config.json");
+  const { readFile: readFile41, writeFile: writeFile31, mkdir: mkdir29 } = await import("node:fs/promises");
+  const { join: join85 } = await import("node:path");
+  const configPath = join85(projectPath, ".fusion", "config.json");
   let config3 = {};
   try {
-    config3 = JSON.parse(await readFile40(configPath, "utf-8"));
+    config3 = JSON.parse(await readFile41(configPath, "utf-8"));
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
@@ -24118,7 +24118,7 @@ async function setWorkspaceModeInConfig(projectPath, value) {
   }
   const settings = config3.settings;
   settings.workspaceMode = value;
-  await mkdir29(join84(projectPath, ".fusion"), { recursive: true });
+  await mkdir29(join85(projectPath, ".fusion"), { recursive: true });
   await writeFile31(configPath, JSON.stringify(config3, null, 2), "utf-8");
 }
 function isInRootRelativePath(entry, pathMod) {
@@ -24131,12 +24131,12 @@ function isInRootRelativePath(entry, pathMod) {
   return true;
 }
 async function loadWorkspaceConfig(rootDir) {
-  const { readFile: readFile40 } = await import("node:fs/promises");
+  const { readFile: readFile41 } = await import("node:fs/promises");
   const pathMod = await import("node:path");
-  const { join: join84 } = pathMod;
-  const configPath = join84(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME);
+  const { join: join85 } = pathMod;
+  const configPath = join85(rootDir, ".fusion", WORKSPACE_CONFIG_FILENAME);
   try {
-    const raw = await readFile40(configPath, "utf-8");
+    const raw = await readFile41(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object" && "repos" in parsed && Array.isArray(parsed.repos) && parsed.repos.every((r) => typeof r === "string")) {
       const rawRepos = parsed.repos;
@@ -24150,11 +24150,11 @@ async function loadWorkspaceConfig(rootDir) {
 }
 async function saveWorkspaceConfig(rootDir, config3) {
   const { mkdir: mkdir29, writeFile: writeFile31 } = await import("node:fs/promises");
-  const { join: join84 } = await import("node:path");
-  const fusionDir = join84(rootDir, ".fusion");
+  const { join: join85 } = await import("node:path");
+  const fusionDir = join85(rootDir, ".fusion");
   await mkdir29(fusionDir, { recursive: true });
   await writeFile31(
-    join84(fusionDir, WORKSPACE_CONFIG_FILENAME),
+    join85(fusionDir, WORKSPACE_CONFIG_FILENAME),
     JSON.stringify(config3, null, 2),
     "utf-8"
   );
@@ -38983,11 +38983,11 @@ async function rekeyFallbackProjectPartition(db, fallbackProjectId, registeredPr
       const parentKey = `${fk.parentSchema}.${fk.parentTable}`;
       if (!targetKeys.has(parentKey)) continue;
       const childTarget = targetKeys.has(`${fk.childSchema}.${fk.childTable}`);
-      const join84 = fk.childColumns.map((column, index2) => `child.${quoteIdentifier(column)} IS NOT DISTINCT FROM parent.${quoteIdentifier(fk.parentColumns[index2])}`).join(" AND ");
+      const join85 = fk.childColumns.map((column, index2) => `child.${quoteIdentifier(column)} IS NOT DISTINCT FROM parent.${quoteIdentifier(fk.parentColumns[index2])}`).join(" AND ");
       const registeredChildScope = childTarget ? ` AND child.${quoteIdentifier("project_id")} = ${quoteLiteral(registeredProjectId)}` : "";
       const unreplaced = await tx.execute(sql.raw(`SELECT EXISTS (
         SELECT 1 FROM ${relationName({ schema: fk.childSchema, table: fk.childTable })} child
-        JOIN ${relationName({ schema: fk.parentSchema, table: fk.parentTable })} parent ON ${join84}
+        JOIN ${relationName({ schema: fk.parentSchema, table: fk.parentTable })} parent ON ${join85}
         JOIN fusion_rekey_conflict_candidates parent_candidate
           ON parent_candidate.schema_name = ${quoteLiteral(fk.parentSchema)}
          AND parent_candidate.table_name = ${quoteLiteral(fk.parentTable)}
@@ -49824,8 +49824,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static async parseFile(filePath) {
-        const { readFile: readFile40 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
-        const data = await readFile40(filePath, "utf8");
+        const { readFile: readFile41 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
+        const data = await readFile41(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -136300,10 +136300,10 @@ async function runHoldReleaseSweep(store, deps) {
   }
   return result;
 }
-async function issueRelease(store, deps, task, target, ir2) {
+async function issueRelease(store, deps, task, target, ir2, options = {}) {
   const targetColumn = findColumn2(ir2, target);
   const targetIsProcessing = targetColumn ? resolveColumnFlags(targetColumn).countsTowardWip === true : false;
-  if (targetIsProcessing && await isUnplannedForExecution(store, task, ir2)) {
+  if (targetIsProcessing && !options.allowUnplanned && await isUnplannedForExecution(store, task, ir2)) {
     schedulerLog.log(`Hold release for ${task.id} blocked \u2014 card is unplanned and cannot enter processing column ${target}`);
     return false;
   }
@@ -136345,7 +136345,7 @@ async function issueRelease(store, deps, task, target, ir2) {
     return false;
   }
 }
-async function promoteHeldTask(store, taskId, deps = {}) {
+async function promoteHeldTask(store, taskId, deps = {}, options = {}) {
   const task = await store.getTask(taskId);
   if (!task) return { released: false, rejection: "task-not-found" };
   const ir2 = await resolveWorkflowIrForTask(store, taskId);
@@ -136356,17 +136356,50 @@ async function promoteHeldTask(store, taskId, deps = {}) {
   if (!target) return { released: false, rejection: "no-release-target" };
   const targetColumn = findColumn2(ir2, target);
   const targetIsProcessing = targetColumn ? resolveColumnFlags(targetColumn).countsTowardWip === true : false;
-  if (targetIsProcessing && await isUnplannedForExecution(store, task, ir2)) {
+  const unplanned = targetIsProcessing && await isUnplannedForExecution(store, task, ir2);
+  if (unplanned && options.force !== true) {
     return { released: false, rejection: "unplanned-for-execution", toColumn: target };
   }
+  let promoted = task;
+  if (unplanned) {
+    if (task.status === "needs-replan" || task.status === "plan-review-unavailable") {
+      try {
+        await store.updateTask(task.id, { status: null });
+        promoted = { ...task, status: void 0 };
+      } catch (error2) {
+        schedulerLog.warn(
+          `Force-promote for ${task.id} could not clear replan status: ${error2 instanceof Error ? error2.message : String(error2)}`
+        );
+      }
+    }
+    if (typeof store.recordRunAuditEvent === "function") {
+      try {
+        await store.recordRunAuditEvent({
+          domain: "database",
+          mutationType: "task:promote-forced-unplanned",
+          target: task.id,
+          taskId: task.id,
+          agentId: "system",
+          runId: `promote-force-${task.id}`,
+          metadata: { fromColumn: task.column, toColumn: target, priorStatus: task.status ?? null }
+        });
+      } catch {
+      }
+    }
+    schedulerLog.log(`Force-promote for ${task.id} bypassing unplanned gate into ${target} (operator override)`);
+  }
   const released = await issueRelease(
     store,
     { now: () => Date.now(), reserveSlot: deps.reserveSlot, allocateWorktree: deps.allocateWorktree },
-    task,
+    promoted,
     target,
-    ir2
+    ir2,
+    { allowUnplanned: unplanned }
   );
-  return released ? { released: true, toColumn: target } : { released: false, rejection: "capacity-exhausted-or-no-slot" };
+  if (!released) {
+    return { released: false, rejection: "capacity-exhausted-or-no-slot" };
+  }
+  return { released: true, toColumn: target, forcedUnplanned: unplanned || void 0 };
 }
 async function releaseHeldTaskByEvent(store, taskId, eventTag, deps = {}) {
   const task = await store.getTask(taskId);
@@ -137290,8 +137323,8 @@ var require_graceful_fs = __commonJS({
       fs10.createReadStream = createReadStream;
       fs10.createWriteStream = createWriteStream;
       var fs$readFile = fs10.readFile;
-      fs10.readFile = readFile40;
-      function readFile40(path5, options, cb) {
+      fs10.readFile = readFile41;
+      function readFile41(path5, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path5, options, cb);
@@ -169790,6 +169823,86 @@ var init_research_step_runner = __esm({
   }
 });
 
+// ../engine/src/plan-artifact-writeback.ts
+import { readFile as readFile33 } from "node:fs/promises";
+import { join as join66 } from "node:path";
+function relativePromptPath(taskId) {
+  return `.fusion/tasks/${taskId}/PROMPT.md`;
+}
+async function readIfPresent(path5) {
+  try {
+    return await readFile33(path5, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function reconcileWorktreePlanArtifact(options) {
+  const { store, taskId, rootDir, planningCwd, logger: logger3 } = options;
+  const relPath = relativePromptPath(taskId);
+  const rootContent = await readIfPresent(join66(rootDir, relPath));
+  if (planningCwd === rootDir) {
+    return { outcome: "not-worktree", content: rootContent ?? void 0 };
+  }
+  const worktreeContent = await readIfPresent(join66(planningCwd, relPath));
+  if (worktreeContent === null) {
+    return { outcome: "no-worktree-artifact", content: rootContent ?? void 0 };
+  }
+  if (worktreeContent.trim().length === 0) {
+    return { outcome: "worktree-artifact-empty", content: rootContent ?? void 0 };
+  }
+  if (rootContent === worktreeContent) {
+    return { outcome: "already-authoritative", content: rootContent };
+  }
+  try {
+    await store.updateTask(taskId, { prompt: worktreeContent });
+    logger3?.log?.(
+      `${taskId}: recovered a worktree-local PROMPT.md into the project .fusion folder (${planningCwd})`
+    );
+    return { outcome: "recovered", content: worktreeContent };
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    logger3?.warn?.(
+      `${taskId}: failed to copy the worktree-local PROMPT.md back into the project .fusion folder: ${message}`
+    );
+    return { outcome: "recovery-failed", content: rootContent ?? void 0 };
+  }
+}
+async function mirrorPlanToProjectDb(store, taskId, content, options = {}) {
+  if (content.trim().length === 0) return false;
+  if (typeof store.upsertTaskDocument !== "function") return false;
+  try {
+    if (typeof store.getTaskDocument === "function") {
+      const existing = await store.getTaskDocument(taskId, PLAN_DOCUMENT_KEY);
+      if (typeof existing?.content === "string" && existing.content === content) return false;
+    }
+    await store.upsertTaskDocument(taskId, {
+      key: PLAN_DOCUMENT_KEY,
+      content,
+      author: options.author ?? "agent"
+    });
+    return true;
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    options.logger?.warn?.(`${taskId}: failed to mirror the plan into the project database: ${message}`);
+    return false;
+  }
+}
+async function persistPlanArtifact(options) {
+  const result = await reconcileWorktreePlanArtifact(options);
+  const mirrored = result.content ? await mirrorPlanToProjectDb(options.store, options.taskId, result.content, {
+    author: options.author,
+    logger: options.logger
+  }) : false;
+  return { ...result, mirrored };
+}
+var PLAN_DOCUMENT_KEY;
+var init_plan_artifact_writeback = __esm({
+  "../engine/src/plan-artifact-writeback.ts"() {
+    "use strict";
+    PLAN_DOCUMENT_KEY = "plan";
+  }
+});
+
 // ../engine/src/auto-recovery-handlers/message-delivery.ts
 import { setTimeout as delay2 } from "node:timers/promises";
 var baseLog, MessageDeliveryAutoRecoveryHandler;
@@ -170817,9 +170930,9 @@ function assertInRootRepoRelPath(repoRelPath, sep12, isAbsolute22, normalize8) {
 async function acquireWorkspaceRepoWorktree(opts) {
   const { repoRelPath, workspaceRootDir, task, store, settings, logger: logger3, secretsStore, audit, runContext, runConfiguredCommand: runConfiguredCommand2, taskEnv } = opts;
   const registry3 = opts.registry ?? activeSessionRegistry;
-  const { join: join84, isAbsolute: isAbsolute22, normalize: normalize8, sep: sep12 } = await import("node:path");
+  const { join: join85, isAbsolute: isAbsolute22, normalize: normalize8, sep: sep12 } = await import("node:path");
   assertInRootRepoRelPath(repoRelPath, sep12, isAbsolute22, normalize8);
-  const repoAbsPath = join84(workspaceRootDir, repoRelPath);
+  const repoAbsPath = join85(workspaceRootDir, repoRelPath);
   const existing = task.workspaceWorktrees?.[repoRelPath];
   if (existing) {
     let live = existsSync52(existing.worktreePath);
@@ -171008,11 +171121,11 @@ var init_worktree_acquisition = __esm({
 });
 
 // ../engine/src/agent-tools.ts
-import { appendFile as appendFile3, mkdir as mkdir26, readFile as readFile33, readdir as readdir9, realpath, stat as stat9, writeFile as writeFile25 } from "node:fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir26, readFile as readFile34, readdir as readdir9, realpath, stat as stat9, writeFile as writeFile25 } from "node:fs/promises";
 import { existsSync as existsSync53 } from "node:fs";
 import { createHash as createHash16, randomUUID as randomUUID45 } from "node:crypto";
 import { tmpdir as tmpdir6 } from "node:os";
-import { extname as extname3, isAbsolute as isAbsolute13, join as join66, relative as relative11, resolve as resolve32, sep as sep9 } from "node:path";
+import { extname as extname3, isAbsolute as isAbsolute13, join as join67, relative as relative11, resolve as resolve32, sep as sep9 } from "node:path";
 import { Type as Type2 } from "@earendil-works/pi-ai";
 function sanitizeAgentMemoryId(agentId) {
   return agentId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
@@ -171024,16 +171137,16 @@ function agentDreamsDisplayPath(agentId) {
   return `${AGENT_MEMORY_ROOT3}/${sanitizeAgentMemoryId(agentId)}/${AGENT_DREAMS_FILENAME2}`;
 }
 function agentMemoryDirectory(rootDir, agentId) {
-  return join66(rootDir, AGENT_MEMORY_ROOT3, sanitizeAgentMemoryId(agentId));
+  return join67(rootDir, AGENT_MEMORY_ROOT3, sanitizeAgentMemoryId(agentId));
 }
 function agentMemoryFilePath(rootDir, agentId) {
-  return join66(agentMemoryDirectory(rootDir, agentId), AGENT_MEMORY_FILENAME2);
+  return join67(agentMemoryDirectory(rootDir, agentId), AGENT_MEMORY_FILENAME2);
 }
 function agentDreamsFilePath(rootDir, agentId) {
-  return join66(agentMemoryDirectory(rootDir, agentId), AGENT_DREAMS_FILENAME2);
+  return join67(agentMemoryDirectory(rootDir, agentId), AGENT_DREAMS_FILENAME2);
 }
 function agentDailyFilePath(rootDir, agentId, date5 = /* @__PURE__ */ new Date()) {
-  return join66(agentMemoryDirectory(rootDir, agentId), `${date5.toISOString().slice(0, 10)}.md`);
+  return join67(agentMemoryDirectory(rootDir, agentId), `${date5.toISOString().slice(0, 10)}.md`);
 }
 async function readAgentMemoryWorkspaceLongTerm(rootDir, agentId) {
   const safeRoot = typeof rootDir === "string" ? rootDir.trim() : "";
@@ -171047,7 +171160,7 @@ async function readAgentMemoryWorkspaceLongTerm(rootDir, agentId) {
     if (!fileStat.isFile()) {
       return "";
     }
-    const content = await readFile33(filePath, "utf-8");
+    const content = await readFile34(filePath, "utf-8");
     return typeof content === "string" ? content.trim() : "";
   } catch {
     return "";
@@ -171126,7 +171239,7 @@ async function listAgentMemoryFiles2(rootDir, agentMemory) {
   }
   for (const entry of entries) {
     if (!DAILY_AGENT_MEMORY_RE2.test(entry)) continue;
-    const absPath = join66(dir, entry);
+    const absPath = join67(dir, entry);
     const fileStat = await stat9(absPath);
     if (fileStat.isFile()) {
       files.push({
@@ -171149,7 +171262,7 @@ async function searchAgentMemoryFile(rootDir, agentMemory, query, limit) {
   }
   const results = [];
   for (const file of await listAgentMemoryFiles2(rootDir, agentMemory)) {
-    const content = await readFile33(file.absPath, "utf-8");
+    const content = await readFile34(file.absPath, "utf-8");
     const lines = content.split("\n");
     for (let index2 = 0; index2 < lines.length; index2 += 8) {
       const chunk = lines.slice(index2, index2 + 12).join("\n").trim();
@@ -171295,7 +171408,7 @@ function resolveAgentMemoryPath(rootDir, agentId, path5) {
     return null;
   }
   return {
-    absPath: join66(agentMemoryDirectory(rootDir, agentId), filename),
+    absPath: join67(agentMemoryDirectory(rootDir, agentId), filename),
     displayPath: `${prefix}${filename}`
   };
 }
@@ -171305,7 +171418,7 @@ async function getAgentMemoryWindow(rootDir, agentMemory, path5, startLine = 1,
     return null;
   }
   await syncAgentMemoryFile(rootDir, agentMemory);
-  const content = await readFile33(resolved.absPath, "utf-8");
+  const content = await readFile34(resolved.absPath, "utf-8");
   const lines = content.split("\n");
   const start = Math.max(1, Math.floor(startLine));
   const count2 = Math.max(1, Math.min(Math.floor(lineCount), 200));
@@ -171955,6 +172068,9 @@ function createTaskPromptWriteTool(store, taskId, runContext) {
         if (persisted?.prompt !== params.content) {
           throw new Error("authoritative PROMPT.md read-back did not match the requested content; persistence could not be verified");
         }
+        await mirrorPlanToProjectDb(store, taskId, params.content, {
+          author: runContext?.agentId ?? "agent"
+        });
         return {
           content: [{ type: "text", text: `Updated PROMPT.md for ${taskId}.` }],
           details: {}
@@ -172169,7 +172285,7 @@ async function readArtifactFileFromPath(params, baseDir) {
   if (!mimeType) {
     throw new Error(`Could not infer a MIME type from ${resolvedPath}; pass mimeType explicitly.`);
   }
-  const data = await readFile33(canonicalPath);
+  const data = await readFile34(canonicalPath);
   if (params.type === "image") {
     if (!mimeType.startsWith("image/")) {
       throw new Error(`image artifacts require an image/* mimeType, got ${mimeType}.`);
@@ -172512,25 +172628,33 @@ function createTaskPromoteTool(store, currentTaskId) {
   return {
     name: "fn_task_promote",
     label: "Promote Held Task",
-    description: "Manually promote a held task out of its hold column, releasing it regardless of the hold's release kind (the explicit operator action a 'manual' hold waits for). Defaults to the current task. Returns the destination column, or a rejection reason when the task is not held or the destination is full.",
+    description: "Manually promote a held task out of its hold column, releasing it regardless of the hold's release kind (the explicit operator action a 'manual' hold waits for). Defaults to the current task. Returns the destination column, or a rejection reason when the task is not held or the destination is full. Pass force:true to start execution even when planning or plan review is still outstanding (that waives the plan gate and cancels the pending replan; capacity still applies).",
     parameters: taskPromoteParams,
     execute: async (_id, params) => {
       const taskId = params.task_id?.trim() || currentTaskId;
+      const force = params.force === true;
       try {
-        const outcome = await promoteHeldTask(store, taskId);
+        const outcome = await promoteHeldTask(store, taskId, {}, { force });
         if (outcome.released) {
+          const forcedNote = outcome.forcedUnplanned ? " Forced past the outstanding planning/plan review \u2014 the pending replan was cancelled." : "";
           return {
             content: [{
               type: "text",
-              text: `Promoted ${taskId} to column '${outcome.toColumn}'.`
+              text: `Promoted ${taskId} to column '${outcome.toColumn}'.${forcedNote}`
             }],
-            details: { taskId, released: true, toColumn: outcome.toColumn }
+            details: {
+              taskId,
+              released: true,
+              toColumn: outcome.toColumn,
+              forcedUnplanned: outcome.forcedUnplanned === true
+            }
           };
         }
+        const forceHint = outcome.rejection === "unplanned-for-execution" ? " Pass force:true to start execution anyway." : "";
         return {
           content: [{
             type: "text",
-            text: `ERROR: Could not promote ${taskId}: ${outcome.rejection ?? "unknown"}.`
+            text: `ERROR: Could not promote ${taskId}: ${outcome.rejection ?? "unknown"}.${forceHint}`
           }],
           details: { taskId, released: false, rejection: outcome.rejection },
           isError: true
@@ -174713,6 +174837,7 @@ var init_agent_tools = __esm({
     init_provider_registry();
     init_research_step_runner();
     init_logger();
+    init_plan_artifact_writeback();
     init_web_fetch();
     init_agent_action_gate();
     init_message_delivery();
@@ -174892,6 +175017,19 @@ var init_agent_tools = __esm({
     taskPromoteParams = Type2.Object({
       task_id: Type2.Optional(
         Type2.String({ description: "Held task to promote. Defaults to the current task." })
+      ),
+      /*
+      FNXC:WorkflowScheduling 2026-07-25-05:40:
+      Agent-native parity with the dashboard's force-promote override: an agent that
+      has read the card and judged the pending replan / Plan Review not worth waiting
+      for can start execution anyway. Opt-in per call and never defaulted on — the
+      automatic surfaces (hold-release sweep, webhook release) still cannot force, so
+      FN-7648 holds for everything that is not an explicit promote request.
+      */
+      force: Type2.Optional(
+        Type2.Boolean({
+          description: "Start execution even when the task is still waiting on planning or plan review (rejection 'unplanned-for-execution'). Waives ONLY that gate \u2014 hold membership and downstream capacity still apply \u2014 and cancels the pending replan. Default false."
+        })
       )
     });
     workflowCreateParams = Type2.Object({
@@ -175276,8 +175414,8 @@ var init_agent_tools = __esm({
 });
 
 // ../engine/src/agent-memory-index.ts
-import { readFile as readFile34 } from "node:fs/promises";
-import { join as join67 } from "node:path";
+import { readFile as readFile35 } from "node:fs/promises";
+import { join as join68 } from "node:path";
 function clampUtf8(input, maxBytes) {
   if (Buffer.byteLength(input, "utf8") <= maxBytes) return input;
   let out = "";
@@ -175309,7 +175447,7 @@ function parseHeadings(content) {
 }
 async function buildFileSection(sectionHeader, displayPath, fsPath) {
   try {
-    const content = await readFile34(fsPath, "utf-8");
+    const content = await readFile35(fsPath, "utf-8");
     const headings = parseHeadings(content);
     const lines = [sectionHeader, `- ${displayPath}`];
     for (const entry of headings) {
@@ -175325,9 +175463,9 @@ async function buildFileSection(sectionHeader, displayPath, fsPath) {
 async function buildMemoryIndex({ rootDir, agentId }) {
   const safeAgentId = agentId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
   const agentDisplayPath = `.fusion/agent-memory/${safeAgentId}/MEMORY.md`;
-  const agentFsPath = join67(rootDir, ".fusion", "agent-memory", safeAgentId, "MEMORY.md");
+  const agentFsPath = join68(rootDir, ".fusion", "agent-memory", safeAgentId, "MEMORY.md");
   const projectDisplayPath = ".fusion/memory/MEMORY.md";
-  const projectFsPath = join67(rootDir, ".fusion", "memory", "MEMORY.md");
+  const projectFsPath = join68(rootDir, ".fusion", "memory", "MEMORY.md");
   const [agentSection, projectSection] = await Promise.all([
     buildFileSection("## Agent Memory Index (use fn_memory_search / fn_memory_get to read)", agentDisplayPath, agentFsPath),
     buildFileSection("## Project Memory Index", projectDisplayPath, projectFsPath)
@@ -175346,7 +175484,7 @@ var init_agent_memory_index = __esm({
 });
 
 // ../engine/src/agent-instructions.ts
-import { readFile as readFile35, writeFile as writeFile26, mkdir as mkdir27, access as access8 } from "node:fs/promises";
+import { readFile as readFile36, writeFile as writeFile26, mkdir as mkdir27, access as access8 } from "node:fs/promises";
 import { isAbsolute as isAbsolute14, resolve as resolve33, relative as relative12, normalize as normalize7, sep as sep10, dirname as dirname28 } from "node:path";
 function trimAndClamp(value, maxLength, label, agentId) {
   const trimmed = value.trim();
@@ -175407,7 +175545,7 @@ async function resolveAgentHeartbeatProcedure(agent, rootDir) {
     return null;
   }
   try {
-    const content = await readFile35(filePath, "utf-8");
+    const content = await readFile36(filePath, "utf-8");
     const normalized = trimAndClamp(
       content,
       MAX_INSTRUCTIONS_TEXT_LENGTH2,
@@ -175533,7 +175671,7 @@ async function resolveAgentInstructions(agent, rootDir, ratingSummary, inclusion
     const filePath = resolveValidatedInstructionsPath(agent.instructionsPath, rootDir, agent.id);
     if (filePath) {
       try {
-        const content = await readFile35(filePath, "utf-8");
+        const content = await readFile36(filePath, "utf-8");
         const normalizedContent = trimAndClamp(
           content,
           MAX_INSTRUCTIONS_TEXT_LENGTH2,
@@ -177366,10 +177504,10 @@ var init_verification_utils = __esm({
 import { exec as exec19 } from "node:child_process";
 import { createHash as createHash17 } from "node:crypto";
 import { existsSync as existsSync54, readFileSync as readFileSync18, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 import { promisify as promisify24 } from "node:util";
 function hasInstallState(rootDir) {
-  return existsSync54(join68(rootDir, "node_modules")) || existsSync54(join68(rootDir, ".pnp.cjs"));
+  return existsSync54(join69(rootDir, "node_modules")) || existsSync54(join69(rootDir, ".pnp.cjs"));
 }
 function getConfiguredWorktreeInitCommand(settings) {
   const trimmed = settings?.worktreeInitCommand?.trim();
@@ -177378,17 +177516,17 @@ function getConfiguredWorktreeInitCommand(settings) {
 function getDependencySyncCommand(rootDir, settings) {
   const configuredCommand = getConfiguredWorktreeInitCommand(settings);
   if (configuredCommand) return configuredCommand;
-  if (existsSync54(join68(rootDir, "pnpm-lock.yaml"))) return "pnpm install --frozen-lockfile";
-  if (existsSync54(join68(rootDir, "package-lock.json"))) return "npm install";
-  if (existsSync54(join68(rootDir, "yarn.lock"))) return "yarn install --frozen-lockfile";
-  if (existsSync54(join68(rootDir, "bun.lock")) || existsSync54(join68(rootDir, "bun.lockb"))) {
+  if (existsSync54(join69(rootDir, "pnpm-lock.yaml"))) return "pnpm install --frozen-lockfile";
+  if (existsSync54(join69(rootDir, "package-lock.json"))) return "npm install";
+  if (existsSync54(join69(rootDir, "yarn.lock"))) return "yarn install --frozen-lockfile";
+  if (existsSync54(join69(rootDir, "bun.lock")) || existsSync54(join69(rootDir, "bun.lockb"))) {
     return "bun install --frozen-lockfile";
   }
   return null;
 }
 function computeLockfileHash(rootDir) {
   for (const name2 of LOCKFILE_CANDIDATES) {
-    const p2 = join68(rootDir, name2);
+    const p2 = join69(rootDir, name2);
     if (existsSync54(p2)) {
       try {
         return createHash17("sha256").update(readFileSync18(p2)).digest("hex");
@@ -177401,7 +177539,7 @@ function computeLockfileHash(rootDir) {
 }
 function readInstallMarker(rootDir) {
   try {
-    const value = readFileSync18(join68(rootDir, INSTALL_MARKER_RELPATH), "utf-8").trim();
+    const value = readFileSync18(join69(rootDir, INSTALL_MARKER_RELPATH), "utf-8").trim();
     return value || null;
   } catch {
     return null;
@@ -177409,7 +177547,7 @@ function readInstallMarker(rootDir) {
 }
 function writeInstallMarker(rootDir, hash) {
   try {
-    writeFileSync7(join68(rootDir, INSTALL_MARKER_RELPATH), hash);
+    writeFileSync7(join69(rootDir, INSTALL_MARKER_RELPATH), hash);
   } catch {
   }
 }
@@ -177500,7 +177638,7 @@ var init_merge_dependency_sync = __esm({
   "../engine/src/merge-dependency-sync.ts"() {
     "use strict";
     execAsync17 = promisify24(exec19);
-    INSTALL_MARKER_RELPATH = join68("node_modules", ".fusion-install-marker");
+    INSTALL_MARKER_RELPATH = join69("node_modules", ".fusion-install-marker");
     LOCKFILE_CANDIDATES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb", "bun.lock"];
     INSTALL_TIMEOUT_MS = 3e5;
   }
@@ -178121,7 +178259,7 @@ var init_merger_glob = __esm({
 
 // ../engine/src/merger-workspace-test-commands.ts
 import { existsSync as existsSync55, readdirSync as readdirSync9, readFileSync as readFileSync19 } from "node:fs";
-import { basename as basename18, dirname as dirname31, join as join69 } from "node:path";
+import { basename as basename18, dirname as dirname31, join as join70 } from "node:path";
 import { execSync as execSync3 } from "node:child_process";
 function quoteArg(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
@@ -178152,14 +178290,14 @@ function resolveWorkspacePackageRoots(rootDir, globs) {
   for (const glob of globs) {
     const starIdx = glob.indexOf("*");
     if (starIdx === -1) {
-      const candidate = join69(rootDir, glob);
-      if (existsSync55(join69(candidate, "package.json"))) {
+      const candidate = join70(rootDir, glob);
+      if (existsSync55(join70(candidate, "package.json"))) {
         roots.push(glob);
       }
       continue;
     }
     const prefix = glob.slice(0, starIdx);
-    const parentDir = join69(rootDir, prefix.replace(/\/$/, ""));
+    const parentDir = join70(rootDir, prefix.replace(/\/$/, ""));
     let entries;
     try {
       entries = readdirSync9(parentDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -178168,8 +178306,8 @@ function resolveWorkspacePackageRoots(rootDir, globs) {
     }
     for (const entry of entries) {
       const relPath = `${prefix.replace(/\/$/, "")}/${entry}`;
-      const absPath = join69(rootDir, relPath);
-      if (existsSync55(join69(absPath, "package.json"))) {
+      const absPath = join70(rootDir, relPath);
+      if (existsSync55(join70(absPath, "package.json"))) {
         roots.push(relPath);
       }
     }
@@ -178192,7 +178330,7 @@ function mapChangedFilesToPackageNames(changedFiles, packageRoots, rootDir) {
     }
     if (bestRoot !== null) {
       try {
-        const pkgJsonPath = join69(rootDir, bestRoot, "package.json");
+        const pkgJsonPath = join70(rootDir, bestRoot, "package.json");
         const raw = readFileSync19(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed.name) {
@@ -178209,7 +178347,7 @@ function packageNamesForFiles(rootDir, files) {
   if (files.length === 0) return [];
   let workspaceContent;
   try {
-    workspaceContent = readFileSync19(join69(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    workspaceContent = readFileSync19(join70(rootDir, "pnpm-workspace.yaml"), "utf-8");
   } catch {
     return [];
   }
@@ -178220,7 +178358,7 @@ function packageNamesForFiles(rootDir, files) {
   return mapChangedFilesToPackageNames(files, packageRoots, rootDir);
 }
 function deriveScopedPnpmTestCommand(rootDir, baseBranch, branch) {
-  const workspacePath = join69(rootDir, "pnpm-workspace.yaml");
+  const workspacePath = join70(rootDir, "pnpm-workspace.yaml");
   let workspaceContent;
   try {
     workspaceContent = readFileSync19(workspacePath, "utf-8");
@@ -178258,7 +178396,7 @@ function deriveScopedPnpmTestCommand(rootDir, baseBranch, branch) {
 function deriveFileScopedPnpmTestCommand(rootDir, baseBranch, branch) {
   let workspaceContent;
   try {
-    workspaceContent = readFileSync19(join69(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    workspaceContent = readFileSync19(join70(rootDir, "pnpm-workspace.yaml"), "utf-8");
   } catch {
     return null;
   }
@@ -178300,7 +178438,7 @@ function deriveFileScopedPnpmTestCommand(rootDir, baseBranch, branch) {
     ];
     for (const candidate of candidates) {
       const normalized = candidate.startsWith("./") ? candidate.slice(2) : candidate;
-      if (existsSync55(join69(rootDir, normalized))) {
+      if (existsSync55(join70(rootDir, normalized))) {
         resolvedTests.add(normalized);
       }
     }
@@ -178328,7 +178466,7 @@ function deriveFileScopedPnpmTestCommand(rootDir, baseBranch, branch) {
       let name2 = bestRoot;
       try {
         const parsed = JSON.parse(
-          readFileSync19(join69(rootDir, bestRoot, "package.json"), "utf-8")
+          readFileSync19(join70(rootDir, bestRoot, "package.json"), "utf-8")
         );
         if (parsed.name) name2 = parsed.name;
       } catch {
@@ -178372,8 +178510,8 @@ function inferDefaultTestCommand(rootDir, explicitTestCommand, explicitBuildComm
     };
   }
   const buildSource = explicitBuildCommand?.trim() ? "explicit" : void 0;
-  if (existsSync55(join69(rootDir, "pnpm-lock.yaml"))) {
-    if (existsSync55(join69(rootDir, "pnpm-workspace.yaml"))) {
+  if (existsSync55(join70(rootDir, "pnpm-lock.yaml"))) {
+    if (existsSync55(join70(rootDir, "pnpm-workspace.yaml"))) {
       if (baseBranch?.trim() && branch?.trim()) {
         try {
           const scoped = deriveScopedPnpmTestCommand(rootDir, baseBranch.trim(), branch.trim());
@@ -178392,13 +178530,13 @@ function inferDefaultTestCommand(rootDir, explicitTestCommand, explicitBuildComm
     }
     return { command: "pnpm test", testSource: "inferred", buildSource };
   }
-  if (existsSync55(join69(rootDir, "yarn.lock"))) {
+  if (existsSync55(join70(rootDir, "yarn.lock"))) {
     return { command: "yarn test", testSource: "inferred", buildSource };
   }
-  if (existsSync55(join69(rootDir, "bun.lock")) || existsSync55(join69(rootDir, "bun.lockb"))) {
+  if (existsSync55(join70(rootDir, "bun.lock")) || existsSync55(join70(rootDir, "bun.lockb"))) {
     return { command: "bun test", testSource: "inferred", buildSource };
   }
-  if (existsSync55(join69(rootDir, "package-lock.json"))) {
+  if (existsSync55(join70(rootDir, "package-lock.json"))) {
     return { command: "npm test", testSource: "inferred", buildSource };
   }
   return null;
@@ -181390,7 +181528,7 @@ var init_merger_ref_update_advance = __esm({
 import { execFile as execFile21, spawn as spawn7 } from "node:child_process";
 import { promisify as promisify39 } from "node:util";
 import { copyFileSync, existsSync as existsSync56, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync2, readFileSync as readFileSync20, rmSync as rmSync7, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname32, join as join70 } from "node:path";
+import { dirname as dirname32, join as join71 } from "node:path";
 import { tmpdir as tmpdir7 } from "node:os";
 async function runGit4(args, cwd, timeoutMs) {
   const result = await execFileAsync14("git", ["-c", "core.quotePath=false", ...args], {
@@ -181476,9 +181614,9 @@ async function syncWorktreeToHead(input) {
   if (mode === "ff-only") {
     return { kind: "skipped-dirty", fromSha: previousSha, reason: "ff-only-mode-requires-clean-tree", dirtyFiles, untrackedFiles };
   }
-  const stageDir = mkdtempSync2(join70(tmpdir7(), "fusion-worktree-sync-"));
-  const patchPath = join70(stageDir, "edits.patch");
-  const untrackedDir = join70(stageDir, "untracked");
+  const stageDir = mkdtempSync2(join71(tmpdir7(), "fusion-worktree-sync-"));
+  const patchPath = join71(stageDir, "edits.patch");
+  const untrackedDir = join71(stageDir, "untracked");
   let preserveStageDir = false;
   try {
     mkdirSync9(untrackedDir, { recursive: true });
@@ -181498,8 +181636,8 @@ async function syncWorktreeToHead(input) {
       }
     }
     for (const rel of untrackedFiles) {
-      const src = join70(worktreePath, rel);
-      const dst = join70(untrackedDir, rel);
+      const src = join71(worktreePath, rel);
+      const dst = join71(untrackedDir, rel);
       try {
         mkdirSync9(dirname32(dst), { recursive: true });
         copyFileSync(src, dst);
@@ -181562,13 +181700,13 @@ async function syncWorktreeToHead(input) {
     const restored = [];
     const untrackedSkippedAsTracked = [];
     for (const rel of untrackedFiles) {
-      const src = join70(untrackedDir, rel);
+      const src = join71(untrackedDir, rel);
       if (!existsSync56(src)) continue;
       if (trackedAtHead.has(rel)) {
         untrackedSkippedAsTracked.push(rel);
         continue;
       }
-      const dst = join70(worktreePath, rel);
+      const dst = join71(worktreePath, rel);
       try {
         mkdirSync9(dirname32(dst), { recursive: true });
         const data = readFileSync20(src);
@@ -181637,8 +181775,8 @@ var init_worktree_ref_sync = __esm({
 
 // ../engine/src/merger-scope-auto-widen.ts
 import { exec as exec28 } from "node:child_process";
-import { readFile as readFile36, writeFile as writeFile27 } from "node:fs/promises";
-import { join as join71 } from "node:path";
+import { readFile as readFile37, writeFile as writeFile27 } from "node:fs/promises";
+import { join as join72 } from "node:path";
 import { promisify as promisify40 } from "node:util";
 function quoteArg4(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -181777,8 +181915,8 @@ function parseScopeEntries(section) {
 async function appendAutoWidenedScopeToPrompt(params) {
   const { store, taskId, files } = params;
   if (files.length === 0) return [];
-  const promptPath = join71(store.getTaskDir(taskId), "PROMPT.md");
-  const prompt = await readFile36(promptPath, "utf-8");
+  const promptPath = join72(store.getTaskDir(taskId), "PROMPT.md");
+  const prompt = await readFile37(promptPath, "utf-8");
   const { before, section, after } = splitPromptSections(prompt);
   const existing = parseScopeEntries(section);
   const toAdd = files.filter((file) => !existing.has(file));
@@ -181934,7 +182072,7 @@ import * as childProcess4 from "node:child_process";
 import { promisify as promisify41 } from "node:util";
 import { existsSync as existsSync57, readFileSync as readFileSync21, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
 import { createHash as createHash19 } from "node:crypto";
-import { join as join72, resolve as resolve36 } from "node:path";
+import { join as join73, resolve as resolve36 } from "node:path";
 import { hostname as hostname2 } from "node:os";
 import { Type as Type3 } from "typebox";
 function mergerCommitEnv() {
@@ -182247,7 +182385,7 @@ async function runDeterministicVerification(store, rootDir, taskId, testCommand,
   const deterministicVerificationMessage = "Running deterministic merge verification" + (hasTestCommand ? ` (test${testSourceDisplayLabel}: ${normalizedTestCommand})` : "") + (hasBuildCommand ? ` (build${buildSource === "inferred" ? " [inferred]" : ""}: ${normalizedBuildCommand})` : "");
   await store.logEntry(taskId, deterministicVerificationMessage);
   await store.appendAgentLog(taskId, deterministicVerificationMessage, "status", void 0, "merger");
-  const bootstrapScriptPath = join72(rootDir, "scripts/ensure-test-artifacts.mjs");
+  const bootstrapScriptPath = join73(rootDir, "scripts/ensure-test-artifacts.mjs");
   if (hasTestCommand || hasBuildCommand) {
     if (!existsSync57(bootstrapScriptPath)) {
       const bootstrapMissingMessage = `${taskId}: [verification:bootstrap] script missing at scripts/ensure-test-artifacts.mjs \u2014 skipping preamble`;
@@ -182746,7 +182884,7 @@ async function stashTreesEqual(rootDir, aSha, bSha) {
 }
 function writeActiveMergerStatus(rootDir, taskId) {
   try {
-    const statusPath = join72(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
+    const statusPath = join73(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
     const payload = {
       taskId,
       pid: process.pid,
@@ -182775,7 +182913,7 @@ function clearActiveMergerStatus(statusPath, taskId) {
 }
 function readActiveMergerStatus(rootDir) {
   try {
-    const statusPath = join72(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
+    const statusPath = join73(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
     if (!existsSync57(statusPath)) return null;
     const raw = readFileSync21(statusPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -183348,7 +183486,7 @@ async function findFilesWithConflictMarkers(rootDir, files) {
   const stillConflicted = [];
   for (const file of files) {
     try {
-      const fullPath = join72(rootDir, file);
+      const fullPath = join73(rootDir, file);
       if (!existsSync57(fullPath)) continue;
       const { stdout } = await execAsync27(
         `git grep -l -e "^<<<<<<< " -e "^=======$" -e "^>>>>>>> " --no-index -- ${quoteArg2(fullPath)}`,
@@ -183375,7 +183513,7 @@ async function tryRecoverHardFailApply(params) {
     if (!patchText.trim()) {
       mergerLog.warn(`${taskId}: autostash ${sha.slice(0, 7)} produced empty patch; cannot 3-way recover`);
     } else {
-      const patchPath = join72(rootDir, ".git", `fusion-autostash-${sha.slice(0, 7)}.patch`);
+      const patchPath = join73(rootDir, ".git", `fusion-autostash-${sha.slice(0, 7)}.patch`);
       writeFileSync9(patchPath, patchText, "utf-8");
       try {
         await execAsync27(`git apply --3way --whitespace=nowarn ${quoteArg2(patchPath)}`, { cwd: rootDir });
@@ -184863,13 +185001,13 @@ async function isCherryPickInProgress(rootDir) {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const cherryPickHeadPath = join72(rootDir, cherryPickHeadPathOut.trim());
+    const cherryPickHeadPath = join73(rootDir, cherryPickHeadPathOut.trim());
     if (existsSync57(cherryPickHeadPath)) return true;
     const { stdout: sequencerPathOut } = await execAsync27("git rev-parse --git-path sequencer", {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const sequencerPath = join72(rootDir, sequencerPathOut.trim());
+    const sequencerPath = join73(rootDir, sequencerPathOut.trim());
     return existsSync57(sequencerPath);
   } catch {
     return false;
@@ -189911,7 +190049,7 @@ var agent_reflection_exports = {};
 __export(agent_reflection_exports, {
   AgentReflectionService: () => AgentReflectionService
 });
-import { readFile as readFile39 } from "node:fs/promises";
+import { readFile as readFile40 } from "node:fs/promises";
 import { isAbsolute as isAbsolute20, resolve as resolve38 } from "node:path";
 var reflectionLog, REFLECTION_SYSTEM_PROMPT, DEFAULT_OUTCOME_LIMIT, AgentReflectionService;
 var init_agent_reflection = __esm({
@@ -190470,7 +190608,7 @@ Rules:
         if (agent.instructionsPath?.trim()) {
           const resolvedPath = isAbsolute20(agent.instructionsPath) ? agent.instructionsPath : resolve38(this.rootDir, agent.instructionsPath);
           try {
-            const content = await readFile39(resolvedPath, "utf-8");
+            const content = await readFile40(resolvedPath, "utf-8");
             if (content.trim()) {
               pieces.push(content.trim());
             }
@@ -194184,9 +194322,9 @@ var Scheduler = class {
 import { exec as exec37, execFile as execFile26, execSync as execSync7 } from "node:child_process";
 import { promisify as promisify52 } from "node:util";
 import { setImmediate as setImmediateCb3 } from "node:timers";
-import { basename as basename19, delimiter as delimiter2, isAbsolute as isAbsolute18, join as join78, relative as relative16, resolve as resolvePath3 } from "node:path";
+import { basename as basename19, delimiter as delimiter2, isAbsolute as isAbsolute18, join as join79, relative as relative16, resolve as resolvePath3 } from "node:path";
 import { existsSync as existsSync65, lstatSync as lstatSync3, realpathSync as realpathSync9 } from "node:fs";
-import { readFile as readFile37, rm as rm12, writeFile as writeFile29 } from "node:fs/promises";
+import { readFile as readFile38, rm as rm12, writeFile as writeFile29 } from "node:fs/promises";
 init_src2();
 
 // ../engine/src/auto-merge-finalization.ts
@@ -194637,16 +194775,16 @@ async function persistBranchState(persistence, state) {
     );
   }
 }
-function resolveJoinConfig(join84) {
-  const rawMode = join84.config?.mode;
+function resolveJoinConfig(join85) {
+  const rawMode = join85.config?.mode;
   let mode = "all";
   if (rawMode === "all" || rawMode === "any") mode = rawMode;
   else if (rawMode && typeof rawMode === "object" && "quorum" in rawMode) {
     const n = rawMode.quorum;
     if (typeof n === "number" && Number.isInteger(n) && n > 0) mode = { quorum: n };
-    else throw new WorkflowIrError(`join '${join84.id}' quorum must be a positive integer`);
+    else throw new WorkflowIrError(`join '${join85.id}' quorum must be a positive integer`);
   }
-  const rawFail = join84.config?.onBranchFailure;
+  const rawFail = join85.config?.onBranchFailure;
   const onBranchFailure = rawFail === "collect" ? "collect" : "fail-fast";
   return { mode, onBranchFailure };
 }
@@ -194662,9 +194800,9 @@ async function runSplitJoin(split, env) {
   if (branchEdges.length === 0) {
     throw new WorkflowIrError(`split '${split.id}' has no traversable branches`);
   }
-  const join84 = findMatchingJoin(branchEdges[0].to, env);
-  if (!join84) throw new WorkflowIrError(`split '${split.id}' has no reachable matching join`);
-  const joinConfig = resolveJoinConfig(env.nodeMap.get(join84));
+  const join85 = findMatchingJoin(branchEdges[0].to, env);
+  if (!join85) throw new WorkflowIrError(`split '${split.id}' has no reachable matching join`);
+  const joinConfig = resolveJoinConfig(env.nodeMap.get(join85));
   const controller = new AbortController();
   const branchCount = branchEdges.length;
   const required2 = requiredCompletions(joinConfig.mode, branchCount);
@@ -194700,7 +194838,7 @@ async function runSplitJoin(split, env) {
   };
   const branchPromises = branchEdges.map((edge) => {
     const branchId = edge.to;
-    return walkBranch(branchId, join84, env, controller.signal, visitedNodeIds).then((result) => {
+    return walkBranch(branchId, join85, env, controller.signal, visitedNodeIds).then((result) => {
       branchOutcomes.push({ branchId, outcome: result.outcome, nodeId: result.lastNodeId });
       if (result.outcome === "success") succeeded += 1;
       else failed += 1;
@@ -194718,7 +194856,7 @@ async function runSplitJoin(split, env) {
   });
   const outcome = await joinReached;
   await Promise.allSettled(branchPromises);
-  return { joinNodeId: join84, outcome, branchOutcomes, visitedNodeIds };
+  return { joinNodeId: join85, outcome, branchOutcomes, visitedNodeIds };
 }
 async function walkBranch(startNodeId, joinId, env, signal, visitedNodeIds) {
   let currentId = startNodeId;
@@ -198101,11 +198239,11 @@ init_active_session_registry();
 // ../engine/src/cli-agent/task-session.ts
 import { mkdtemp as mkdtemp3, rm as rm10 } from "node:fs/promises";
 import { tmpdir as tmpdir8 } from "node:os";
-import { join as join74 } from "node:path";
+import { join as join75 } from "node:path";
 
 // ../engine/src/cli-agent/hook-scripts.ts
 import { mkdir as mkdir28, rm as rm9, writeFile as writeFile28 } from "node:fs/promises";
-import { join as join73 } from "node:path";
+import { join as join74 } from "node:path";
 var HOOK_SCRIPT_NAMES = {
   /** Main hook script: POSTs stdin payload (with the hook event name) to the route. */
   hook: "fusion-hook.sh",
@@ -198187,8 +198325,8 @@ exit 0
 async function writeSessionHookScripts(opts) {
   const { sessionId, token, endpointUrl, dir } = opts;
   await mkdir28(dir, { recursive: true, mode: 448 });
-  const hookScriptPath = join73(dir, HOOK_SCRIPT_NAMES.hook);
-  const notifyScriptPath = join73(dir, HOOK_SCRIPT_NAMES.notify);
+  const hookScriptPath = join74(dir, HOOK_SCRIPT_NAMES.hook);
+  const notifyScriptPath = join74(dir, HOOK_SCRIPT_NAMES.notify);
   await writeFile28(hookScriptPath, buildHookScriptContent({ sessionId, token, endpointUrl }), {
     mode: 448
   });
@@ -198364,9 +198502,9 @@ var CliTaskSession = class _CliTaskSession {
       isApproved: opts.isAutonomyApproved ?? (() => false)
     });
     const root = opts.hookDirRoot ?? tmpdir8();
-    const hookDir = await mkdtemp3(join74(root, "fusion-cli-hooks-"));
-    const hookScriptPath = join74(hookDir, HOOK_SCRIPT_NAMES.hook);
-    const settingsPath = join74(hookDir, "settings.json");
+    const hookDir = await mkdtemp3(join75(root, "fusion-cli-hooks-"));
+    const hookScriptPath = join75(hookDir, HOOK_SCRIPT_NAMES.hook);
+    const settingsPath = join75(hookDir, "settings.json");
     const cliAgentSettings = opts.config.cliAgentSettings ?? null;
     const operatorEnvAdditions = (cliAgentSettings?.envAdditions ?? []).filter(
       (k2) => !/^FUSION_/i.test(k2)
@@ -198619,7 +198757,7 @@ function killLiveTaskSessions(taskId, manager, store) {
 // ../engine/src/pty-native.ts
 import * as fs7 from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
-import { join as join75, dirname as dirname33 } from "node:path";
+import { join as join76, dirname as dirname33 } from "node:path";
 var isBunBinary = typeof Bun !== "undefined" && !!Bun.embeddedFiles;
 var ptyModule = null;
 var ptyLoadError = null;
@@ -198633,12 +198771,12 @@ function findInstalledNodePtyNativeDir() {
   try {
     const packageJsonPath = require4.resolve("node-pty/package.json");
     const pkgRoot = dirname33(packageJsonPath);
-    const releaseDir = join75(pkgRoot, "build", "Release");
-    if (fs7.existsSync(join75(releaseDir, "pty.node"))) {
+    const releaseDir = join76(pkgRoot, "build", "Release");
+    if (fs7.existsSync(join76(releaseDir, "pty.node"))) {
       return releaseDir;
     }
-    const prebuildDir = join75(pkgRoot, "prebuilds", getNativePrebuildName());
-    if (fs7.existsSync(join75(prebuildDir, "pty.node"))) {
+    const prebuildDir = join76(pkgRoot, "prebuilds", getNativePrebuildName());
+    if (fs7.existsSync(join76(prebuildDir, "pty.node"))) {
       return prebuildDir;
     }
     return null;
@@ -198649,14 +198787,14 @@ function findInstalledNodePtyNativeDir() {
 function findStagedNativeDir() {
   const prebuildName = getNativePrebuildName();
   if (process.env.FUSION_RUNTIME_DIR) {
-    const envPath = join75(process.env.FUSION_RUNTIME_DIR, prebuildName);
-    if (fs7.existsSync(join75(envPath, "pty.node"))) {
+    const envPath = join76(process.env.FUSION_RUNTIME_DIR, prebuildName);
+    if (fs7.existsSync(join76(envPath, "pty.node"))) {
       return envPath;
     }
   }
   const execDir = dirname33(process.execPath);
-  const nextToBinary = join75(execDir, "runtime", prebuildName);
-  if (fs7.existsSync(join75(nextToBinary, "pty.node"))) {
+  const nextToBinary = join76(execDir, "runtime", prebuildName);
+  if (fs7.existsSync(join76(nextToBinary, "pty.node"))) {
     return nextToBinary;
   }
   return null;
@@ -198679,8 +198817,8 @@ function ensureNodePtyNativePermissions() {
     candidateDirs.add(installedNativeDir);
   }
   for (const nativeDir of candidateDirs) {
-    const helperPath = join75(nativeDir, "spawn-helper");
-    const nativeModulePath = join75(nativeDir, "pty.node");
+    const helperPath = join76(nativeDir, "spawn-helper");
+    const nativeModulePath = join76(nativeDir, "pty.node");
     try {
       fs7.chmodSync(helperPath, 493);
     } catch {
@@ -198710,7 +198848,7 @@ async function loadPtyModule() {
         process.env.NODE_PTY_SPAWN_HELPER_DIR = nativeDir;
       }
       process.env.FUSION_NATIVE_ASSETS_PATH = nativeDir;
-      const nativePath = join75(nativeDir, "pty.node");
+      const nativePath = join76(nativeDir, "pty.node");
       if (fs7.existsSync(nativePath)) {
         try {
           const nativeModule = { exports: {} };
@@ -201830,7 +201968,7 @@ import { promisify as promisify49 } from "node:util";
 import { setImmediate as setImmediateCb2 } from "node:timers";
 import { existsSync as existsSync63, mkdirSync as mkdirSync10, readdirSync as readdirSync10, readFileSync as readFileSync22, realpathSync as realpathSync8, rmSync as rmSync8, statSync as statSync12, writeFileSync as writeFileSync10 } from "node:fs";
 import { tmpdir as tmpdir9 } from "node:os";
-import { isAbsolute as isAbsolute15, join as join76, relative as relative13, resolve as resolve37 } from "node:path";
+import { isAbsolute as isAbsolute15, join as join77, relative as relative13, resolve as resolve37 } from "node:path";
 init_transient_error_detector();
 
 // ../engine/src/auto-claim-snapshot.ts
@@ -207253,9 +207391,9 @@ async function preserveWorktreeChanges(repoDir, worktreePath, taskId) {
       return null;
     }
     const diff = (await execAsync32("git diff HEAD --binary", { cwd: worktreePath, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 })).stdout;
-    const recoveryDir = join76(repoDir, ".fusion", "recovery");
+    const recoveryDir = join77(repoDir, ".fusion", "recovery");
     mkdirSync10(recoveryDir, { recursive: true });
-    const patchPath = join76(recoveryDir, `${taskId.toLowerCase()}-${formatRecoveryTimestamp()}.patch`);
+    const patchPath = join77(recoveryDir, `${taskId.toLowerCase()}-${formatRecoveryTimestamp()}.patch`);
     writeFileSync10(patchPath, diff, "utf-8");
     return patchPath;
   } catch (error2) {
@@ -208621,6 +208759,35 @@ var SelfHealingManager = class _SelfHealingManager {
     }
     return false;
   }
+  /**
+   * FNXC:WorkflowRecovery 2026-07-25-09:40:
+   * Single shared decision for "is this branch tip's foreign `Fusion-Task-Id`/`Fusion-Task-Lineage` trailer real
+   * evidence of cross-task contamination, or just an inherited start point?"
+   *
+   * A task branch cut from the integration branch points at whatever landed last. When the task has not committed
+   * anything of its own (planning aborted, spec revise, operator move back to `todo`), the branch tip IS that
+   * previous task's commit — a foreign trailer with zero foreign intent. FN-1406 hit exactly this: `fusion/fn-1406`
+   * was cut from `main` at FN-1401's landed commit, planning ended without a commit, and the reclaim sweep logged
+   * `already-merged rejected ... owner=FN-1401 reason=foreign-task-tip` every pass instead of clearing the stale
+   * worktree/branch metadata.
+   *
+   * Merge-base-to-tip diff proof separates the two: no unique diff means the branch carries no task content, so the
+   * foreign trailer is inherited and the caller may treat the row as stale metadata. The one exception is when the
+   * base ALREADY has an explicit commit for this task — then the branch should have been sitting on the task's own
+   * landed commit, and a foreign tip is genuine misbinding worth rejecting.
+   *
+   * Callers: already-merged recovery (`branchTipForeignOwnership`), branch-misbound recovery
+   * (`isBranchTipMisboundToTask`), and the self-owned-branch reclaim sweep's `tip-already-merged` arm. Keeping the
+   * three on one helper is the point — the reclaim arm drifted without the diff proof and that was the bug.
+   */
+  async foreignTipRejection(input) {
+    const { taskId, lineageId, branchTip, baseBranch, ownership } = input;
+    if (ownership.rejectionReason !== "foreign-task" && ownership.rejectionReason !== "foreign-lineage") return null;
+    const hasNoUniqueDiff = await this.branchHasNoUniqueDiff(branchTip, baseBranch).catch(() => false);
+    const baseAlreadyHasCurrentTask = hasNoUniqueDiff ? await this.baseHasExplicitTaskOwnership(taskId, lineageId, baseBranch).catch(() => false) : false;
+    if (hasNoUniqueDiff && !baseAlreadyHasCurrentTask) return null;
+    return ownership.rejectionReason === "foreign-task" ? { reason: "foreign-task-tip", owner: ownership.ownerTaskId } : { reason: "foreign-lineage-tip", owner: ownership.ownerLineageId };
+  }
   async rejectForeignAlreadyMergedCandidate(input) {
     const { task, candidateSha, candidateOwner, taskBranch, baseBranch, reason, phase } = input;
     await this.store.logEntry(
@@ -208662,20 +208829,14 @@ var SelfHealingManager = class _SelfHealingManager {
     }
     const sha = stdout.trim();
     if (!sha) return null;
-    const hasNoUniqueDiff = await this.branchHasNoUniqueDiff(sha, baseBranch).catch(() => false);
     let ownership;
     try {
       ownership = await this.readCommitTaskOwnership(sha, taskId, lineageId);
     } catch {
       return { sha, reason: "ownership-unverifiable" };
     }
-    const baseAlreadyHasCurrentTask = hasNoUniqueDiff ? await this.baseHasExplicitTaskOwnership(taskId, lineageId, baseBranch).catch(() => false) : false;
-    if ((!hasNoUniqueDiff || baseAlreadyHasCurrentTask) && ownership.rejectionReason === "foreign-task") {
-      return { sha, owner: ownership.ownerTaskId, reason: "foreign-task-tip" };
-    }
-    if ((!hasNoUniqueDiff || baseAlreadyHasCurrentTask) && ownership.rejectionReason === "foreign-lineage") {
-      return { sha, owner: ownership.ownerLineageId, reason: "foreign-lineage-tip" };
-    }
+    const rejection = await this.foreignTipRejection({ taskId, lineageId, branchTip: sha, baseBranch, ownership });
+    if (rejection) return { sha, owner: rejection.owner, reason: rejection.reason };
     return null;
   }
   async resolveSelfHealingMergeTarget(task, settings, phase) {
@@ -209891,14 +210052,21 @@ var SelfHealingManager = class _SelfHealingManager {
             if (!ownership) {
               continue;
             }
-            if (ownership?.rejectionReason === "foreign-task" || ownership?.rejectionReason === "foreign-lineage") {
+            const foreignRejection = await this.foreignTipRejection({
+              taskId: task.id,
+              lineageId: task.lineageId,
+              branchTip: inspection.tipSha,
+              baseBranch: inspection.integrationRef,
+              ownership
+            });
+            if (foreignRejection) {
               await this.rejectForeignAlreadyMergedCandidate({
                 task,
                 candidateSha: inspection.tipSha,
-                candidateOwner: ownership.rejectionReason === "foreign-task" ? ownership.ownerTaskId : ownership.ownerLineageId,
+                candidateOwner: foreignRejection.owner,
                 taskBranch: branchName,
                 baseBranch: inspection.integrationRef,
-                reason: ownership.rejectionReason === "foreign-task" ? "foreign-task-tip" : "foreign-lineage-tip",
+                reason: foreignRejection.reason,
                 phase: "tip-already-merged"
               });
               continue;
@@ -213838,7 +214006,7 @@ var SelfHealingManager = class _SelfHealingManager {
           const unrecoverableRepos = [];
           for (const repoRel of repoKeys) {
             const entry = workspaceWorktrees[repoRel];
-            const repoRootDir = join76(this.options.rootDir, repoRel);
+            const repoRootDir = join77(this.options.rootDir, repoRel);
             let integrationBranch;
             try {
               integrationBranch = await resolveIntegrationBranch(
@@ -214132,7 +214300,7 @@ var SelfHealingManager = class _SelfHealingManager {
           if ((this.orphanWorktreeRemovalFailures.get(worktreePath) ?? 0) >= MAX_STARVATION_DROPS) {
             continue;
           }
-          const repoRootDir = join76(this.options.rootDir, repoRel);
+          const repoRootDir = join77(this.options.rootDir, repoRel);
           let success = false;
           let reason = "removed";
           try {
@@ -215053,7 +215221,7 @@ var SelfHealingManager = class _SelfHealingManager {
     if (testWorkerRoot) {
       try {
         for (const entry of readdirSync10(testWorkerRoot)) {
-          if (entry.startsWith("redir-")) roots.push(join76(testWorkerRoot, entry));
+          if (entry.startsWith("redir-")) roots.push(join77(testWorkerRoot, entry));
         }
       } catch {
       }
@@ -215067,7 +215235,7 @@ var SelfHealingManager = class _SelfHealingManager {
       } catch {
         continue;
       }
-      for (const entry of entries) paths2.push(join76(root, entry));
+      for (const entry of entries) paths2.push(join77(root, entry));
     }
     return paths2;
   }
@@ -215303,14 +215471,10 @@ var SelfHealingManager = class _SelfHealingManager {
       maxBuffer: 1024 * 1024
     });
     const branchTip = tipOut.trim();
-    const hasNoUniqueDiff = await this.branchHasNoUniqueDiff(branchTip, baseBranch).catch(() => false);
     const ownership = await this.readCommitTaskOwnership(branchTip, taskId, lineageId);
-    const baseAlreadyHasCurrentTask = hasNoUniqueDiff ? await this.baseHasExplicitTaskOwnership(taskId, lineageId, baseBranch).catch(() => false) : false;
-    if ((!hasNoUniqueDiff || baseAlreadyHasCurrentTask) && ownership.rejectionReason === "foreign-task") {
-      return { misbound: false, branchTip, landed: null, rejection: { reason: "foreign-task-tip", owner: ownership.ownerTaskId } };
-    }
-    if ((!hasNoUniqueDiff || baseAlreadyHasCurrentTask) && ownership.rejectionReason === "foreign-lineage") {
-      return { misbound: false, branchTip, landed: null, rejection: { reason: "foreign-lineage-tip", owner: ownership.ownerLineageId } };
+    const rejection = await this.foreignTipRejection({ taskId, lineageId, branchTip, baseBranch, ownership });
+    if (rejection) {
+      return { misbound: false, branchTip, landed: null, rejection };
     }
     const hasTaskId = ownership.ownerTaskId === taskId;
     const hasLineage = lineageId ? ownership.ownerLineageId === lineageId : false;
@@ -216972,7 +217136,7 @@ var SelfHealingManager = class _SelfHealingManager {
       let processedMarkers = 0;
       for (const task of candidates) {
         try {
-          const promptPath = join76(this.options.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+          const promptPath = join77(this.options.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
           if (!existsSync63(promptPath)) {
             continue;
           }
@@ -217359,7 +217523,7 @@ var SelfHealingManager = class _SelfHealingManager {
     if (!existsSync63(worktreesDir)) return 0;
     let dirs;
     try {
-      dirs = readdirSync10(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join76(worktreesDir, e.name));
+      dirs = readdirSync10(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !isAiMergeContainerDir(e.name)).map((e) => join77(worktreesDir, e.name));
     } catch (err) {
       log28.warn(`Failed to read .worktrees/ for unregistered orphan reap: ${err instanceof Error ? err.message : String(err)}`);
       return 0;
@@ -217429,7 +217593,7 @@ var SelfHealingManager = class _SelfHealingManager {
         }
         if (entries.length === 0) continue;
         for (const entry of entries) {
-          const path5 = join76(tempRoot, entry);
+          const path5 = join77(tempRoot, entry);
           let canonicalPath = path5;
           let cleanupReason = "stale";
           try {
@@ -217821,7 +217985,7 @@ init_src2();
 init_logger();
 init_verification_concurrency();
 import { existsSync as existsSync64, readdirSync as readdirSync11, readFileSync as readFileSync23 } from "node:fs";
-import { isAbsolute as isAbsolute16, join as join77, relative as relative14 } from "node:path";
+import { isAbsolute as isAbsolute16, join as join78, relative as relative14 } from "node:path";
 import { Type as Type5 } from "@earendil-works/pi-ai";
 var MAX_OUTPUT_BYTES = 200 * 1024;
 var QUIET_HEARTBEAT_INTERVAL_MS = 6e4;
@@ -217946,7 +218110,7 @@ function findWorkspacePackageDir(rootDir, packageName) {
   for (const candidate of candidates) {
     if (!candidate) continue;
     try {
-      const pkg = JSON.parse(readFileSync23(join77(rootDir, candidate, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync23(join78(rootDir, candidate, "package.json"), "utf8"));
       if (pkg.name === packageName) {
         packageDirCache.set(cacheKey, candidate);
         return candidate;
@@ -217961,7 +218125,7 @@ function findWorkspacePackageDir(rootDir, packageName) {
   while (queue.length > 0) {
     const current = queue.shift();
     if (!current) break;
-    const abs = join77(rootDir, current.dir);
+    const abs = join78(rootDir, current.dir);
     let entries;
     try {
       entries = readdirSync11(abs, { withFileTypes: true });
@@ -217971,9 +218135,9 @@ function findWorkspacePackageDir(rootDir, packageName) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name === "node_modules" || entry.name === "dist") continue;
-      const child = join77(current.dir, entry.name);
+      const child = join78(current.dir, entry.name);
       try {
-        const pkg = JSON.parse(readFileSync23(join77(rootDir, child, "package.json"), "utf8"));
+        const pkg = JSON.parse(readFileSync23(join78(rootDir, child, "package.json"), "utf8"));
         if (pkg.name === packageName) {
           packageDirCache.set(cacheKey, child);
           return child;
@@ -217993,7 +218157,7 @@ function toPackageRelativeFilter(token, rootDir, packageDir) {
     return normalized.slice(normalizedPackageDir.length + 1);
   }
   if (isAbsolute16(token)) {
-    const rel = relative14(join77(rootDir, packageDir), token).replace(/\\/g, "/");
+    const rel = relative14(join78(rootDir, packageDir), token).replace(/\\/g, "/");
     if (!rel.startsWith("../") && rel !== "..") return rel;
   }
   return token;
@@ -218281,7 +218445,7 @@ function createRunVerificationTool(opts) {
       if (params.cwd && isAbsolute16(params.cwd)) {
         resolvedCwd = params.cwd;
       } else if (params.cwd) {
-        resolvedCwd = join77(worktreePath, params.cwd);
+        resolvedCwd = join78(worktreePath, params.cwd);
       } else {
         resolvedCwd = worktreePath;
       }
@@ -218314,7 +218478,7 @@ function createRunVerificationTool(opts) {
         warnings.push(...normalized.warnings);
       }
       if (effectiveCommand.trimStart().startsWith("pnpm --filter")) {
-        const modulesYaml = join77(rootDir, "node_modules", ".modules.yaml");
+        const modulesYaml = join78(rootDir, "node_modules", ".modules.yaml");
         if (!existsSync64(modulesYaml)) {
           const installCmd = "pnpm install --prefer-offline";
           const msg = `node_modules/.modules.yaml not found in workspace root \u2014 auto-prepending \`${installCmd}\` before running the command.`;
@@ -218604,7 +218768,7 @@ function isWorkflowStepSkillDiscoverable(skillName, additionalSkillPaths, ceSkil
     return false;
   }
   return (additionalSkillPaths ?? []).some(
-    (skillPath) => basename19(skillPath) === bareSkillName && existsSync65(join78(skillPath, "SKILL.md")) || existsSync65(join78(skillPath, bareSkillName, "SKILL.md"))
+    (skillPath) => basename19(skillPath) === bareSkillName && existsSync65(join79(skillPath, "SKILL.md")) || existsSync65(join79(skillPath, bareSkillName, "SKILL.md"))
   );
 }
 var yieldEventLoop3 = () => new Promise((resolve40) => setImmediateCb3(resolve40));
@@ -218932,7 +219096,7 @@ function normalizeWorktreePath(pathValue) {
 }
 async function extractPersistedSessionWorktreePath(sessionFile, rootDir, settings) {
   try {
-    const content = await readFile37(sessionFile, "utf-8");
+    const content = await readFile38(sessionFile, "utf-8");
     const matches = content.match(buildSessionWorktreePathRegex(rootDir, settings)) ?? [];
     if (matches.length === 0) return null;
     const normalizedCounts = /* @__PURE__ */ new Map();
@@ -222007,7 +222171,7 @@ ${info.feedback}`, revisionKey),
       const authoritativeAgentLayer = this.store.getAsyncLayer();
       if (!this.authoritativeAssignedAgentStore || authoritativeAgentLayer && !this.authoritativeAssignedAgentStore.backendMode) {
         this.authoritativeAssignedAgentStore = new AgentStore({
-          rootDir: join78(this.rootDir, ".fusion"),
+          rootDir: join79(this.rootDir, ".fusion"),
           taskStore: this.store,
           ...authoritativeAgentLayer ? { asyncLayer: authoritativeAgentLayer } : {}
         });
@@ -226467,7 +226631,7 @@ Graph value: ${failureValue}` : ""}`, budget.key),
     const activeMergeStatuses = /* @__PURE__ */ new Set(["merging", "merging-pr", "merging-fix"]);
     const isActiveTask = activeColumns.has(task.column) || activeMergeStatuses.has(task.status ?? "");
     if (!isActiveTask) {
-      const tasksDir = join78(this.store.getFusionDir(), "tasks");
+      const tasksDir = join79(this.store.getFusionDir(), "tasks");
       const promptPath = getPromptPath(tasksDir, task.id);
       const staleness = await evaluateSpecStaleness({ settings, promptPath, task });
       if (staleness.isStale) {
@@ -230328,10 +230492,10 @@ Please fix the issues so the verification can pass on the next attempt.`,
    * The section is replaced entirely to avoid accumulation of old feedback.
    */
   async injectWorkflowStepFailureInstructions(task, failureFeedback, stepName, retry) {
-    const promptPath = join78(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
+    const promptPath = join79(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
     let content;
     try {
-      content = await readFile37(promptPath, "utf-8");
+      content = await readFile38(promptPath, "utf-8");
     } catch {
       executorLog.warn(`${task.id}: PROMPT.md not found at ${promptPath}, skipping workflow failure injection`);
       return;
@@ -241504,7 +241668,7 @@ init_effective_settings();
 
 // ../engine/src/spec-validation/task-document-references.ts
 import { access as access9 } from "node:fs/promises";
-import { join as join79 } from "node:path";
+import { join as join80 } from "node:path";
 var TASK_PATH_REGEX = /\.fusion\/tasks\/[A-Z0-9]+(?:-[A-Z0-9]+)*\/[^\s`'"\]]+/g;
 function normalizePathToken(token) {
   return token.replace(/^[`([{"']+/, "").replace(/[`),.;:!?\]}'"]+$/, "");
@@ -241593,7 +241757,7 @@ async function detectDanglingTaskDocReferences(promptContent, opts) {
   }
   const dangling = [];
   for (const [path5, sections] of references.entries()) {
-    const absPath = join79(opts.rootDir, path5);
+    const absPath = join80(opts.rootDir, path5);
     if (await existsImpl(absPath)) continue;
     dangling.push({ path: path5, sections: Array.from(sections).sort() });
   }
@@ -241616,14 +241780,15 @@ init_agent_logger();
 init_agent_instructions();
 init_fallback_model_observer();
 init_logger();
+init_plan_artifact_writeback();
 init_mcp_resolution();
 init_usage_limit_detector();
 init_transient_error_detector();
 init_rate_limit_retry();
 init_agent_tools();
 import { exec as exec41 } from "node:child_process";
-import { readFile as readFile38, writeFile as writeFile30, rm as rm13 } from "node:fs/promises";
-import { join as join80 } from "node:path";
+import { readFile as readFile39, writeFile as writeFile30, rm as rm13 } from "node:fs/promises";
+import { join as join81 } from "node:path";
 import { promisify as promisify56 } from "node:util";
 
 // ../engine/src/triage-preflight.ts
@@ -242299,8 +242464,8 @@ var TriageProcessor = class _TriageProcessor {
     }
     const settings = await mergeEffectiveSettings(this.store, task, await this.store.getSettings());
     const approvalRequired = resolvePlanApprovalRequired(settings);
-    const promptPath = join80(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
-    const written = await readFile38(promptPath, "utf-8").catch((err) => {
+    const promptPath = join81(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+    const written = await readFile39(promptPath, "utf-8").catch((err) => {
       const msg = err instanceof Error ? err.message : String(err);
       planLog.warn(`${task.id}: failed to read PROMPT.md during planning recovery (${promptPath}): ${msg}`);
       return "";
@@ -242338,8 +242503,8 @@ var TriageProcessor = class _TriageProcessor {
     return true;
   }
   async readNonEmptyPromptDraft(taskId, context) {
-    const promptPath = join80(this.rootDir, ".fusion", "tasks", taskId, "PROMPT.md");
-    const written = await readFile38(promptPath, "utf-8").catch((err) => {
+    const promptPath = join81(this.rootDir, ".fusion", "tasks", taskId, "PROMPT.md");
+    const written = await readFile39(promptPath, "utf-8").catch((err) => {
       const msg = err instanceof Error ? err.message : String(err);
       planLog.warn(`${taskId}: failed to read PROMPT.md during ${context} (${promptPath}): ${msg}`);
       return "";
@@ -242503,8 +242668,8 @@ var TriageProcessor = class _TriageProcessor {
         continue;
       }
       try {
-        const promptPath = join80(this.rootDir, ".fusion", "tasks", todoTask.id, "PROMPT.md");
-        const content = await readFile38(promptPath, "utf-8");
+        const promptPath = join81(this.rootDir, ".fusion", "tasks", todoTask.id, "PROMPT.md");
+        const content = await readFile39(promptPath, "utf-8");
         if (isUnplannedSeedPrompt(content, todoTask.id, todoTask.title, todoTask.description)) {
           eligibleTodoTasks.push(todoTask);
         }
@@ -242715,7 +242880,7 @@ var TriageProcessor = class _TriageProcessor {
       const detail = await this.store.getTask(task.id);
       const currentTask = detail ?? task;
       const settings = await mergeEffectiveSettings(this.store, currentTask, await this.store.getSettings());
-      const promptPath = `.fusion/tasks/${task.id}/PROMPT.md`;
+      const promptPath = relativePromptPath(task.id);
       const isFast = task.executionMode === "fast";
       const leanPlanning = settings.leanPlanning === true || isFast;
       const agentWork = async () => {
@@ -243051,8 +243216,22 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
             }
             return;
           }
-          const written = await readFile38(
-            join80(this.rootDir, promptPath),
+          const planPersistence = await persistPlanArtifact({
+            store: this.store,
+            taskId: task.id,
+            rootDir: this.rootDir,
+            planningCwd,
+            author: "triage",
+            logger: { log: (m2) => planLog.log(m2), warn: (m2) => planLog.warn(m2) }
+          });
+          if (planPersistence.outcome === "recovered") {
+            await this.store.logEntry(
+              task.id,
+              "Recovered the plan written inside the task worktree into the project .fusion folder"
+            ).catch(() => void 0);
+          }
+          const written = await readFile39(
+            join81(this.rootDir, promptPath),
             "utf-8"
           ).catch((err) => {
             const msg = err instanceof Error ? err.message : String(err);
@@ -243669,7 +243848,7 @@ Remove or replace these ids and call fn_task_create again.`
       if (isNearDuplicateCanonicalInactive(canonicalTask ?? void 0)) {
         if (canClearInactiveMarker) {
           if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
-            await rm13(join80(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+            await rm13(join81(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
           })) return;
           await this.updatePlanningStateIfStillCurrent(task, { paused: false, pausedReason: null, status: null });
         }
@@ -243680,7 +243859,7 @@ Remove or replace these ids and call fn_task_create again.`
       if (resolution === "prompt" && keepAcknowledged) {
         if (canClearInactiveMarker) {
           if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
-            await rm13(join80(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+            await rm13(join81(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
           })) return;
           await this.updatePlanningStateIfStillCurrent(task, {
             paused: false,
@@ -243721,7 +243900,7 @@ Remove or replace these ids and call fn_task_create again.`
         return;
       }
       if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
-        await rm13(join80(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
+        await rm13(join81(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md"), { force: true });
       })) return;
       if (!await this.updatePlanningStateIfStillCurrent(task, {
         paused: false,
@@ -243786,7 +243965,7 @@ Remove or replace these ids and call fn_task_create again.`
       let nextPrompt = applyOriginalDescription(written, originalDescription);
       nextPrompt = applyFrontendUxCriteria(nextPrompt, parsedFileScope);
       if (nextPrompt !== written) {
-        const promptPath = join80(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+        const promptPath = join81(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
         try {
           if (!await this.runIfStillPlanningUnderTaskLock(task, async () => {
             await writeFile30(promptPath, nextPrompt, "utf-8");
@@ -243798,6 +243977,10 @@ Remove or replace these ids and call fn_task_create again.`
         }
       }
     }
+    await mirrorPlanToProjectDb(this.store, task.id, written, {
+      author: "triage",
+      logger: { warn: (m2) => planLog.warn(m2) }
+    });
     let taskIntentSignature = {
       routePaths: [],
       filePaths: [],
@@ -244074,10 +244257,10 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
   if (!attachments || attachments.length === 0) {
     return { attachmentContents, imageContents };
   }
-  const { readFile: readFile40 } = await import("node:fs/promises");
-  const { join: join84 } = await import("node:path");
+  const { readFile: readFile41 } = await import("node:fs/promises");
+  const { join: join85 } = await import("node:path");
   for (const att of attachments) {
-    const filePath = join84(
+    const filePath = join85(
       rootDir,
       ".fusion",
       "tasks",
@@ -244087,7 +244270,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
     );
     try {
       if (IMAGE_MIME_TYPES.has(att.mimeType)) {
-        const data = await readFile40(filePath);
+        const data = await readFile41(filePath);
         const detectedMimeType = detectImageMimeFromBytes(data);
         const imageMimeType = detectedMimeType ?? att.mimeType;
         if (detectedMimeType && detectedMimeType !== att.mimeType) {
@@ -244104,7 +244287,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
           text: null
         });
       } else {
-        const data = await readFile40(filePath, "utf-8");
+        const data = await readFile41(filePath, "utf-8");
         const text2 = data.length > TEXT_INLINE_LIMIT ? data.slice(0, TEXT_INLINE_LIMIT) + "\n... (truncated at 50KB)" : data;
         attachmentContents.push({
           originalName: att.originalName,
@@ -247464,7 +247647,7 @@ function extractAdvisorAssistantText(session) {
 // ../engine/src/overseer-watchdog.ts
 init_logger();
 import { existsSync as existsSync67, readFileSync as readFileSync24 } from "node:fs";
-import { dirname as dirname34, join as join81, relative as relative17, resolve as resolve39, sep as sep11 } from "node:path";
+import { dirname as dirname34, join as join82, relative as relative17, resolve as resolve39, sep as sep11 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 var log32 = createLogger("overseer-watchdog");
 var WATCHDOG_FILENAMES = ["OVERSEER.md", "WATCHDOG.md"];
@@ -247495,7 +247678,7 @@ function discoverOverseerWatchdogFiles(options) {
     };
     if (agentDir) {
       for (const name2 of WATCHDOG_FILENAMES) {
-        tryAdd(join81(agentDir, name2), "user", 999);
+        tryAdd(join82(agentDir, name2), "user", 999);
       }
     }
     let current = cwd;
@@ -247503,9 +247686,9 @@ function discoverOverseerWatchdogFiles(options) {
     for (let hop = 0; hop < 64; hop++) {
       const depth = relative17(cwd, current) === "" ? 0 : relative17(cwd, current).split(sep11).filter(Boolean).length;
       for (const name2 of WATCHDOG_FILENAMES) {
-        tryAdd(join81(current, name2), "project", depth);
-        tryAdd(join81(current, ".fusion", name2), "project", depth);
-        tryAdd(join81(current, ".omp", name2), "project", depth);
+        tryAdd(join82(current, name2), "project", depth);
+        tryAdd(join82(current, ".fusion", name2), "project", depth);
+        tryAdd(join82(current, ".omp", name2), "project", depth);
       }
       if (current === stopAt) break;
       const parent = dirname34(current);
@@ -248470,7 +248653,7 @@ import { promisify as promisify58 } from "node:util";
 import { realpathSync as realpathSync11, readdirSync as readdirSync13 } from "node:fs";
 import { mkdtemp as mkdtemp4 } from "node:fs/promises";
 import { tmpdir as tmpdir11 } from "node:os";
-import { join as join83 } from "node:path";
+import { join as join84 } from "node:path";
 
 // ../engine/src/overseer-noop-finalize-veto.ts
 init_src2();
@@ -248564,7 +248747,7 @@ import { execFile as execFile28 } from "node:child_process";
 import { appendFileSync as appendFileSync2, existsSync as existsSync68, mkdirSync as mkdirSync11, readdirSync as readdirSync12, readFileSync as readFileSync25, realpathSync as realpathSync10, rmSync as rmSync9, statSync as statSync13 } from "node:fs";
 import { rm as rm14 } from "node:fs/promises";
 import { tmpdir as tmpdir10 } from "node:os";
-import { isAbsolute as isAbsolute21, join as join82, relative as relative18 } from "node:path";
+import { isAbsolute as isAbsolute21, join as join83, relative as relative18 } from "node:path";
 import { promisify as promisify57 } from "node:util";
 init_worktree_paths();
 var execFileAsync21 = promisify57(execFile28);
@@ -248597,7 +248780,7 @@ function isBenignAbsentWorktreeError(err) {
   return /is not a working tree|No such file or directory|spawn\s+.*\bENOENT\b/i.test(description);
 }
 function ensureAiMergeRootIgnored(projectRootDir, settings) {
-  const excludePath = join82(projectRootDir, ".git", "info", "exclude");
+  const excludePath = join83(projectRootDir, ".git", "info", "exclude");
   if (!existsSync68(excludePath)) return;
   try {
     const current = readFileSync25(excludePath, "utf-8");
@@ -248629,7 +248812,7 @@ function getAiMergeTempSearchRoots(projectRootDir, settings) {
   if (testWorkerRoot) {
     try {
       for (const entry of readdirSync12(testWorkerRoot)) {
-        if (entry.startsWith("redir-")) roots.push(join82(testWorkerRoot, entry));
+        if (entry.startsWith("redir-")) roots.push(join83(testWorkerRoot, entry));
       }
     } catch {
     }
@@ -248652,7 +248835,7 @@ async function pruneExistingAiMergeWorktrees(taskId, projectRootDir, audit, log3
       continue;
     }
     for (const entry of entries) {
-      const candidatePath = join82(tempRoot, entry);
+      const candidatePath = join83(tempRoot, entry);
       let canonicalPath = candidatePath;
       try {
         canonicalPath = realpathSync10(candidatePath);
@@ -249128,7 +249311,7 @@ function listAiMergeWorktreeCandidates(taskId, projectRootDir, settings) {
   if (testWorkerRoot) {
     try {
       for (const entry of readdirSync13(testWorkerRoot)) {
-        if (entry.startsWith("redir-")) roots.push(join83(testWorkerRoot, entry));
+        if (entry.startsWith("redir-")) roots.push(join84(testWorkerRoot, entry));
       }
     } catch {
     }
@@ -249141,7 +249324,7 @@ function listAiMergeWorktreeCandidates(taskId, projectRootDir, settings) {
     } catch {
       continue;
     }
-    for (const entry of entries) candidates.push(join83(root, entry));
+    for (const entry of entries) candidates.push(join84(root, entry));
   }
   return candidates;
 }
@@ -249485,7 +249668,7 @@ async function landOneRepo(repoRootDir, branch, integrationBranch, ctx) {
       registeredMergePaths.add(pathToRegister);
     };
     try {
-      mergeRoot = await mkdtemp4(join83(resolveAiMergeRoot(repoRootDir, settings), `fusion-ai-merge-${taskId.toLowerCase()}-`));
+      mergeRoot = await mkdtemp4(join84(resolveAiMergeRoot(repoRootDir, settings), `fusion-ai-merge-${taskId.toLowerCase()}-`));
       registerMergeRoot(mergeRoot);
       await git5(["worktree", "add", "--detach", mergeRoot, tipSha], repoRootDir);
       worktreeAdded = true;
@@ -250002,7 +250185,7 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
     for (const repoRel of repoKeys) {
       throwIfAborted2(options.signal, taskId);
       const entry = workspaceWorktrees[repoRel];
-      const repoRootDir = join83(workspaceRootDir, repoRel);
+      const repoRootDir = join84(workspaceRootDir, repoRel);
       let integrationBranch;
       try {
         integrationBranch = await resolveIntegrationBranch(
@@ -250319,7 +250502,7 @@ async function pushAfterMergeToRemote(input) {
   let worktreeAdded = false;
   const registeredPaths = /* @__PURE__ */ new Set();
   try {
-    pushRoot = await mkdtemp4(join83(resolveAiMergeRoot(projectRootDir, settings), `fusion-ai-merge-push-${taskId.toLowerCase()}-`));
+    pushRoot = await mkdtemp4(join84(resolveAiMergeRoot(projectRootDir, settings), `fusion-ai-merge-push-${taskId.toLowerCase()}-`));
     for (const p2 of [pushRoot]) {
       activeSessionRegistry.registerPath(p2, { taskId, kind: "ai-merge", ownerKey: `ai-merge-push:${taskId}` });
       registeredPaths.add(p2);