@runfusion/fusion 0.24.0 → 0.25.0

package/dist/extension.js

@@ -68,6 +68,8 @@ var init_settings_schema = __esm({
         "awaiting-approval",
         "awaiting-user-review",
         "planning-awaiting-input",
+        "message:agent-to-user",
+        "message:agent-to-agent",
         "gridlock",
         "fallback-used",
         "memory-dreams-processed"
@@ -274,6 +276,11 @@ var init_settings_schema = __esm({
       autoBackupSchedule: "0 2 * * *",
       autoBackupRetention: 7,
       autoBackupDir: ".fusion/backups",
+      memoryBackupEnabled: false,
+      memoryBackupSchedule: "0 3 * * *",
+      memoryBackupRetention: 14,
+      memoryBackupDir: ".fusion/backups/memory",
+      memoryBackupScope: "all",
       autoSummarizeTitles: false,
       useAiMergeCommitSummary: true,
       titleSummarizerProvider: void 0,
@@ -4236,6 +4243,7 @@ This means a caller passed a .fusion directory where a project root was expected
           `INSERT OR IGNORE INTO __meta (key, value) VALUES ('lastModified', '${Date.now()}')`
         );
         this.migrate();
+        this.ensureTasksSchemaCompatibility();
         this.ensureRoutinesSchemaCompatibility();
         this.ensureInsightRunsSchemaCompatibility();
         this.ensureEvalTaskResultsSchemaCompatibility();
@@ -4255,6 +4263,27 @@ This means a caller passed a .fusion directory where a project root was expected
        * Column additions use `hasColumn()` so they are idempotent — safe to
        * re-run even if a previous migration partially applied.
        */
+      /**
+       * Applies idempotent compatibility fixes for legacy tasks checkout lease columns.
+       *
+       * FN-3879 documented a self-heal for missing checkout lease columns, but the
+       * original column adds lived only in the `version < 20` migration block. Some
+       * legacy/mesh-synced databases report `schemaVersion >= 20` despite never
+       * receiving those columns, so task listing queries can fail with `no such
+       * column: checkoutNodeId`. Running this unconditionally on init guarantees the
+       * canonical lease columns exist.
+       */
+      ensureTasksSchemaCompatibility() {
+        if (!this.hasTable("tasks")) {
+          return;
+        }
+        this.addColumnIfMissing("tasks", "checkedOutBy", "TEXT");
+        this.addColumnIfMissing("tasks", "checkedOutAt", "TEXT");
+        this.addColumnIfMissing("tasks", "checkoutNodeId", "TEXT");
+        this.addColumnIfMissing("tasks", "checkoutRunId", "TEXT");
+        this.addColumnIfMissing("tasks", "checkoutLeaseRenewedAt", "TEXT");
+        this.addColumnIfMissing("tasks", "checkoutLeaseEpoch", "INTEGER DEFAULT 0");
+      }
       /**
        * Applies idempotent compatibility fixes for legacy routines table shapes.
        *
@@ -7301,17 +7330,17 @@ var init_agent_store = __esm({
        * @returns Matching agent when unambiguous; otherwise null
        */
       async resolveAgent(shortname) {
-        const normalize4 = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+        const normalize5 = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
         const all = await this.listAgents();
         const exact = all.find((agent) => agent.id === shortname);
         if (exact) {
           return exact;
         }
-        const normalizedTarget = normalize4(shortname);
+        const normalizedTarget = normalize5(shortname);
         if (!normalizedTarget) {
           return null;
         }
-        const matches = all.filter((agent) => normalize4(agent.name) === normalizedTarget);
+        const matches = all.filter((agent) => normalize5(agent.name) === normalizedTarget);
         return matches.length === 1 ? matches[0] : null;
       }
       // ─────────────────────────────────────────────────────────────────────────
@@ -8928,9 +8957,9 @@ var init_global_settings = __esm({
        * Serialize operations via promise chain to prevent lost-update races.
        */
       withLock(fn) {
-        let resolve23;
+        let resolve24;
         const next = new Promise((r) => {
-          resolve23 = r;
+          resolve24 = r;
         });
         const prev = this.lock;
         this.lock = next;
@@ -8938,7 +8967,7 @@ var init_global_settings = __esm({
           try {
             return await fn();
           } finally {
-            resolve23();
+            resolve24();
           }
         });
       }
@@ -31410,8 +31439,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static async parseFile(filePath) {
-        const { readFile: readFile22 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
-        const data = await readFile22(filePath, "utf8");
+        const { readFile: readFile23 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
+        const data = await readFile23(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -31641,9 +31670,9 @@ var init_automation_store = __esm({
        */
       withScheduleLock(id, fn) {
         const prev = this.scheduleLocks.get(id) ?? Promise.resolve();
-        let resolve23;
+        let resolve24;
         const next = new Promise((r) => {
-          resolve23 = r;
+          resolve24 = r;
         });
         this.scheduleLocks.set(id, next);
         return prev.then(async () => {
@@ -31653,7 +31682,7 @@ var init_automation_store = __esm({
             if (this.scheduleLocks.get(id) === next) {
               this.scheduleLocks.delete(id);
             }
-            resolve23();
+            resolve24();
           }
         });
       }
@@ -32362,8 +32391,8 @@ async function writeProjectMemoryFile(rootDir, path2, content) {
   await mkdir6(dirname5(absPath), { recursive: true });
   const tmpPath = `${absPath}.tmp`;
   await writeFile5(tmpPath, content, "utf-8");
-  const { rename: rename6 } = await import("node:fs/promises");
-  await rename6(tmpPath, absPath);
+  const { rename: rename7 } = await import("node:fs/promises");
+  await rename7(tmpPath, absPath);
   return { success: true, backend: "file" };
 }
 async function listAgentMemoryFiles(rootDir, agentId, date = /* @__PURE__ */ new Date()) {
@@ -32481,8 +32510,8 @@ async function writeAgentMemoryFile(rootDir, agentId, path2, content) {
   await mkdir6(dirname5(absPath), { recursive: true });
   const tmpPath = `${absPath}.tmp`;
   await writeFile5(tmpPath, content, "utf-8");
-  const { rename: rename6 } = await import("node:fs/promises");
-  await rename6(tmpPath, absPath);
+  const { rename: rename7 } = await import("node:fs/promises");
+  await rename7(tmpPath, absPath);
   return { success: true };
 }
 function isPathTraversal(path2) {
@@ -32984,8 +33013,8 @@ var init_memory_backend = __esm({
           }
           const tmpPath = filePath + ".tmp";
           await writeFile5(tmpPath, content, "utf-8");
-          const { rename: rename6 } = await import("node:fs/promises");
-          await rename6(tmpPath, filePath);
+          const { rename: rename7 } = await import("node:fs/promises");
+          await rename7(tmpPath, filePath);
           return {
             success: true,
             backend: this.type
@@ -33432,7 +33461,7 @@ var init_project_memory = __esm({
 // ../core/src/run-command.ts
 import { spawn } from "node:child_process";
 function runCommandAsync(command, options = {}) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
     let stdout = "";
     let stderr = "";
@@ -33491,7 +33520,7 @@ function runCommandAsync(command, options = {}) {
         clearTimeout(forceKillTimer);
         forceKillTimer = null;
       }
-      resolve23({
+      resolve24({
         stdout,
         stderr,
         exitCode: null,
@@ -33509,7 +33538,7 @@ function runCommandAsync(command, options = {}) {
       }
       signalProcessGroup("SIGTERM");
       scheduleForceKill(NORMAL_CLEANUP_FORCE_KILL_DELAY_MS);
-      resolve23({
+      resolve24({
         stdout,
         stderr,
         exitCode: code,
@@ -34078,15 +34107,15 @@ function createDistributedTaskIdAllocator(db) {
   let opLock = Promise.resolve();
   const withLock = async (fn) => {
     const prev = opLock;
-    let resolve23;
+    let resolve24;
     opLock = new Promise((r) => {
-      resolve23 = r;
+      resolve24 = r;
     });
     await prev;
     try {
       return await fn();
     } finally {
-      resolve23();
+      resolve24();
     }
   };
   const expireReservations = (nowIso3) => {
@@ -34361,8 +34390,8 @@ function assertSafeGitBranchName(name) {
   }
 }
 function assertSafeAbsolutePath(path2) {
-  const isAbsolute14 = path2.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path2);
-  if (!path2 || path2.length > 4096 || !isAbsolute14 || path2.startsWith("-") || // Reject shell metacharacters, quotes, control chars, and NULs.
+  const isAbsolute15 = path2.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path2);
+  if (!path2 || path2.length > 4096 || !isAbsolute15 || path2.startsWith("-") || // Reject shell metacharacters, quotes, control chars, and NULs.
   /["'`$\n\r\t;&|<>()*?[\]{}\\\0]/.test(
     path2.replace(/^[A-Za-z]:/, "")
     // ignore the drive-letter colon on Windows
@@ -35623,9 +35652,9 @@ ${outcome}`;
        * lost-update races on the nextId counter.
        */
       withConfigLock(fn) {
-        let resolve23;
+        let resolve24;
         const next = new Promise((r) => {
-          resolve23 = r;
+          resolve24 = r;
         });
         const prev = this.configLock;
         this.configLock = next;
@@ -35633,7 +35662,7 @@ ${outcome}`;
           try {
             return await fn();
           } finally {
-            resolve23();
+            resolve24();
           }
         });
       }
@@ -35642,9 +35671,9 @@ ${outcome}`;
        * per task ID. Concurrent callers for the same ID will queue behind each other.
        */
       withWorktreeAllocationLock(fn) {
-        let resolve23;
+        let resolve24;
         const next = new Promise((r) => {
-          resolve23 = r;
+          resolve24 = r;
         });
         const prev = this.worktreeAllocationLock;
         this.worktreeAllocationLock = next;
@@ -35652,15 +35681,15 @@ ${outcome}`;
           try {
             return await fn();
           } finally {
-            resolve23();
+            resolve24();
           }
         });
       }
       withTaskLock(id, fn) {
         const prev = this.taskLocks.get(id) ?? Promise.resolve();
-        let resolve23;
+        let resolve24;
         const next = new Promise((r) => {
-          resolve23 = r;
+          resolve24 = r;
         });
         this.taskLocks.set(id, next);
         return prev.then(async () => {
@@ -35670,7 +35699,7 @@ ${outcome}`;
             if (this.taskLocks.get(id) === next) {
               this.taskLocks.delete(id);
             }
-            resolve23();
+            resolve24();
           }
         });
       }
@@ -37638,8 +37667,8 @@ ${newTask.description}
           if (this.isWatching) this.taskCache.delete(id);
           const dir = this.taskDir(id);
           if (existsSync13(dir)) {
-            const { rm: rm4 } = await import("node:fs/promises");
-            await rm4(dir, { recursive: true });
+            const { rm: rm5 } = await import("node:fs/promises");
+            await rm5(dir, { recursive: true });
           }
           for (const dependentTask of rewrittenDependents) {
             this.emit("task:updated", dependentTask);
@@ -37999,8 +38028,8 @@ ${newTask.description}
           this.clearLinkedAgentTaskIds(id, task.updatedAt);
           this.db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
           this.db.bumpLastModified();
-          const { rm: rm4 } = await import("node:fs/promises");
-          await rm4(dir, { recursive: true, force: true });
+          const { rm: rm5 } = await import("node:fs/promises");
+          await rm5(dir, { recursive: true, force: true });
           if (this.isWatching) {
             this.taskCache.delete(id);
           }
@@ -38163,7 +38192,7 @@ ${newTask.description}
               }
             }
           }
-          await new Promise((resolve23) => setImmediate(resolve23));
+          await new Promise((resolve24) => setImmediate(resolve24));
           const selectClause = this.getTaskSelectClause(true);
           const changedRows = this.lastPollTime ? this.db.prepare(`SELECT ${selectClause} FROM tasks WHERE updatedAt > ? OR columnMovedAt > ?`).all(this.lastPollTime, this.lastPollTime) : this.db.prepare(`SELECT ${selectClause} FROM tasks`).all();
           this.lastPollTime = (/* @__PURE__ */ new Date()).toISOString();
@@ -38183,7 +38212,7 @@ ${newTask.description}
               this.emit("task:updated", task);
             }
             if (i > 0 && i % 50 === 0) {
-              await new Promise((resolve23) => setImmediate(resolve23));
+              await new Promise((resolve24) => setImmediate(resolve24));
             }
           }
           const elapsed = Date.now() - startTime;
@@ -39138,14 +39167,14 @@ ${newTask.description}
         if (rows.length === 0) {
           return;
         }
-        const { rm: rm4 } = await import("node:fs/promises");
+        const { rm: rm5 } = await import("node:fs/promises");
         for (const row of rows) {
           const task = this.rowToTask(row);
           const archivedAt = task.columnMovedAt ?? task.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
           const entry = await this.taskToArchiveEntry(task, archivedAt);
           this.archiveDb.upsert(entry);
           this.db.prepare("DELETE FROM tasks WHERE id = ?").run(task.id);
-          await rm4(this.taskDir(task.id), { recursive: true, force: true });
+          await rm5(this.taskDir(task.id), { recursive: true, force: true });
           if (this.isWatching) {
             this.taskCache.delete(task.id);
           }
@@ -39168,8 +39197,8 @@ ${newTask.description}
           this.archiveDb.upsert(entry);
           this.db.prepare("DELETE FROM tasks WHERE id = ?").run(task.id);
           this.db.bumpLastModified();
-          const { rm: rm4 } = await import("node:fs/promises");
-          await rm4(dir, { recursive: true, force: true });
+          const { rm: rm5 } = await import("node:fs/promises");
+          await rm5(dir, { recursive: true, force: true });
           if (this.isWatching) {
             this.taskCache.delete(task.id);
           }
@@ -40334,7 +40363,7 @@ function runGh(args, cwd) {
 }
 function runGhAsync(args, cwdOrOptions) {
   const { cwd, signal: externalSignal, timeoutMs = DEFAULT_GH_TIMEOUT_MS } = normalizeRunGhOptions(cwdOrOptions);
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     if (externalSignal?.aborted) {
       reject(makeGhError(`gh command aborted: ${describeAbortReason(externalSignal.reason)}`, "ABORT_ERR"));
       return;
@@ -40385,7 +40414,7 @@ function runGhAsync(args, cwdOrOptions) {
           ghError.stderr = stderr ?? "";
           reject(ghError);
         } else {
-          resolve23(stdout ?? "");
+          resolve24(stdout ?? "");
         }
       }
     );
@@ -40486,7 +40515,7 @@ import { existsSync as existsSync15, readFileSync as readFileSync4, realpathSync
 import { platform as platform2, tmpdir as tmpdir2 } from "node:os";
 import { posix, win32 as win322 } from "node:path";
 function runProbe(command, args, timeoutMs) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     let stdout = "";
     let stderr = "";
     const child = spawn2(command, args, {
@@ -40508,11 +40537,11 @@ function runProbe(command, args, timeoutMs) {
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve23({ exitCode: null, stdout, stderr: stderr || err.message });
+      resolve24({ exitCode: null, stdout, stderr: stderr || err.message });
     });
     child.on("close", (exitCode) => {
       clearTimeout(timer);
-      resolve23({ exitCode, stdout, stderr });
+      resolve24({ exitCode, stdout, stderr });
     });
   });
 }
@@ -40819,9 +40848,9 @@ var init_routine_store = __esm({
        */
       withRoutineLock(id, fn) {
         const prev = this.routineLocks.get(id) ?? Promise.resolve();
-        let resolve23;
+        let resolve24;
         const next = new Promise((r) => {
-          resolve23 = r;
+          resolve24 = r;
         });
         this.routineLocks.set(id, next);
         return prev.then(async () => {
@@ -40831,7 +40860,7 @@ var init_routine_store = __esm({
             if (this.routineLocks.get(id) === next) {
               this.routineLocks.delete(id);
             }
-            resolve23();
+            resolve24();
           }
         });
       }
@@ -41567,13 +41596,13 @@ var init_plugin_loader = __esm({
        * Execute a promise with a timeout.
        */
       withTimeout(promise, ms, timeoutMessage) {
-        return new Promise((resolve23, reject) => {
+        return new Promise((resolve24, reject) => {
           const timer = setTimeout(() => {
             reject(new Error(timeoutMessage));
           }, ms);
           promise.then((result) => {
             clearTimeout(timer);
-            resolve23(result);
+            resolve24(result);
           }).catch((err) => {
             clearTimeout(timer);
             reject(err);
@@ -42363,8 +42392,329 @@ var init_backup = __esm({
   }
 });
 
+// ../core/src/memory-backup.ts
+import { cp as cp2, mkdir as mkdir9, readdir as readdir7, readFile as readFile10, rename as rename5, rm as rm2, stat as stat4, writeFile as writeFile7 } from "node:fs/promises";
+import { existsSync as existsSync17 } from "node:fs";
+import { dirname as dirname7, join as join20, relative as relative3, resolve as resolve10, sep as sep5 } from "node:path";
+function createMemoryBackupManager(fusionDir, settings) {
+  return new MemoryBackupManager(fusionDir, {
+    backupDir: sanitizeMemoryBackupDir(fusionDir, canonicalizeMemoryBackupDir(settings?.memoryBackupDir)),
+    retention: settings?.memoryBackupRetention,
+    scope: settings?.memoryBackupScope
+  });
+}
+async function runMemoryBackupCommand(fusionDir, settings) {
+  if (settings.memoryBackupSchedule && !validateMemoryBackupSchedule(settings.memoryBackupSchedule)) {
+    return { success: false, output: `Invalid memory backup schedule: ${settings.memoryBackupSchedule}` };
+  }
+  const manager = createMemoryBackupManager(fusionDir, settings);
+  try {
+    const backup = await manager.createBackup();
+    const deletedCount = await manager.cleanupOldBackups();
+    const output = deletedCount > 0 ? `Memory backup created: ${backup.filename} (${formatBytes2(backup.size)}). Removed ${deletedCount} old backup(s).` : `Memory backup created: ${backup.filename} (${formatBytes2(backup.size)})`;
+    return { success: true, output, backupPath: backup.path, deletedCount };
+  } catch (error) {
+    return { success: false, output: `Memory backup failed: ${error.message}` };
+  }
+}
+async function syncMemoryBackupAutomation(automationStore, settings) {
+  const { AutomationStore: AutomationStore2 } = await Promise.resolve().then(() => (init_automation_store(), automation_store_exports));
+  const schedules = await automationStore.listSchedules();
+  const existing = schedules.find((s) => s.name === MEMORY_BACKUP_SCHEDULE_NAME);
+  if (!settings.memoryBackupEnabled) {
+    if (existing) await automationStore.deleteSchedule(existing.id);
+    return void 0;
+  }
+  const schedule = settings.memoryBackupSchedule || "0 3 * * *";
+  if (!AutomationStore2.isValidCron(schedule)) {
+    throw new Error(`Invalid backup schedule: ${schedule}`);
+  }
+  const command = "fn memory-backup --create";
+  if (existing) {
+    return await automationStore.updateSchedule(existing.id, {
+      scheduleType: "custom",
+      cronExpression: schedule,
+      command,
+      enabled: true
+    });
+  }
+  return await automationStore.createSchedule({
+    name: MEMORY_BACKUP_SCHEDULE_NAME,
+    description: "Automatic memory backup based on project settings",
+    scheduleType: "custom",
+    cronExpression: schedule,
+    command,
+    enabled: true
+  });
+}
+async function syncMemoryBackupRoutine(routineStore, settings) {
+  const { RoutineStore: RoutineStore2 } = await Promise.resolve().then(() => (init_routine_store(), routine_store_exports));
+  const routines = await routineStore.listRoutines();
+  const existing = routines.find((routine) => routine.name === MEMORY_BACKUP_SCHEDULE_NAME);
+  if (!settings.memoryBackupEnabled) {
+    if (existing) {
+      await routineStore.deleteRoutine(existing.id);
+    }
+    return void 0;
+  }
+  const schedule = settings.memoryBackupSchedule || "0 3 * * *";
+  if (!RoutineStore2.isValidCron(schedule)) {
+    throw new Error(`Invalid backup schedule: ${schedule}`);
+  }
+  const command = "fn memory-backup --create";
+  if (existing) {
+    return await routineStore.updateRoutine(existing.id, {
+      trigger: { type: "cron", cronExpression: schedule },
+      command,
+      enabled: true
+    });
+  }
+  return await routineStore.createRoutine({
+    name: MEMORY_BACKUP_SCHEDULE_NAME,
+    description: "Automatic memory backup based on project settings",
+    agentId: "",
+    trigger: { type: "cron", cronExpression: schedule },
+    command,
+    enabled: true,
+    scope: "project"
+  });
+}
+function canonicalizeMemoryBackupDir(dir) {
+  if (dir === ".kb/backups/memory") return ".fusion/backups/memory";
+  return dir;
+}
+function sanitizeMemoryBackupDir(fusionDir, dir) {
+  if (!dir) return void 0;
+  if (dir.startsWith("/") || dir.startsWith("\\") || /^[a-zA-Z]:/.test(dir) || dir.includes("..")) {
+    throw new Error(`Invalid memory backup directory: ${dir}`);
+  }
+  const projectRoot = resolve10(fusionDir, "..");
+  const resolved = resolve10(projectRoot, dir);
+  const rel = relative3(projectRoot, resolved);
+  if (rel.startsWith("..") || rel.includes(`..${sep5}`)) {
+    throw new Error(`Invalid memory backup directory: ${dir}`);
+  }
+  return rel || ".";
+}
+function formatTimestamp2(date) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  const hours = String(date.getUTCHours()).padStart(2, "0");
+  const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+  const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+  return `${year}-${month}-${day}-${hours}${minutes}${seconds}`;
+}
+function formatBytes2(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+async function getDirectoryStats(dir) {
+  const entries = await readdir7(dir, { withFileTypes: true });
+  let size = 0;
+  let entryCount = 0;
+  for (const entry of entries) {
+    const fullPath = join20(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await getDirectoryStats(fullPath);
+      size += nested.size;
+      entryCount += nested.entryCount;
+      continue;
+    }
+    if (entry.isFile()) {
+      const st = await stat4(fullPath);
+      size += st.size;
+      entryCount++;
+    }
+  }
+  return { size, entryCount };
+}
+async function listFilesRecursive(root) {
+  const entries = await readdir7(root, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = join20(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFilesRecursive(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+var MEMORY_BACKUP_SCHEDULE_NAME, AGENT_MEMORY_ROOT2, MemoryBackupManager, validateMemoryBackupSchedule;
+var init_memory_backup = __esm({
+  "../core/src/memory-backup.ts"() {
+    "use strict";
+    init_memory_backend();
+    init_backup();
+    MEMORY_BACKUP_SCHEDULE_NAME = "Memory Backup";
+    AGENT_MEMORY_ROOT2 = ".fusion/agent-memory";
+    MemoryBackupManager = class {
+      fusionDir;
+      backupDir;
+      retention;
+      scope;
+      constructor(fusionDir, options) {
+        this.fusionDir = fusionDir;
+        this.backupDir = options?.backupDir ?? ".fusion/backups/memory";
+        this.retention = options?.retention ?? 14;
+        this.scope = options?.scope ?? "all";
+      }
+      getProjectRoot() {
+        return resolve10(this.fusionDir, "..");
+      }
+      getBackupDirPath() {
+        return resolve10(this.getProjectRoot(), this.backupDir);
+      }
+      async collectSources() {
+        const root = this.getProjectRoot();
+        const projectPath = join20(root, MEMORY_WORKSPACE_PATH);
+        const agentsPath = join20(root, AGENT_MEMORY_ROOT2);
+        const includeProject = this.scope !== "agents";
+        const includeAgents = this.scope !== "project";
+        const sources = [];
+        if (includeProject && existsSync17(projectPath)) {
+          sources.push({ source: projectPath, target: "project" });
+        }
+        if (includeAgents && existsSync17(agentsPath)) {
+          sources.push({ source: agentsPath, target: "agents" });
+        }
+        if (sources.length === 0) {
+          throw new Error(`No memory sources found for scope '${this.scope}' (.fusion/memory or .fusion/agent-memory)`);
+        }
+        return sources;
+      }
+      async createBackup() {
+        const backupDirPath = this.getBackupDirPath();
+        await mkdir9(backupDirPath, { recursive: true });
+        const sources = await this.collectSources();
+        const baseName = `memory-${formatTimestamp2(/* @__PURE__ */ new Date())}`;
+        let filename = baseName;
+        let finalPath = join20(backupDirPath, filename);
+        let tmpPath = `${finalPath}.tmp`;
+        let counter = 1;
+        while (existsSync17(finalPath) || existsSync17(tmpPath)) {
+          filename = `${baseName}-${counter}`;
+          finalPath = join20(backupDirPath, filename);
+          tmpPath = `${finalPath}.tmp`;
+          counter++;
+        }
+        try {
+          await mkdir9(tmpPath, { recursive: true });
+          for (const { source, target } of sources) {
+            const targetPath = join20(tmpPath, target);
+            await cp2(source, targetPath, { recursive: true, preserveTimestamps: true });
+          }
+          await rename5(tmpPath, finalPath);
+        } catch (error) {
+          await rm2(tmpPath, { recursive: true, force: true });
+          throw error;
+        }
+        return this.buildInfo(filename, finalPath);
+      }
+      async listBackups() {
+        const backupDirPath = this.getBackupDirPath();
+        try {
+          const entries = await readdir7(backupDirPath);
+          const backups = [];
+          for (const entry of entries) {
+            if (!entry.match(/^memory-\d{4}-\d{2}-\d{2}-\d{6}(?:-\d+)?$/)) continue;
+            const fullPath = join20(backupDirPath, entry);
+            const st = await stat4(fullPath);
+            if (!st.isDirectory()) continue;
+            backups.push(await this.buildInfo(entry, fullPath));
+          }
+          return backups.sort((a, b) => {
+            const timeCompare = b.createdAt.localeCompare(a.createdAt);
+            if (timeCompare !== 0) return timeCompare;
+            return b.filename.localeCompare(a.filename);
+          });
+        } catch {
+          return [];
+        }
+      }
+      async cleanupOldBackups() {
+        const backups = await this.listBackups();
+        if (backups.length <= this.retention) return 0;
+        const sorted = [...backups].sort((a, b) => {
+          const timeCompare = a.createdAt.localeCompare(b.createdAt);
+          if (timeCompare !== 0) return timeCompare;
+          return a.filename.localeCompare(b.filename);
+        });
+        const toDelete = sorted.slice(0, sorted.length - this.retention);
+        let deleted = 0;
+        for (const backup of toDelete) {
+          try {
+            await rm2(backup.path, { recursive: true, force: true });
+            deleted++;
+          } catch {
+          }
+        }
+        return deleted;
+      }
+      async restoreBackup(filename, opts) {
+        const backupRoot = join20(this.getBackupDirPath(), filename);
+        const sourceProject = join20(backupRoot, "project");
+        const sourceAgents = join20(backupRoot, "agents");
+        const hasProject = existsSync17(sourceProject);
+        const hasAgents = existsSync17(sourceAgents);
+        if (!hasProject && !hasAgents) {
+          throw new Error(`Memory backup not found or empty: ${filename}`);
+        }
+        if (hasProject) {
+          await this.restoreTree(sourceProject, join20(this.getProjectRoot(), MEMORY_WORKSPACE_PATH), opts?.overwrite === true);
+        }
+        if (hasAgents) {
+          await this.restoreTree(sourceAgents, join20(this.getProjectRoot(), AGENT_MEMORY_ROOT2), opts?.overwrite === true);
+        }
+      }
+      async restoreTree(sourceDir, destinationDir, overwrite) {
+        const files = await listFilesRecursive(sourceDir);
+        for (const file of files) {
+          const rel = relative3(sourceDir, file);
+          const destFile = join20(destinationDir, rel);
+          await mkdir9(dirname7(destFile), { recursive: true });
+          if (existsSync17(destFile) && !overwrite) {
+            const [srcBuf, dstBuf] = await Promise.all([readFile10(file), readFile10(destFile)]);
+            if (!srcBuf.equals(dstBuf)) {
+              throw new Error(`Restore would overwrite modified memory file: ${destFile}`);
+            }
+            continue;
+          }
+          const tmp = `${destFile}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+          const content = await readFile10(file);
+          await writeFile7(tmp, content);
+          await rename5(tmp, destFile);
+        }
+      }
+      async buildInfo(filename, fullPath) {
+        const stats = await stat4(fullPath);
+        const sizeAndCount = await getDirectoryStats(fullPath);
+        const match = filename.match(/^memory-(\d{4})-(\d{2})-(\d{2})-(\d{2})(\d{2})(\d{2})(?:-\d+)?$/);
+        const createdAt = match ? `${match[1]}-${match[2]}-${match[3]}T${match[4]}:${match[5]}:${match[6]}Z` : stats.mtime.toISOString();
+        const hasProject = existsSync17(join20(fullPath, "project"));
+        const hasAgents = existsSync17(join20(fullPath, "agents"));
+        const scope = hasProject && hasAgents ? "all" : hasProject ? "project" : "agents";
+        return {
+          filename,
+          createdAt,
+          size: sizeAndCount.size,
+          path: fullPath,
+          scope,
+          entryCount: sizeAndCount.entryCount
+        };
+      }
+    };
+    validateMemoryBackupSchedule = validateBackupSchedule;
+  }
+});
+
 // ../core/src/settings-export.ts
-import { writeFile as writeFile7, readFile as readFile10, rename as rename5 } from "node:fs/promises";
+import { writeFile as writeFile8, readFile as readFile11, rename as rename6 } from "node:fs/promises";
 function validateImportData(data) {
   const errors = [];
   if (data === null || typeof data !== "object") {
@@ -42486,7 +42836,7 @@ async function importSettings(store, data, options = {}) {
   }
 }
 async function readExportFile(filePath) {
-  const content = await readFile10(filePath, "utf-8");
+  const content = await readFile11(filePath, "utf-8");
   try {
     const parsed = JSON.parse(content);
     return parsed;
@@ -42496,8 +42846,8 @@ async function readExportFile(filePath) {
 }
 async function writeExportFile(filePath, data) {
   const tmpPath = filePath + ".tmp";
-  await writeFile7(tmpPath, JSON.stringify(data, null, 2));
-  await rename5(tmpPath, filePath);
+  await writeFile8(tmpPath, JSON.stringify(data, null, 2));
+  await rename6(tmpPath, filePath);
 }
 var init_settings_export = __esm({
   "../core/src/settings-export.ts"() {
@@ -42756,7 +43106,7 @@ var init_mission_types = __esm({
 // ../core/src/docker-client.ts
 import Docker from "dockerode";
 import { exec } from "node:child_process";
-import { readFile as readFile11 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 import { promisify as promisify2 } from "node:util";
 function isLocalDaemonHost(host) {
   return !host || host.trim() === "" || host === "unix:///var/run/docker.sock";
@@ -42797,9 +43147,9 @@ var init_docker_client = __esm({
           const options = {
             host: hostConfig.host
           };
-          if (hostConfig.tlsCaPath) options.ca = await readFile11(hostConfig.tlsCaPath);
-          if (hostConfig.tlsCertPath) options.cert = await readFile11(hostConfig.tlsCertPath);
-          if (hostConfig.tlsKeyPath) options.key = await readFile11(hostConfig.tlsKeyPath);
+          if (hostConfig.tlsCaPath) options.ca = await readFile12(hostConfig.tlsCaPath);
+          if (hostConfig.tlsCertPath) options.cert = await readFile12(hostConfig.tlsCertPath);
+          if (hostConfig.tlsKeyPath) options.key = await readFile12(hostConfig.tlsKeyPath);
           if (hostConfig.tlsVerify === false) options.rejectUnauthorized = false;
           return new Docker(options);
         }
@@ -43063,7 +43413,7 @@ var init_mesh_config_generator = __esm({
               hostConfig
             }
           );
-          await new Promise((resolve23) => setTimeout(resolve23, POST_RECREATE_DELAY_MS));
+          await new Promise((resolve24) => setTimeout(resolve24, POST_RECREATE_DELAY_MS));
           await this.deps.central.updateManagedDockerNode(managedNodeId, {
             apiKey: config.nodeApiKey,
             reachableUrl: config.reachableUrl,
@@ -43171,7 +43521,7 @@ var init_mesh_config_generator = __esm({
             }
           } catch {
           }
-          await new Promise((resolve23) => setTimeout(resolve23, intervalMs));
+          await new Promise((resolve24) => setTimeout(resolve24, intervalMs));
         }
         return { healthy: false };
       }
@@ -43215,10 +43565,10 @@ var init_docker_provisioning = __esm({
                 }
               } : void 0;
               const stream = await docker.pull(imageRef, authOptions);
-              await new Promise((resolve23, reject) => {
+              await new Promise((resolve24, reject) => {
                 docker.modem.followProgress(
                   stream,
-                  (err) => err ? reject(err) : resolve23()
+                  (err) => err ? reject(err) : resolve24()
                 );
               });
             } catch (error) {
@@ -43449,36 +43799,36 @@ var init_docker_provisioning = __esm({
 });
 
 // ../core/src/memory-insights.ts
-import { readFile as readFile12, writeFile as writeFile8, mkdir as mkdir9, unlink as unlink5 } from "node:fs/promises";
-import { existsSync as existsSync17 } from "node:fs";
-import { dirname as dirname7, join as join20 } from "node:path";
+import { readFile as readFile13, writeFile as writeFile9, mkdir as mkdir10, unlink as unlink5 } from "node:fs/promises";
+import { existsSync as existsSync18 } from "node:fs";
+import { dirname as dirname8, join as join21 } from "node:path";
 async function readWorkingMemory(rootDir) {
-  const filePath = join20(rootDir, MEMORY_WORKING_PATH);
-  if (!existsSync17(filePath)) {
+  const filePath = join21(rootDir, MEMORY_WORKING_PATH);
+  if (!existsSync18(filePath)) {
     return "";
   }
-  return readFile12(filePath, "utf-8");
+  return readFile13(filePath, "utf-8");
 }
 async function migrateLegacyArtifactIfNeeded(rootDir, canonicalPath, legacyPath) {
-  const canonicalFilePath = join20(rootDir, canonicalPath);
-  const legacyFilePath = join20(rootDir, legacyPath);
-  if (existsSync17(canonicalFilePath) || !existsSync17(legacyFilePath)) {
+  const canonicalFilePath = join21(rootDir, canonicalPath);
+  const legacyFilePath = join21(rootDir, legacyPath);
+  if (existsSync18(canonicalFilePath) || !existsSync18(legacyFilePath)) {
     return;
   }
-  const content = await readFile12(legacyFilePath, "utf-8");
-  const canonicalDir = dirname7(canonicalFilePath);
-  if (!existsSync17(canonicalDir)) {
-    await mkdir9(canonicalDir, { recursive: true });
+  const content = await readFile13(legacyFilePath, "utf-8");
+  const canonicalDir = dirname8(canonicalFilePath);
+  if (!existsSync18(canonicalDir)) {
+    await mkdir10(canonicalDir, { recursive: true });
   }
-  await writeFile8(canonicalFilePath, content, "utf-8");
+  await writeFile9(canonicalFilePath, content, "utf-8");
   try {
     await unlink5(legacyFilePath);
   } catch {
   }
 }
 async function removeLegacyArtifactIfPresent(rootDir, legacyPath) {
-  const legacyFilePath = join20(rootDir, legacyPath);
-  if (!existsSync17(legacyFilePath)) {
+  const legacyFilePath = join21(rootDir, legacyPath);
+  if (!existsSync18(legacyFilePath)) {
     return;
   }
   try {
@@ -43488,54 +43838,54 @@ async function removeLegacyArtifactIfPresent(rootDir, legacyPath) {
 }
 async function readInsightsMemory(rootDir) {
   await migrateLegacyArtifactIfNeeded(rootDir, MEMORY_INSIGHTS_PATH, LEGACY_MEMORY_INSIGHTS_PATH);
-  const filePath = join20(rootDir, MEMORY_INSIGHTS_PATH);
-  if (!existsSync17(filePath)) {
+  const filePath = join21(rootDir, MEMORY_INSIGHTS_PATH);
+  if (!existsSync18(filePath)) {
     return null;
   }
-  return readFile12(filePath, "utf-8");
+  return readFile13(filePath, "utf-8");
 }
 async function writeInsightsMemory(rootDir, content) {
-  const filePath = join20(rootDir, MEMORY_INSIGHTS_PATH);
-  const dir = dirname7(filePath);
-  if (!existsSync17(dir)) {
-    await mkdir9(dir, { recursive: true });
+  const filePath = join21(rootDir, MEMORY_INSIGHTS_PATH);
+  const dir = dirname8(filePath);
+  if (!existsSync18(dir)) {
+    await mkdir10(dir, { recursive: true });
   }
-  await writeFile8(filePath, content, "utf-8");
+  await writeFile9(filePath, content, "utf-8");
   await removeLegacyArtifactIfPresent(rootDir, LEGACY_MEMORY_INSIGHTS_PATH);
 }
 async function writeWorkingMemory(rootDir, content) {
-  const filePath = join20(rootDir, MEMORY_WORKING_PATH);
-  const dir = dirname7(filePath);
-  if (!existsSync17(dir)) {
-    await mkdir9(dir, { recursive: true });
+  const filePath = join21(rootDir, MEMORY_WORKING_PATH);
+  const dir = dirname8(filePath);
+  if (!existsSync18(dir)) {
+    await mkdir10(dir, { recursive: true });
   }
-  await writeFile8(filePath, content, "utf-8");
+  await writeFile9(filePath, content, "utf-8");
 }
 async function readMemoryAudit(rootDir) {
   await migrateLegacyArtifactIfNeeded(rootDir, MEMORY_AUDIT_PATH, LEGACY_MEMORY_AUDIT_PATH);
-  const filePath = join20(rootDir, MEMORY_AUDIT_PATH);
-  if (!existsSync17(filePath)) {
+  const filePath = join21(rootDir, MEMORY_AUDIT_PATH);
+  if (!existsSync18(filePath)) {
     return null;
   }
-  return readFile12(filePath, "utf-8");
+  return readFile13(filePath, "utf-8");
 }
 async function writeMemoryAudit(rootDir, content) {
-  const filePath = join20(rootDir, MEMORY_AUDIT_PATH);
-  const dir = dirname7(filePath);
-  if (!existsSync17(dir)) {
-    await mkdir9(dir, { recursive: true });
+  const filePath = join21(rootDir, MEMORY_AUDIT_PATH);
+  const dir = dirname8(filePath);
+  if (!existsSync18(dir)) {
+    await mkdir10(dir, { recursive: true });
   }
-  await writeFile8(filePath, content, "utf-8");
+  await writeFile9(filePath, content, "utf-8");
   await removeLegacyArtifactIfPresent(rootDir, LEGACY_MEMORY_AUDIT_PATH);
 }
 async function readMemoryAuditState(rootDir) {
   await migrateLegacyArtifactIfNeeded(rootDir, MEMORY_AUDIT_STATE_PATH, LEGACY_MEMORY_AUDIT_STATE_PATH);
-  const filePath = join20(rootDir, MEMORY_AUDIT_STATE_PATH);
-  if (!existsSync17(filePath)) {
+  const filePath = join21(rootDir, MEMORY_AUDIT_STATE_PATH);
+  if (!existsSync18(filePath)) {
     return null;
   }
   try {
-    const raw = await readFile12(filePath, "utf-8");
+    const raw = await readFile13(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     const extraction = isValidExtractionMetadata(parsed.extraction) ? parsed.extraction : void 0;
     const pruning = isValidPruneOutcome(parsed.pruning) ? parsed.pruning : void 0;
@@ -43549,12 +43899,12 @@ async function readMemoryAuditState(rootDir) {
   }
 }
 async function writeMemoryAuditState(rootDir, state) {
-  const filePath = join20(rootDir, MEMORY_AUDIT_STATE_PATH);
-  const dir = dirname7(filePath);
-  if (!existsSync17(dir)) {
-    await mkdir9(dir, { recursive: true });
+  const filePath = join21(rootDir, MEMORY_AUDIT_STATE_PATH);
+  const dir = dirname8(filePath);
+  if (!existsSync18(dir)) {
+    await mkdir10(dir, { recursive: true });
   }
-  await writeFile8(filePath, JSON.stringify(state, null, 2), "utf-8");
+  await writeFile9(filePath, JSON.stringify(state, null, 2), "utf-8");
   await removeLegacyArtifactIfPresent(rootDir, LEGACY_MEMORY_AUDIT_STATE_PATH);
 }
 function isValidExtractionMetadata(value) {
@@ -44028,14 +44378,14 @@ async function generateMemoryAudit(rootDir, lastExtraction, pruningOutcome) {
   const persistedState = lastExtraction === void 0 || pruningOutcome === void 0 ? await readMemoryAuditState(rootDir) : null;
   const effectiveExtraction = lastExtraction ?? persistedState?.extraction;
   const effectivePruning = pruningOutcome ?? persistedState?.pruning;
-  const workingMemoryPath = join20(rootDir, MEMORY_WORKING_PATH);
-  const workingMemoryExists = existsSync17(workingMemoryPath);
+  const workingMemoryPath = join21(rootDir, MEMORY_WORKING_PATH);
+  const workingMemoryExists = existsSync18(workingMemoryPath);
   let workingMemorySize = 0;
   let workingMemorySectionCount = 0;
   let workingMemoryContent = "";
   if (workingMemoryExists) {
     try {
-      workingMemoryContent = await readFile12(workingMemoryPath, "utf-8");
+      workingMemoryContent = await readFile13(workingMemoryPath, "utf-8");
       workingMemorySize = workingMemoryContent.length;
       workingMemorySectionCount = countMarkdownSections(workingMemoryContent);
       checks.push({
@@ -44083,8 +44433,8 @@ async function generateMemoryAudit(rootDir, lastExtraction, pruningOutcome) {
       details: foundSections.length >= 2 ? `Found sections: ${foundSections.join(", ")}` : `Missing sections: ${requiredSections.filter((s) => !foundSections.includes(s)).join(", ")}`
     });
   }
-  const insightsMemoryPath = join20(rootDir, MEMORY_INSIGHTS_PATH);
-  const insightsMemoryExists = existsSync17(insightsMemoryPath);
+  const insightsMemoryPath = join21(rootDir, MEMORY_INSIGHTS_PATH);
+  const insightsMemoryExists = existsSync18(insightsMemoryPath);
   let insightsMemorySize = 0;
   let insightsMemoryContent = "";
   const categoryCounts = {
@@ -44097,7 +44447,7 @@ async function generateMemoryAudit(rootDir, lastExtraction, pruningOutcome) {
   let lastUpdated;
   if (insightsMemoryExists) {
     try {
-      insightsMemoryContent = await readFile12(insightsMemoryPath, "utf-8");
+      insightsMemoryContent = await readFile13(insightsMemoryPath, "utf-8");
       insightsMemorySize = insightsMemoryContent.length;
       for (const [category, header] of Object.entries({
         pattern: "## Patterns",
@@ -46232,7 +46582,7 @@ var require_get_stream = __commonJS({
       };
       const { maxBuffer } = options;
       let stream;
-      await new Promise((resolve23, reject) => {
+      await new Promise((resolve24, reject) => {
         const rejectPromise = (error) => {
           if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
             error.bufferedData = stream.getBufferedValue();
@@ -46244,7 +46594,7 @@ var require_get_stream = __commonJS({
             rejectPromise(error);
             return;
           }
-          resolve23();
+          resolve24();
         });
         stream.on("data", () => {
           if (stream.getBufferedLength() > maxBuffer) {
@@ -47538,7 +47888,7 @@ var require_extract_zip = __commonJS({
         debug("opening", this.zipPath, "with opts", this.opts);
         this.zipfile = await openZip(this.zipPath, { lazyEntries: true });
         this.canceled = false;
-        return new Promise((resolve23, reject) => {
+        return new Promise((resolve24, reject) => {
           this.zipfile.on("error", (err) => {
             this.canceled = true;
             reject(err);
@@ -47547,7 +47897,7 @@ var require_extract_zip = __commonJS({
           this.zipfile.on("close", () => {
             if (!this.canceled) {
               debug("zip extraction complete");
-              resolve23();
+              resolve24();
             }
           });
           this.zipfile.on("entry", async (entry) => {
@@ -51609,10 +51959,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key, sep: sep6, value } = collItem;
+        const { start, key, sep: sep7, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key ?? sep6?.[0],
+          next: key ?? sep7?.[0],
           offset,
           onError,
           parentIndent: bm.indent,
@@ -51626,7 +51976,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key && key.indent !== bm.indent)
               onError(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep6) {
+          if (!keyProps.anchor && !keyProps.tag && !sep7) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map.comment)
@@ -51650,7 +52000,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep6 ?? [], {
+        const valueProps = resolveProps.resolveProps(sep7 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -51666,7 +52016,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep6, null, valueProps, onError);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep7, null, valueProps, onError);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
           offset = valueNode.range[2];
@@ -51757,7 +52107,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep6 = "";
+        let sep7 = "";
         for (const token of end) {
           const { source, type } = token;
           switch (type) {
@@ -51771,13 +52121,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep6 + cb;
-              sep6 = "";
+                comment += sep7 + cb;
+              sep7 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep6 += source;
+                sep7 += source;
               hasSpace = true;
               break;
             default:
@@ -51820,18 +52170,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
-        const { start, key, sep: sep6, value } = collItem;
+        const { start, key, sep: sep7, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep6?.[0],
+          next: key ?? sep7?.[0],
           offset,
           onError,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep6 && !value) {
+          if (!props.anchor && !props.tag && !sep7 && !value) {
             if (i === 0 && props.comma)
               onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i < fc.items.length - 1)
@@ -51885,8 +52235,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep6 && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep6, null, props, onError);
+        if (!isMap && !sep7 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep7, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -51898,7 +52248,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key))
             onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep6 ?? [], {
+          const valueProps = resolveProps.resolveProps(sep7 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -51909,8 +52259,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap && !props.found && ctx.options.strict) {
-              if (sep6)
-                for (const st of sep6) {
+              if (sep7)
+                for (const st of sep7) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -51927,7 +52277,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep6, null, valueProps, onError) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep7, null, valueProps, onError) : null;
           if (valueNode) {
             if (isBlock(value))
               onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -52107,7 +52457,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i + 1;
       }
       let value = "";
-      let sep6 = "";
+      let sep7 = "";
       let prevMoreIndented = false;
       for (let i = 0; i < contentStart; ++i)
         value += lines[i][0].slice(trimIndent) + "\n";
@@ -52124,24 +52474,24 @@ var require_resolve_block_scalar = __commonJS({
           indent = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep6 + indent.slice(trimIndent) + content;
-          sep6 = "\n";
+          value += sep7 + indent.slice(trimIndent) + content;
+          sep7 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep6 === " ")
-            sep6 = "\n";
-          else if (!prevMoreIndented && sep6 === "\n")
-            sep6 = "\n\n";
-          value += sep6 + indent.slice(trimIndent) + content;
-          sep6 = "\n";
+          if (sep7 === " ")
+            sep7 = "\n";
+          else if (!prevMoreIndented && sep7 === "\n")
+            sep7 = "\n\n";
+          value += sep7 + indent.slice(trimIndent) + content;
+          sep7 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep6 === "\n")
+          if (sep7 === "\n")
             value += "\n";
           else
-            sep6 = "\n";
+            sep7 = "\n";
         } else {
-          value += sep6 + content;
-          sep6 = " ";
+          value += sep7 + content;
+          sep7 = " ";
           prevMoreIndented = false;
         }
       }
@@ -52323,25 +52673,25 @@ var require_resolve_flow_scalar = __commonJS({
       if (!match)
         return source;
       let res = match[1];
-      let sep6 = " ";
+      let sep7 = " ";
       let pos = first.lastIndex;
       line.lastIndex = pos;
       while (match = line.exec(source)) {
         if (match[1] === "") {
-          if (sep6 === "\n")
-            res += sep6;
+          if (sep7 === "\n")
+            res += sep7;
           else
-            sep6 = "\n";
+            sep7 = "\n";
         } else {
-          res += sep6 + match[1];
-          sep6 = " ";
+          res += sep7 + match[1];
+          sep7 = " ";
         }
         pos = line.lastIndex;
       }
       const last = /[ \t]*(.*)/sy;
       last.lastIndex = pos;
       match = last.exec(source);
-      return res + sep6 + (match?.[1] ?? "");
+      return res + sep7 + (match?.[1] ?? "");
     }
     function doubleQuotedValue(source, onError) {
       let res = "";
@@ -53148,14 +53498,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep: sep6, value }) {
+    function stringifyItem({ start, key, sep: sep7, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep6)
-        for (const st of sep6)
+      if (sep7)
+        for (const st of sep7)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -54305,18 +54655,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
-          let sep6;
+          let sep7;
           if (scalar.end) {
-            sep6 = scalar.end;
-            sep6.push(this.sourceToken);
+            sep7 = scalar.end;
+            sep7.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep6 = [this.sourceToken];
+            sep7 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep: sep6 }]
+            items: [{ start, key: scalar, sep: sep7 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -54469,15 +54819,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start2 = getFirstKeyStartProps(it.start);
                   const key = it.key;
-                  const sep6 = it.sep;
-                  sep6.push(this.sourceToken);
+                  const sep7 = it.sep;
+                  sep7.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start2, key, sep: sep6 }]
+                    items: [{ start: start2, key, sep: sep7 }]
                   });
                 } else if (start.length > 0) {
                   it.sep = it.sep.concat(start, this.sourceToken);
@@ -54671,13 +55021,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep6 = fc.end.splice(1, fc.end.length);
-            sep6.push(this.sourceToken);
+            const sep7 = fc.end.splice(1, fc.end.length);
+            sep7.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep: sep6 }]
+              items: [{ start, key: fc, sep: sep7 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -54956,9 +55306,9 @@ var require_dist3 = __commonJS({
 });
 
 // ../core/src/agent-companies-parser.ts
-import { existsSync as existsSync18, mkdtempSync, readdirSync as readdirSync2, readFileSync as readFileSync5, rmSync, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync19, mkdtempSync, readdirSync as readdirSync2, readFileSync as readFileSync5, rmSync, statSync as statSync4 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join21, resolve as resolve10 } from "node:path";
+import { isAbsolute as isAbsolute7, join as join22, normalize as normalize3, resolve as resolve11 } from "node:path";
 function slugifyAgentReference(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -55183,15 +55533,15 @@ function parseManifestFile(filePath, parser) {
   }
 }
 function parseManifestSubdirectories(rootDir, sectionDir, filename, parser) {
-  const sectionPath = join21(rootDir, sectionDir);
-  if (!existsSync18(sectionPath)) {
+  const sectionPath = join22(rootDir, sectionDir);
+  if (!existsSync19(sectionPath)) {
     return [];
   }
   const manifests = [];
   const entries = readdirSync2(sectionPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const manifestPath = join21(sectionPath, entry.name, filename);
-    if (!existsSync18(manifestPath)) {
+    const manifestPath = join22(sectionPath, entry.name, filename);
+    if (!existsSync19(manifestPath)) {
       continue;
     }
     manifests.push(parseManifestFile(manifestPath, parser));
@@ -55228,18 +55578,18 @@ function walkTeamIncludes(teams) {
   }
 }
 function parseCompanyDirectory(dirPath) {
-  const resolvedPath = resolve10(dirPath);
-  if (!existsSync18(resolvedPath)) {
+  const resolvedPath = resolve11(dirPath);
+  if (!existsSync19(resolvedPath)) {
     throw new AgentCompaniesParseError(`Company directory does not exist: ${resolvedPath}`);
   }
   if (!statSync4(resolvedPath).isDirectory()) {
     throw new AgentCompaniesParseError(`Company path is not a directory: ${resolvedPath}`);
   }
-  const companyPath = join21(resolvedPath, "COMPANY.md");
+  const companyPath = join22(resolvedPath, "COMPANY.md");
   const teams = parseManifestSubdirectories(resolvedPath, "teams", "TEAM.md", parseTeamManifest);
   walkTeamIncludes(teams);
   return {
-    company: existsSync18(companyPath) ? parseManifestFile(companyPath, parseCompanyManifest) : void 0,
+    company: existsSync19(companyPath) ? parseManifestFile(companyPath, parseCompanyManifest) : void 0,
     agents: parseManifestSubdirectories(resolvedPath, "agents", "AGENTS.md", parseAgentManifest),
     teams,
     projects: parseManifestSubdirectories(
@@ -55253,20 +55603,20 @@ function parseCompanyDirectory(dirPath) {
   };
 }
 function resolveExtractionRoot(tempDir) {
-  if (existsSync18(join21(tempDir, "COMPANY.md"))) {
+  if (existsSync19(join22(tempDir, "COMPANY.md"))) {
     return tempDir;
   }
   const directories = readdirSync2(tempDir, { withFileTypes: true }).filter(
     (entry) => entry.isDirectory()
   );
   for (const directory of directories) {
-    const candidate = join21(tempDir, directory.name);
-    if (existsSync18(join21(candidate, "COMPANY.md"))) {
+    const candidate = join22(tempDir, directory.name);
+    if (existsSync19(join22(candidate, "COMPANY.md"))) {
       return candidate;
     }
   }
   if (directories.length === 1) {
-    return resolveExtractionRoot(join21(tempDir, directories[0].name));
+    return resolveExtractionRoot(join22(tempDir, directories[0].name));
   }
   return tempDir;
 }
@@ -55278,9 +55628,35 @@ async function extractTarArchive(archivePath, outputDir) {
   const execFileAsync6 = promisify14(execFile8);
   await execFileAsync6("tar", ["xzf", archivePath, "-C", outputDir]);
 }
-async function parseCompanyArchive(archivePath) {
-  const resolvedArchivePath = resolve10(archivePath);
-  const tempDir = mkdtempSync(join21(tmpdir3(), "agent-companies-"));
+function sanitizeCompanySubPath(subPath) {
+  const trimmed = subPath.trim();
+  if (trimmed.length === 0) {
+    throw new AgentCompaniesParseError("subPath must not be empty");
+  }
+  if (trimmed.includes("\\")) {
+    throw new AgentCompaniesParseError(`Invalid subPath "${subPath}": backslashes are not allowed`);
+  }
+  if (isAbsolute7(trimmed)) {
+    throw new AgentCompaniesParseError(`Invalid subPath "${subPath}": absolute paths are not allowed`);
+  }
+  const normalized = normalize3(trimmed).replace(/^\/+/, "");
+  if (normalized === "" || normalized === "." || normalized.split("/").some((segment) => segment === "..")) {
+    throw new AgentCompaniesParseError(`Invalid subPath "${subPath}": path traversal is not allowed`);
+  }
+  return normalized;
+}
+function findArchiveWrapperRoot(tempDir) {
+  const directories = readdirSync2(tempDir, { withFileTypes: true }).filter(
+    (entry) => entry.isDirectory()
+  );
+  if (directories.length === 1) {
+    return join22(tempDir, directories[0].name);
+  }
+  return tempDir;
+}
+async function parseCompanyArchive(archivePath, options) {
+  const resolvedArchivePath = resolve11(archivePath);
+  const tempDir = mkdtempSync(join22(tmpdir3(), "agent-companies-"));
   try {
     if (resolvedArchivePath.endsWith(".tar.gz") || resolvedArchivePath.endsWith(".tgz")) {
       await extractTarArchive(resolvedArchivePath, tempDir);
@@ -55291,6 +55667,18 @@ async function parseCompanyArchive(archivePath) {
         "Unsupported archive format. Expected .tar.gz, .tgz, or .zip"
       );
     }
+    if (typeof options?.subPath === "string") {
+      const wrapperRoot = findArchiveWrapperRoot(tempDir);
+      const sanitizedSubPath = sanitizeCompanySubPath(options.subPath);
+      const candidateRoot = join22(wrapperRoot, sanitizedSubPath);
+      const companyManifestPath = join22(candidateRoot, "COMPANY.md");
+      if (!existsSync19(companyManifestPath)) {
+        throw new AgentCompaniesParseError(
+          `Company manifest not found at archive subPath "${sanitizedSubPath}" (expected ${companyManifestPath})`
+        );
+      }
+      return parseCompanyDirectory(candidateRoot);
+    }
     return parseCompanyDirectory(resolveExtractionRoot(tempDir));
   } catch (error) {
     if (error instanceof AgentCompaniesParseError) {
@@ -55469,8 +55857,8 @@ var init_agent_companies_parser = __esm({
 });
 
 // ../core/src/agent-companies-exporter.ts
-import { mkdir as mkdir10, writeFile as writeFile9 } from "node:fs/promises";
-import { resolve as resolve11, join as join22 } from "node:path";
+import { mkdir as mkdir11, writeFile as writeFile10 } from "node:fs/promises";
+import { resolve as resolve12, join as join23 } from "node:path";
 function trimToUndefined(value) {
   if (typeof value !== "string") {
     return void 0;
@@ -55578,7 +55966,7 @@ function generateSkillMd(skillName) {
   );
 }
 async function exportAgentsToDirectory(agents, outputDir, options) {
-  const resolvedOutputDir = resolve11(outputDir);
+  const resolvedOutputDir = resolve12(outputDir);
   const includeSkills = options?.includeSkills ?? true;
   const result = {
     outputDir: resolvedOutputDir,
@@ -55587,15 +55975,15 @@ async function exportAgentsToDirectory(agents, outputDir, options) {
     filesWritten: [],
     errors: []
   };
-  await mkdir10(resolvedOutputDir, { recursive: true });
-  await mkdir10(join22(resolvedOutputDir, "agents"), { recursive: true });
-  const companyMdPath = join22(resolvedOutputDir, "COMPANY.md");
+  await mkdir11(resolvedOutputDir, { recursive: true });
+  await mkdir11(join23(resolvedOutputDir, "agents"), { recursive: true });
+  const companyMdPath = join23(resolvedOutputDir, "COMPANY.md");
   const companyMd = generateCompanyMd(agents, {
     name: options?.companyName,
     description: options?.companyDescription,
     slug: options?.companySlug
   });
-  await writeFile9(companyMdPath, companyMd, "utf-8");
+  await writeFile10(companyMdPath, companyMd, "utf-8");
   result.filesWritten.push(companyMdPath);
   const validAgents = agents.filter((agent) => {
     if (!trimToUndefined(agent.name)) {
@@ -55641,9 +56029,9 @@ async function exportAgentsToDirectory(agents, outputDir, options) {
       skills: skillRefs
     });
     try {
-      const agentDir = join22(resolvedOutputDir, "agents", agentSlug);
-      const agentMdPath = join22(agentDir, "AGENTS.md");
-      await mkdir10(agentDir, { recursive: true });
+      const agentDir = join23(resolvedOutputDir, "agents", agentSlug);
+      const agentMdPath = join23(agentDir, "AGENTS.md");
+      await mkdir11(agentDir, { recursive: true });
       const frontmatter = {
         name: manifest.name,
         title: manifest.title,
@@ -55656,7 +56044,7 @@ async function exportAgentsToDirectory(agents, outputDir, options) {
         memory: manifest.memory
       };
       const content = toFrontmatterMarkdown(frontmatter, manifest.instructionBody ?? "");
-      await writeFile9(agentMdPath, content, "utf-8");
+      await writeFile10(agentMdPath, content, "utf-8");
       result.agentsExported += 1;
       result.filesWritten.push(agentMdPath);
     } catch (error) {
@@ -55667,13 +56055,13 @@ async function exportAgentsToDirectory(agents, outputDir, options) {
     }
   }
   if (includeSkills && skillByName.size > 0) {
-    const skillsDir = join22(resolvedOutputDir, "skills");
-    await mkdir10(skillsDir, { recursive: true });
+    const skillsDir = join23(resolvedOutputDir, "skills");
+    await mkdir11(skillsDir, { recursive: true });
     for (const skill of skillByName.values()) {
-      const skillDir = join22(skillsDir, skill.slug);
-      const skillPath = join22(skillDir, "SKILL.md");
-      await mkdir10(skillDir, { recursive: true });
-      await writeFile9(skillPath, generateSkillMd(skill.name), "utf-8");
+      const skillDir = join23(skillsDir, skill.slug);
+      const skillPath = join23(skillDir, "SKILL.md");
+      await mkdir11(skillDir, { recursive: true });
+      await writeFile10(skillPath, generateSkillMd(skill.name), "utf-8");
       result.skillsExported += 1;
       result.filesWritten.push(skillPath);
     }
@@ -56401,19 +56789,19 @@ var init_chat_store = __esm({
 });
 
 // ../core/src/oauth-credential-interop.ts
-import { existsSync as existsSync19, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync6 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function getHomeDir4() {
   return process.env.HOME || process.env.USERPROFILE || homedir4();
 }
 function getCodexCliAuthPath(home = getHomeDir4()) {
-  return join23(home, ".codex", "auth.json");
+  return join24(home, ".codex", "auth.json");
 }
 function getClaudeCodeCredentialPaths(home = getHomeDir4()) {
   return [
-    join23(home, ".claude", ".credentials.json"),
-    join23(home, ".config", "claude", ".credentials.json")
+    join24(home, ".claude", ".credentials.json"),
+    join24(home, ".config", "claude", ".credentials.json")
   ];
 }
 function parseJwtPayload(token) {
@@ -56580,7 +56968,7 @@ function extractClaudeCliStoredCredential(raw) {
   };
 }
 function readStoredCredentialsFromAuthFile(authPath) {
-  if (!existsSync19(authPath)) {
+  if (!existsSync20(authPath)) {
     return {};
   }
   try {
@@ -56717,6 +57105,7 @@ __export(src_exports, {
   MAX_TITLE_LENGTH: () => MAX_TITLE_LENGTH,
   MEMORY_AUDIT_PATH: () => MEMORY_AUDIT_PATH,
   MEMORY_BACKEND_SETTINGS_KEYS: () => MEMORY_BACKEND_SETTINGS_KEYS,
+  MEMORY_BACKUP_SCHEDULE_NAME: () => MEMORY_BACKUP_SCHEDULE_NAME,
   MEMORY_DREAMS_FILENAME: () => MEMORY_DREAMS_FILENAME,
   MEMORY_DREAMS_SCHEDULE_NAME: () => MEMORY_DREAMS_SCHEDULE_NAME,
   MEMORY_INSIGHTS_PATH: () => MEMORY_INSIGHTS_PATH,
@@ -56735,6 +57124,7 @@ __export(src_exports, {
   MISSION_EVENT_TYPES: () => MISSION_EVENT_TYPES,
   MISSION_STATUSES: () => MISSION_STATUSES,
   MemoryBackendError: () => MemoryBackendError,
+  MemoryBackupManager: () => MemoryBackupManager,
   MeshConfigGenerator: () => MeshConfigGenerator,
   MessageStore: () => MessageStore,
   MigrationCoordinator: () => MigrationCoordinator,
@@ -56840,6 +57230,7 @@ __export(src_exports, {
   createDistributedTaskIdAllocator: () => createDistributedTaskIdAllocator,
   createFenceToken: () => createFenceToken,
   createInsightExtractionAutomation: () => createInsightExtractionAutomation,
+  createMemoryBackupManager: () => createMemoryBackupManager,
   createMemoryDreamsAutomation: () => createMemoryDreamsAutomation,
   createMissionHierarchySnapshot: () => createMissionHierarchySnapshot,
   createProjectSettingsSnapshot: () => createProjectSettingsSnapshot,
@@ -57029,6 +57420,7 @@ __export(src_exports, {
   runGhAsync: () => runGhAsync,
   runGhJson: () => runGhJson,
   runGhJsonAsync: () => runGhJsonAsync,
+  runMemoryBackupCommand: () => runMemoryBackupCommand,
   runScheduledEvalBatch: () => runScheduledEvalBatch,
   sanitizeCommitSubject: () => sanitizeCommitSubject,
   sanitizeDockerNodeConfigForResponse: () => sanitizeDockerNodeConfigForResponse,
@@ -57052,6 +57444,8 @@ __export(src_exports, {
   syncBackupAutomation: () => syncBackupAutomation,
   syncBackupRoutine: () => syncBackupRoutine,
   syncInsightExtractionAutomation: () => syncInsightExtractionAutomation,
+  syncMemoryBackupAutomation: () => syncMemoryBackupAutomation,
+  syncMemoryBackupRoutine: () => syncMemoryBackupRoutine,
   syncMemoryDreamsAutomation: () => syncMemoryDreamsAutomation,
   syncScheduledEvalBatchAutomation: () => syncScheduledEvalBatchAutomation,
   taskMatchesReplicatedCreate: () => taskMatchesReplicatedCreate,
@@ -57066,6 +57460,7 @@ __export(src_exports, {
   validateDescription: () => validateDescription,
   validateDockerNodeConfig: () => validateDockerNodeConfig,
   validateImportData: () => validateImportData,
+  validateMemoryBackupSchedule: () => validateMemoryBackupSchedule,
   validateMessageMetadata: () => validateMessageMetadata,
   validateNodeOverrideChange: () => validateNodeOverrideChange,
   validatePluginManifest: () => validatePluginManifest,
@@ -57123,6 +57518,7 @@ var init_src = __esm({
     init_plugin_loader();
     init_plugin_security_scan();
     init_backup();
+    init_memory_backup();
     init_settings_export();
     init_ai_summarize();
     init_model_resolution();
@@ -57876,12 +58272,12 @@ var init_concurrency = __esm({
           this._active++;
           return Promise.resolve();
         }
-        return new Promise((resolve23) => {
+        return new Promise((resolve24) => {
           this._waiters.push({
             priority,
             resolve: () => {
               this._active++;
-              resolve23();
+              resolve24();
             }
           });
         });
@@ -58689,23 +59085,23 @@ var init_github_provider = __esm({
 });
 
 // ../engine/src/skill-resolver.ts
-import { existsSync as existsSync20, readFileSync as readFileSync7 } from "node:fs";
-import { dirname as dirname8, join as join24, resolve as resolve12 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync7 } from "node:fs";
+import { dirname as dirname9, join as join25, resolve as resolve13 } from "node:path";
 function resolveProjectRoot(cwd) {
-  let current = resolve12(cwd);
+  let current = resolve13(cwd);
   while (true) {
-    if (existsSync20(join24(current, ".fusion"))) {
+    if (existsSync21(join25(current, ".fusion"))) {
       return current;
     }
-    const parent = dirname8(current);
+    const parent = dirname9(current);
     if (parent === current) {
-      return resolve12(cwd);
+      return resolve13(cwd);
     }
     current = parent;
   }
 }
 function readJsonObject(path2) {
-  if (!existsSync20(path2)) {
+  if (!existsSync21(path2)) {
     return {};
   }
   try {
@@ -58716,8 +59112,8 @@ function readJsonObject(path2) {
   }
 }
 function readProjectSettings(projectRootDir) {
-  const fusionSettings = join24(projectRootDir, ".fusion", "settings.json");
-  if (existsSync20(fusionSettings)) {
+  const fusionSettings = join25(projectRootDir, ".fusion", "settings.json");
+  if (existsSync21(fusionSettings)) {
     const parsed = readJsonObject(fusionSettings);
     return {
       skills: Array.isArray(parsed.skills) ? parsed.skills : void 0,
@@ -58963,24 +59359,24 @@ var init_context_limit_detector = __esm({
 });
 
 // ../engine/src/auth-storage.ts
-import { existsSync as existsSync21, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync22, readFileSync as readFileSync8 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 import { AuthStorage } from "@mariozechner/pi-coding-agent";
 import { getOAuthProvider } from "@mariozechner/pi-ai/oauth";
 function getHomeDir5() {
   return process.env.HOME || process.env.USERPROFILE || homedir5();
 }
 function getFusionAuthPath(home = getHomeDir5()) {
-  return join25(home, ".fusion", "agent", "auth.json");
+  return join26(home, ".fusion", "agent", "auth.json");
 }
 function getFusionModelsPath(home = getHomeDir5()) {
-  return join25(home, ".fusion", "agent", "models.json");
+  return join26(home, ".fusion", "agent", "models.json");
 }
 function getLegacyAuthPaths(home = getHomeDir5()) {
   return [
-    join25(home, ".pi", "agent", "auth.json"),
-    join25(home, ".pi", "auth.json")
+    join26(home, ".pi", "agent", "auth.json"),
+    join26(home, ".pi", "auth.json")
   ];
 }
 function getSupplementalAuthPaths(home = getHomeDir5()) {
@@ -58992,16 +59388,16 @@ function getSupplementalAuthPaths(home = getHomeDir5()) {
 }
 function getLegacyModelsPaths(home = getHomeDir5()) {
   return [
-    join25(home, ".pi", "agent", "models.json"),
-    join25(home, ".pi", "models.json")
+    join26(home, ".pi", "agent", "models.json"),
+    join26(home, ".pi", "models.json")
   ];
 }
 function getModelRegistryModelsPath(home = getHomeDir5()) {
   const fusionModelsPath = getFusionModelsPath(home);
-  if (existsSync21(fusionModelsPath)) {
+  if (existsSync22(fusionModelsPath)) {
     return fusionModelsPath;
   }
-  return getLegacyModelsPaths(home).find((modelsPath) => existsSync21(modelsPath)) ?? fusionModelsPath;
+  return getLegacyModelsPaths(home).find((modelsPath) => existsSync22(modelsPath)) ?? fusionModelsPath;
 }
 function readSupplementalCredentials(authPaths = getSupplementalAuthPaths()) {
   const credentials = {};
@@ -59035,7 +59431,7 @@ function resolveStoredCredentialApiKey(providerId, credential) {
 function readModelsJsonApiKeys(home = getHomeDir5()) {
   const apiKeys = /* @__PURE__ */ new Map();
   const modelsPath = getModelRegistryModelsPath(home);
-  if (!existsSync21(modelsPath)) {
+  if (!existsSync22(modelsPath)) {
     return apiKeys;
   }
   try {
@@ -59199,10 +59595,10 @@ var init_auth_storage = __esm({
 // ../engine/src/custom-providers.ts
 import { readFileSync as readFileSync9 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 function readCustomProviders(homeDir = homedir6()) {
   try {
-    const settingsPath = join26(homeDir, ".fusion", "settings.json");
+    const settingsPath = join27(homeDir, ".fusion", "settings.json");
     const raw = readFileSync9(settingsPath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.customProviders) ? parsed.customProviders : [];
@@ -59286,11 +59682,11 @@ var init_permanent_agent_gating = __esm({
 });
 
 // ../engine/src/pi.ts
-import { existsSync as existsSync22, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync23, readFileSync as readFileSync10 } from "node:fs";
 import { exec as exec2 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 import { createRequire as createRequire2 } from "node:module";
-import { basename as basename7, dirname as dirname9, join as join27, relative as relative3, isAbsolute as isAbsolute7, resolve as resolve13 } from "node:path";
+import { basename as basename7, dirname as dirname10, join as join28, relative as relative4, isAbsolute as isAbsolute8, resolve as resolve14 } from "node:path";
 import {
   createAgentSession,
   createBashTool,
@@ -59751,7 +60147,7 @@ function isRetryableModelSelectionError(message) {
   return normalized.includes("rate limit") || normalized.includes("too many requests") || normalized.includes("429") || normalized.includes("401") || normalized.includes("403") || normalized.includes("unauthorized") || normalized.includes("forbidden") || normalized.includes("authentication") || normalized.includes("invalid api key") || normalized.includes("invalid key") || normalized.includes("api key") || normalized.includes("overloaded") || normalized.includes("quota") || normalized.includes("capacity") || normalized.includes("temporarily unavailable") || normalized.includes("invalid temperature");
 }
 function readJsonObject2(path2) {
-  if (!existsSync22(path2)) {
+  if (!existsSync23(path2)) {
     return {};
   }
   try {
@@ -59892,17 +60288,17 @@ function siblingAgentDir(agentDir, siblingRoot) {
   if (basename7(agentDir) !== "agent") {
     return void 0;
   }
-  return join27(dirname9(dirname9(agentDir)), siblingRoot, "agent");
+  return join28(dirname10(dirname10(agentDir)), siblingRoot, "agent");
 }
 function createReadOnlyPiSettingsView(cwd, agentDir) {
   const projectRoot = resolvePiExtensionProjectRoot(cwd);
-  const fusionAgentDir = agentDir.includes(`${join27(".fusion", "agent")}`) ? agentDir : siblingAgentDir(agentDir, ".fusion");
-  const legacyAgentDir = agentDir.includes(`${join27(".pi", "agent")}`) ? agentDir : siblingAgentDir(agentDir, ".pi");
-  const legacyGlobalSettings = legacyAgentDir ? readJsonObject2(join27(legacyAgentDir, "settings.json")) : {};
-  const fusionGlobalSettings = fusionAgentDir ? readJsonObject2(join27(fusionAgentDir, "settings.json")) : {};
-  const directGlobalSettings = readJsonObject2(join27(agentDir, "settings.json"));
+  const fusionAgentDir = agentDir.includes(`${join28(".fusion", "agent")}`) ? agentDir : siblingAgentDir(agentDir, ".fusion");
+  const legacyAgentDir = agentDir.includes(`${join28(".pi", "agent")}`) ? agentDir : siblingAgentDir(agentDir, ".pi");
+  const legacyGlobalSettings = legacyAgentDir ? readJsonObject2(join28(legacyAgentDir, "settings.json")) : {};
+  const fusionGlobalSettings = fusionAgentDir ? readJsonObject2(join28(fusionAgentDir, "settings.json")) : {};
+  const directGlobalSettings = readJsonObject2(join28(agentDir, "settings.json"));
   const globalSettings = { ...legacyGlobalSettings, ...directGlobalSettings, ...fusionGlobalSettings };
-  const fusionProjectSettings = readJsonObject2(join27(projectRoot, ".fusion", "settings.json"));
+  const fusionProjectSettings = readJsonObject2(join28(projectRoot, ".fusion", "settings.json"));
   const mergedSettings = { ...globalSettings, ...fusionProjectSettings };
   return {
     getGlobalSettings: () => structuredClone(globalSettings),
@@ -59913,15 +60309,15 @@ function createReadOnlyPiSettingsView(cwd, agentDir) {
 function getPackageManagerAgentDir() {
   const fusionAgentDir = getFusionAgentDir();
   const legacyAgentDir = getLegacyPiAgentDir();
-  const fusionSettings = readJsonObject2(join27(fusionAgentDir, "settings.json"));
-  const legacySettings = readJsonObject2(join27(legacyAgentDir, "settings.json"));
-  if (hasPackageManagerSettings(fusionSettings) || !existsSync22(legacyAgentDir)) {
+  const fusionSettings = readJsonObject2(join28(fusionAgentDir, "settings.json"));
+  const legacySettings = readJsonObject2(join28(legacyAgentDir, "settings.json"));
+  if (hasPackageManagerSettings(fusionSettings) || !existsSync23(legacyAgentDir)) {
     return fusionAgentDir;
   }
   if (hasPackageManagerSettings(legacySettings)) {
     return legacyAgentDir;
   }
-  return existsSync22(fusionAgentDir) ? fusionAgentDir : legacyAgentDir;
+  return existsSync23(fusionAgentDir) ? fusionAgentDir : legacyAgentDir;
 }
 function resolveVendoredClaudeCliEntry() {
   try {
@@ -59932,8 +60328,8 @@ function resolveVendoredClaudeCliEntry() {
     if (!Array.isArray(extensions) || extensions.length === 0) return null;
     const entry = extensions[0];
     if (typeof entry !== "string" || entry.length === 0) return null;
-    const path2 = resolve13(dirname9(pkgJsonPath), entry);
-    return existsSync22(path2) ? path2 : null;
+    const path2 = resolve14(dirname10(pkgJsonPath), entry);
+    return existsSync23(path2) ? path2 : null;
   } catch {
     return null;
   }
@@ -59947,8 +60343,8 @@ function resolveVendoredDroidCliEntry() {
     if (!Array.isArray(extensions) || extensions.length === 0) return null;
     const entry = extensions[0];
     if (typeof entry !== "string" || entry.length === 0) return null;
-    const path2 = resolve13(dirname9(pkgJsonPath), entry);
-    return existsSync22(path2) ? path2 : null;
+    const path2 = resolve14(dirname10(pkgJsonPath), entry);
+    return existsSync23(path2) ? path2 : null;
   } catch {
     return null;
   }
@@ -59976,7 +60372,7 @@ async function registerExtensionProviders(cwd, modelRegistry) {
     const extensionsResult = await discoverAndLoadExtensions(
       doubleReconciledPaths,
       cwd,
-      join27(resolvePiExtensionProjectRoot(cwd), ".fusion", "disabled-auto-extension-discovery")
+      join28(resolvePiExtensionProjectRoot(cwd), ".fusion", "disabled-auto-extension-discovery")
     );
     for (const { path: path2, error } of extensionsResult.errors) {
       extensionsLog.warn(`Failed to load ${path2}: ${error}`);
@@ -60011,9 +60407,9 @@ async function isRegisteredGitWorktree(projectRoot, worktreePath) {
       cwd: projectRoot,
       encoding: "utf-8"
     });
-    const resolvedWorktree = resolve13(worktreePath);
+    const resolvedWorktree = resolve14(worktreePath);
     return stdout.split("\n").some(
-      (line) => line.startsWith("worktree ") && resolve13(line.slice("worktree ".length)) === resolvedWorktree
+      (line) => line.startsWith("worktree ") && resolve14(line.slice("worktree ".length)) === resolvedWorktree
     );
   } catch {
     return false;
@@ -60025,16 +60421,16 @@ async function isCompleteGitWorktree(worktreePath) {
       cwd: worktreePath,
       encoding: "utf-8"
     });
-    return resolve13(stdout.trim()) === resolve13(worktreePath);
+    return resolve14(stdout.trim()) === resolve14(worktreePath);
   } catch {
     return false;
   }
 }
 async function assertValidWorktreeSession(cwd, projectRoot) {
-  if (!existsSync22(cwd)) {
+  if (!existsSync23(cwd)) {
     throw new Error(`Refusing to start coding agent in missing worktree: ${cwd}`);
   }
-  if (!existsSync22(join27(cwd, ".git")) || !await isCompleteGitWorktree(cwd)) {
+  if (!existsSync23(join28(cwd, ".git")) || !await isCompleteGitWorktree(cwd)) {
     throw new Error(`Refusing to start coding agent in incomplete worktree: ${cwd}`);
   }
   if (!await isRegisteredGitWorktree(projectRoot, cwd)) {
@@ -60042,14 +60438,14 @@ async function assertValidWorktreeSession(cwd, projectRoot) {
   }
 }
 function isWorktreeAllowedPath(worktreePath, projectRoot, requestedPath, toolName) {
-  const worktreeResolved = resolve13(worktreePath);
-  const projectRootResolved = resolve13(projectRoot);
-  const requestedResolved = isAbsolute7(requestedPath) ? resolve13(requestedPath) : resolve13(worktreeResolved, requestedPath);
-  const relToWorktree = relative3(worktreeResolved, requestedResolved);
-  if (!relToWorktree.startsWith("..") && !isAbsolute7(relToWorktree)) {
+  const worktreeResolved = resolve14(worktreePath);
+  const projectRootResolved = resolve14(projectRoot);
+  const requestedResolved = isAbsolute8(requestedPath) ? resolve14(requestedPath) : resolve14(worktreeResolved, requestedPath);
+  const relToWorktree = relative4(worktreeResolved, requestedResolved);
+  if (!relToWorktree.startsWith("..") && !isAbsolute8(relToWorktree)) {
     return true;
   }
-  const relToProjectRoot = relative3(projectRootResolved, requestedResolved).replace(/\\/g, "/");
+  const relToProjectRoot = relative4(projectRootResolved, requestedResolved).replace(/\\/g, "/");
   if (relToProjectRoot === ".fusion/memory" || relToProjectRoot === ".fusion/memory/" || relToProjectRoot.startsWith(".fusion/memory/")) {
     return true;
   }
@@ -60103,7 +60499,7 @@ function wrapToolsWithBoundary(tools, worktreePath, projectRoot) {
         const _signal = args[2];
         const pathArg = params.path;
         if (pathArg && !isWorktreeAllowedPath(worktreePath, projectRoot, pathArg, tool.name)) {
-          const relToProject = relative3(projectRoot, pathArg);
+          const relToProject = relative4(projectRoot, pathArg);
           return boundaryRejection(
             `Path "${relToProject}" is outside the worktree boundary. Coding agents can only modify files inside the current worktree. Exceptions (read-only): .fusion/memory/, .fusion/tasks/*/attachments/, and .fusion/tasks/*/{PROMPT.md,task.json} for dependency context.`
           );
@@ -60852,7 +61248,7 @@ ${source.content ?? ""}`;
 
 // ../engine/src/research/providers/local-docs-provider.ts
 import { promises as fs } from "node:fs";
-import { extname as extname2, join as join28, relative as relative4, resolve as resolve14 } from "node:path";
+import { extname as extname2, join as join29, relative as relative5, resolve as resolve15 } from "node:path";
 function buildExcerpt(content, terms) {
   const lower = content.toLowerCase();
   const first = terms.find((term) => lower.includes(term));
@@ -60889,7 +61285,7 @@ var init_local_docs_provider = __esm({
     LocalDocsProvider = class {
       constructor(options) {
         this.options = options;
-        this.projectRoot = resolve14(options.projectRoot);
+        this.projectRoot = resolve15(options.projectRoot);
         this.scanPaths = options.scanPaths ?? ["docs", "README.md", "AGENTS.md", ".fusion/memory"];
       }
       type = "local-docs";
@@ -60915,7 +61311,7 @@ var init_local_docs_provider = __esm({
             score += matches?.length ?? 0;
           }
           if (score <= 0) continue;
-          const relPath = relative4(this.projectRoot, file);
+          const relPath = relative5(this.projectRoot, file);
           results.push({
             score,
             source: {
@@ -60933,7 +61329,7 @@ var init_local_docs_provider = __esm({
       }
       async fetchContent(filePath, config = {}, signal) {
         const timeoutMs = Number(config.timeoutMs ?? this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS3);
-        const resolvedPath = resolve14(this.projectRoot, filePath);
+        const resolvedPath = resolve15(this.projectRoot, filePath);
         if (!resolvedPath.startsWith(this.projectRoot)) {
           throw new ResearchProviderError({
             providerType: "local-docs",
@@ -60941,8 +61337,8 @@ var init_local_docs_provider = __esm({
             message: "Path traversal is not allowed"
           });
         }
-        const stat8 = await this.withTimeout(fs.stat(resolvedPath), timeoutMs, signal);
-        if (!stat8.isFile()) {
+        const stat9 = await this.withTimeout(fs.stat(resolvedPath), timeoutMs, signal);
+        if (!stat9.isFile()) {
           throw new ResearchProviderError({ providerType: "local-docs", code: "provider-unavailable", message: "Path is not a file" });
         }
         const content = await this.withTimeout(fs.readFile(resolvedPath), timeoutMs, signal);
@@ -60954,9 +61350,9 @@ var init_local_docs_provider = __esm({
         return {
           content: text.length > MAX_FILE_SIZE_BYTES ? text.slice(0, MAX_FILE_SIZE_BYTES) : text,
           metadata: {
-            path: relative4(this.projectRoot, resolvedPath),
-            size: stat8.size,
-            modifiedAt: stat8.mtime.toISOString(),
+            path: relative5(this.projectRoot, resolvedPath),
+            size: stat9.size,
+            modifiedAt: stat9.mtime.toISOString(),
             extension: extname2(resolvedPath)
           },
           mimeType: "text/plain"
@@ -60966,13 +61362,13 @@ var init_local_docs_provider = __esm({
         const ignorePatterns = await this.readGitignore();
         const files = [];
         for (const pathEntry of this.scanPaths) {
-          const target = resolve14(this.projectRoot, pathEntry);
+          const target = resolve15(this.projectRoot, pathEntry);
           if (!target.startsWith(this.projectRoot)) continue;
           try {
-            const stat8 = await fs.stat(target);
-            if (stat8.isDirectory()) {
+            const stat9 = await fs.stat(target);
+            if (stat9.isDirectory()) {
               await this.walk(target, files, ignorePatterns, signal);
-            } else if (stat8.isFile()) {
+            } else if (stat9.isFile()) {
               files.push(target);
             }
           } catch {
@@ -60981,7 +61377,7 @@ var init_local_docs_provider = __esm({
         const rootEntries = await fs.readdir(this.projectRoot, { withFileTypes: true });
         for (const entry of rootEntries) {
           if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
-            files.push(join28(this.projectRoot, entry.name));
+            files.push(join29(this.projectRoot, entry.name));
           }
         }
         return [...new Set(files)];
@@ -60991,8 +61387,8 @@ var init_local_docs_provider = __esm({
         const entries = await fs.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
           this.throwIfAborted(signal);
-          const fullPath = join28(dir, entry.name);
-          const relPath = relative4(this.projectRoot, fullPath).replace(/\\/g, "/");
+          const fullPath = join29(dir, entry.name);
+          const relPath = relative5(this.projectRoot, fullPath).replace(/\\/g, "/");
           if (matchesGitignore(relPath, ignorePatterns)) continue;
           if (entry.isDirectory()) {
             await this.walk(fullPath, out, ignorePatterns, signal);
@@ -61003,8 +61399,8 @@ var init_local_docs_provider = __esm({
       }
       async safeReadText(filePath, signal) {
         try {
-          const stat8 = await fs.stat(filePath);
-          if (stat8.size > MAX_FILE_SIZE_BYTES) return void 0;
+          const stat9 = await fs.stat(filePath);
+          if (stat9.size > MAX_FILE_SIZE_BYTES) return void 0;
           const content = await fs.readFile(filePath);
           if (content.subarray(0, BINARY_SNIFF_BYTES).includes(0)) return void 0;
           this.throwIfAborted(signal);
@@ -61016,7 +61412,7 @@ var init_local_docs_provider = __esm({
       }
       async readGitignore() {
         try {
-          const content = await fs.readFile(join28(this.projectRoot, ".gitignore"), "utf-8");
+          const content = await fs.readFile(join29(this.projectRoot, ".gitignore"), "utf-8");
           return content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
         } catch {
           return [];
@@ -61349,8 +61745,8 @@ var init_page_fetch_provider = __esm({
 
 // ../engine/src/research/providers/web-search-provider.ts
 async function sleep(ms, signal) {
-  await new Promise((resolve23, reject) => {
-    const timer = setTimeout(resolve23, ms);
+  await new Promise((resolve24, reject) => {
+    const timer = setTimeout(resolve24, ms);
     const onAbort = () => {
       clearTimeout(timer);
       reject(new ResearchProviderError({ providerType: "web-search", code: "abort", message: "Search aborted" }));
@@ -61818,31 +62214,31 @@ var init_research_step_runner = __esm({
 });
 
 // ../engine/src/agent-tools.ts
-import { appendFile as appendFile3, mkdir as mkdir11, readFile as readFile13, readdir as readdir7, stat as stat4, writeFile as writeFile10 } from "node:fs/promises";
-import { existsSync as existsSync23 } from "node:fs";
+import { appendFile as appendFile3, mkdir as mkdir12, readFile as readFile14, readdir as readdir8, stat as stat5, writeFile as writeFile11 } from "node:fs/promises";
+import { existsSync as existsSync24 } from "node:fs";
 import { createHash as createHash5 } from "node:crypto";
-import { join as join29, relative as relative5, resolve as resolve15 } from "node:path";
+import { join as join30, relative as relative6, resolve as resolve16 } from "node:path";
 import { Type } from "@mariozechner/pi-ai";
 function sanitizeAgentMemoryId(agentId) {
   return agentId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
 }
 function agentMemoryDisplayPath(agentId) {
-  return `${AGENT_MEMORY_ROOT2}/${sanitizeAgentMemoryId(agentId)}/${AGENT_MEMORY_FILENAME2}`;
+  return `${AGENT_MEMORY_ROOT3}/${sanitizeAgentMemoryId(agentId)}/${AGENT_MEMORY_FILENAME2}`;
 }
 function agentDreamsDisplayPath(agentId) {
-  return `${AGENT_MEMORY_ROOT2}/${sanitizeAgentMemoryId(agentId)}/${AGENT_DREAMS_FILENAME2}`;
+  return `${AGENT_MEMORY_ROOT3}/${sanitizeAgentMemoryId(agentId)}/${AGENT_DREAMS_FILENAME2}`;
 }
 function agentMemoryDirectory(rootDir, agentId) {
-  return join29(rootDir, AGENT_MEMORY_ROOT2, sanitizeAgentMemoryId(agentId));
+  return join30(rootDir, AGENT_MEMORY_ROOT3, sanitizeAgentMemoryId(agentId));
 }
 function agentMemoryFilePath(rootDir, agentId) {
-  return join29(agentMemoryDirectory(rootDir, agentId), AGENT_MEMORY_FILENAME2);
+  return join30(agentMemoryDirectory(rootDir, agentId), AGENT_MEMORY_FILENAME2);
 }
 function agentDreamsFilePath(rootDir, agentId) {
-  return join29(agentMemoryDirectory(rootDir, agentId), AGENT_DREAMS_FILENAME2);
+  return join30(agentMemoryDirectory(rootDir, agentId), AGENT_DREAMS_FILENAME2);
 }
 function agentDailyFilePath(rootDir, agentId, date = /* @__PURE__ */ new Date()) {
-  return join29(agentMemoryDirectory(rootDir, agentId), `${date.toISOString().slice(0, 10)}.md`);
+  return join30(agentMemoryDirectory(rootDir, agentId), `${date.toISOString().slice(0, 10)}.md`);
 }
 async function readAgentMemoryWorkspaceLongTerm(rootDir, agentId) {
   const safeRoot = typeof rootDir === "string" ? rootDir.trim() : "";
@@ -61852,11 +62248,11 @@ async function readAgentMemoryWorkspaceLongTerm(rootDir, agentId) {
   }
   const filePath = agentMemoryFilePath(safeRoot, safeAgentId);
   try {
-    const fileStat = await stat4(filePath);
+    const fileStat = await stat5(filePath);
     if (!fileStat.isFile()) {
       return "";
     }
-    const content = await readFile13(filePath, "utf-8");
+    const content = await readFile14(filePath, "utf-8");
     return typeof content === "string" ? content.trim() : "";
   } catch {
     return "";
@@ -61894,9 +62290,9 @@ async function syncAgentMemoryFile(rootDir, agentMemory) {
     return null;
   }
   const dir = agentMemoryDirectory(rootDir, agentMemory.agentId);
-  await mkdir11(dir, { recursive: true });
+  await mkdir12(dir, { recursive: true });
   const longTermPath = agentMemoryFilePath(rootDir, agentMemory.agentId);
-  if (!existsSync23(longTermPath)) {
+  if (!existsSync24(longTermPath)) {
     const title = agentMemory.agentName?.trim() ? `# Agent Memory: ${agentMemory.agentName.trim()}` : "# Agent Memory";
     const fileContent = `${title}
 
@@ -61904,15 +62300,15 @@ async function syncAgentMemoryFile(rootDir, agentMemory) {
 
 ${content || ""}
 `;
-    await writeFile10(longTermPath, fileContent, "utf-8");
+    await writeFile11(longTermPath, fileContent, "utf-8");
   }
   const dreamsPath = agentDreamsFilePath(rootDir, agentMemory.agentId);
-  if (!existsSync23(dreamsPath)) {
-    await writeFile10(dreamsPath, "# Agent Memory Dreams\n\n<!-- Synthesized patterns from this agent's daily notes. -->\n", "utf-8");
+  if (!existsSync24(dreamsPath)) {
+    await writeFile11(dreamsPath, "# Agent Memory Dreams\n\n<!-- Synthesized patterns from this agent's daily notes. -->\n", "utf-8");
   }
   const dailyPath = agentDailyFilePath(rootDir, agentMemory.agentId);
-  if (!existsSync23(dailyPath)) {
-    await writeFile10(dailyPath, `# Agent Daily Memory ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
+  if (!existsSync24(dailyPath)) {
+    await writeFile11(dailyPath, `# Agent Daily Memory ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
 
 <!-- Running observations for this agent. -->
 `, "utf-8");
@@ -61928,19 +62324,19 @@ async function listAgentMemoryFiles2(rootDir, agentMemory) {
   ];
   let entries;
   try {
-    entries = await readdir7(dir);
+    entries = await readdir8(dir);
   } catch (err) {
     log10.warn(`Failed to read agent memory directory ${dir}: ${err instanceof Error ? err.message : String(err)}`);
     entries = [];
   }
   for (const entry of entries) {
     if (!DAILY_AGENT_MEMORY_RE2.test(entry)) continue;
-    const absPath = join29(dir, entry);
-    const fileStat = await stat4(absPath);
+    const absPath = join30(dir, entry);
+    const fileStat = await stat5(absPath);
     if (fileStat.isFile()) {
       files.push({
         absPath,
-        displayPath: `${AGENT_MEMORY_ROOT2}/${sanitizeAgentMemoryId(agentMemory.agentId)}/${entry}`
+        displayPath: `${AGENT_MEMORY_ROOT3}/${sanitizeAgentMemoryId(agentMemory.agentId)}/${entry}`
       });
     }
   }
@@ -61958,7 +62354,7 @@ async function searchAgentMemoryFile(rootDir, agentMemory, query, limit) {
   }
   const results = [];
   for (const file of await listAgentMemoryFiles2(rootDir, agentMemory)) {
-    const content = await readFile13(file.absPath, "utf-8");
+    const content = await readFile14(file.absPath, "utf-8");
     const lines = content.split("\n");
     for (let index = 0; index < lines.length; index += 8) {
       const chunk = lines.slice(index, index + 12).join("\n").trim();
@@ -62036,13 +62432,13 @@ function normalizeQmdAgentMemoryResultPath(rootDir, agentId, rawPath) {
   candidate = candidate.split("?")[0]?.split("#")[0] ?? "";
   candidate = candidate.replace(/^\.\/+/, "");
   const normalizedAgentId = sanitizeAgentMemoryId(agentId);
-  const agentPrefix = `${AGENT_MEMORY_ROOT2}/${normalizedAgentId}/`;
+  const agentPrefix = `${AGENT_MEMORY_ROOT3}/${normalizedAgentId}/`;
   if (candidate.startsWith(agentPrefix)) {
     return resolveAgentMemoryPath(rootDir, agentId, candidate)?.displayPath ?? fallbackPath;
   }
-  const workspacePath = resolve15(agentMemoryDirectory(rootDir, agentId)).replace(/\\/g, "/");
-  const candidateAbs = resolve15(rootDir, candidate).replace(/\\/g, "/");
-  const relToWorkspace = relative5(workspacePath, candidateAbs).replace(/\\/g, "/");
+  const workspacePath = resolve16(agentMemoryDirectory(rootDir, agentId)).replace(/\\/g, "/");
+  const candidateAbs = resolve16(rootDir, candidate).replace(/\\/g, "/");
+  const relToWorkspace = relative6(workspacePath, candidateAbs).replace(/\\/g, "/");
   if (relToWorkspace && !relToWorkspace.startsWith("..") && !relToWorkspace.includes("/../")) {
     const maybeDisplayPath = `${agentPrefix}${relToWorkspace}`;
     return resolveAgentMemoryPath(rootDir, agentId, maybeDisplayPath)?.displayPath ?? fallbackPath;
@@ -62095,7 +62491,7 @@ async function searchAgentMemoryWithQmd(rootDir, agentMemory, query, limit) {
 }
 function resolveAgentMemoryPath(rootDir, agentId, path2) {
   const safeAgentId = sanitizeAgentMemoryId(agentId);
-  const prefix = `${AGENT_MEMORY_ROOT2}/${safeAgentId}/`;
+  const prefix = `${AGENT_MEMORY_ROOT3}/${safeAgentId}/`;
   if (!path2.startsWith(prefix)) {
     return null;
   }
@@ -62104,7 +62500,7 @@ function resolveAgentMemoryPath(rootDir, agentId, path2) {
     return null;
   }
   return {
-    absPath: join29(agentMemoryDirectory(rootDir, agentId), filename),
+    absPath: join30(agentMemoryDirectory(rootDir, agentId), filename),
     displayPath: `${prefix}${filename}`
   };
 }
@@ -62114,7 +62510,7 @@ async function getAgentMemoryWindow(rootDir, agentMemory, path2, startLine = 1,
     return null;
   }
   await syncAgentMemoryFile(rootDir, agentMemory);
-  const content = await readFile13(resolved.absPath, "utf-8");
+  const content = await readFile14(resolved.absPath, "utf-8");
   const lines = content.split("\n");
   const start = Math.max(1, Math.floor(startLine));
   const count = Math.max(1, Math.min(Math.floor(lineCount), 200));
@@ -63123,9 +63519,9 @@ function createResearchTools(options) {
       const maxWaitMs = Math.max(1e3, Math.min(params.max_wait_ms ?? 9e4, resolved.limits.maxDurationMs));
       const completed = await Promise.race([
         runPromise,
-        new Promise((resolve23) => setTimeout(() => {
+        new Promise((resolve24) => setTimeout(() => {
           const latest = options.store.getResearchStore().getRun(runId);
-          resolve23(latest ?? {
+          resolve24(latest ?? {
             id: runId,
             query: params.query,
             status: "running",
@@ -63251,7 +63647,7 @@ ${lines.join("\n")}`
     }
   };
 }
-var taskCreateParams, taskLogParams, taskDocumentWriteParams, taskDocumentReadParams, reflectOnPerformanceParams, readEvaluationsParams, updateIdentityParams, listAgentsParams, delegateTaskParams, getAgentConfigParams, updateAgentConfigParams, createAgentParams, deleteAgentParams, sendMessageParams, readMessagesParams, memorySearchParams, memoryGetParams, webFetchParams, researchRunParams, researchListParams, researchGetParams, researchCancelParams, memoryAppendParams, log10, MAX_INSTRUCTIONS_TEXT_LENGTH, MAX_MEMORY_LENGTH, MAX_SOUL_LENGTH, AGENT_MEMORY_ROOT2, AGENT_MEMORY_FILENAME2, AGENT_DREAMS_FILENAME2, agentQmdRefreshState, AGENT_QMD_REFRESH_INTERVAL_MS, DAILY_AGENT_MEMORY_RE2;
+var taskCreateParams, taskLogParams, taskDocumentWriteParams, taskDocumentReadParams, reflectOnPerformanceParams, readEvaluationsParams, updateIdentityParams, listAgentsParams, delegateTaskParams, getAgentConfigParams, updateAgentConfigParams, createAgentParams, deleteAgentParams, sendMessageParams, readMessagesParams, memorySearchParams, memoryGetParams, webFetchParams, researchRunParams, researchListParams, researchGetParams, researchCancelParams, memoryAppendParams, log10, MAX_INSTRUCTIONS_TEXT_LENGTH, MAX_MEMORY_LENGTH, MAX_SOUL_LENGTH, AGENT_MEMORY_ROOT3, AGENT_MEMORY_FILENAME2, AGENT_DREAMS_FILENAME2, agentQmdRefreshState, AGENT_QMD_REFRESH_INTERVAL_MS, DAILY_AGENT_MEMORY_RE2;
 var init_agent_tools = __esm({
   "../engine/src/agent-tools.ts"() {
     "use strict";
@@ -63422,7 +63818,7 @@ var init_agent_tools = __esm({
     MAX_INSTRUCTIONS_TEXT_LENGTH = 5e4;
     MAX_MEMORY_LENGTH = 5e4;
     MAX_SOUL_LENGTH = 1e4;
-    AGENT_MEMORY_ROOT2 = ".fusion/agent-memory";
+    AGENT_MEMORY_ROOT3 = ".fusion/agent-memory";
     AGENT_MEMORY_FILENAME2 = "MEMORY.md";
     AGENT_DREAMS_FILENAME2 = "DREAMS.md";
     agentQmdRefreshState = /* @__PURE__ */ new Map();
@@ -63962,9 +64358,9 @@ var init_usage_limit_detector = __esm({
 });
 
 // ../engine/src/agent-instructions.ts
-import { readFile as readFile14, writeFile as writeFile11, mkdir as mkdir12, access as access4 } from "node:fs/promises";
+import { readFile as readFile15, writeFile as writeFile12, mkdir as mkdir13, access as access4 } from "node:fs/promises";
 import { constants as fsConstants2 } from "node:fs";
-import { isAbsolute as isAbsolute8, resolve as resolve16, relative as relative6, normalize as normalize3, sep as sep5, dirname as dirname10 } from "node:path";
+import { isAbsolute as isAbsolute9, resolve as resolve17, relative as relative7, normalize as normalize4, sep as sep6, dirname as dirname11 } from "node:path";
 function trimAndClamp(value, maxLength, label, agentId) {
   const trimmed = value.trim();
   if (!trimmed) {
@@ -63994,18 +64390,18 @@ function resolveValidatedMarkdownPath(rawPath, rootDir, agentId, fieldLabel) {
     log12.warn(`${fieldLabel} must end in .md for agent ${agentId}: ${trimmed}`);
     return null;
   }
-  if (isAbsolute8(trimmed)) {
+  if (isAbsolute9(trimmed)) {
     log12.warn(`${fieldLabel} must be project-relative for agent ${agentId}: ${trimmed}`);
     return null;
   }
-  const normalized = normalize3(trimmed);
+  const normalized = normalize4(trimmed);
   if (isPathTraversal2(normalized)) {
     log12.warn(`${fieldLabel} traversal is not allowed for agent ${agentId}: ${trimmed}`);
     return null;
   }
-  const resolvedPath = resolve16(rootDir, normalized);
-  const rel = relative6(rootDir, resolvedPath);
-  if (!rel || rel.startsWith(`..${sep5}`) || rel === ".." || isAbsolute8(rel)) {
+  const resolvedPath = resolve17(rootDir, normalized);
+  const rel = relative7(rootDir, resolvedPath);
+  if (!rel || rel.startsWith(`..${sep6}`) || rel === ".." || isAbsolute9(rel)) {
     log12.warn(`${fieldLabel} escapes project root for agent ${agentId}: ${trimmed}`);
     return null;
   }
@@ -64024,7 +64420,7 @@ async function resolveAgentHeartbeatProcedure(agent, rootDir) {
     return null;
   }
   try {
-    const content = await readFile14(filePath, "utf-8");
+    const content = await readFile15(filePath, "utf-8");
     const normalized = trimAndClamp(
       content,
       MAX_INSTRUCTIONS_TEXT_LENGTH2,
@@ -64053,8 +64449,8 @@ async function ensureDefaultHeartbeatProcedureFile(rootDir, procedurePathRel, de
   } catch {
   }
   try {
-    await mkdir12(dirname10(filePath), { recursive: true });
-    await writeFile11(filePath, defaultContent, "utf-8");
+    await mkdir13(dirname11(filePath), { recursive: true });
+    await writeFile12(filePath, defaultContent, "utf-8");
     log12.log(`Seeded default heartbeat procedure file at ${filePath}`);
     return filePath;
   } catch (err) {
@@ -64154,7 +64550,7 @@ async function resolveAgentInstructions(agent, rootDir, ratingSummary) {
     const filePath = resolveValidatedInstructionsPath(agent.instructionsPath, rootDir, agent.id);
     if (filePath) {
       try {
-        const content = await readFile14(filePath, "utf-8");
+        const content = await readFile15(filePath, "utf-8");
         const normalizedContent = trimAndClamp(
           content,
           MAX_INSTRUCTIONS_TEXT_LENGTH2,
@@ -64282,6 +64678,16 @@ var init_agent_instructions = __esm({
 });
 
 // ../engine/src/notification/ntfy-provider.ts
+function resolveParticipantLabel(metadata, kind) {
+  const nameKey = kind === "from" ? "fromName" : "toName";
+  const idKey = kind === "from" ? "fromId" : "toId";
+  const name = typeof metadata?.[nameKey] === "string" ? metadata[nameKey].trim() : "";
+  if (name.length > 0) {
+    return name;
+  }
+  const id = typeof metadata?.[idKey] === "string" ? metadata[idKey].trim() : "";
+  return id.length > 0 ? id : kind === "from" ? "agent" : "recipient";
+}
 var SUPPORTED_EVENTS, NtfyNotificationProvider;
 var init_ntfy_provider = __esm({
   "../engine/src/notification/ntfy-provider.ts"() {
@@ -64348,8 +64754,8 @@ var init_ntfy_provider = __esm({
         };
         const identifier = formatTaskIdentifier(taskLike);
         const messageId = typeof payload.metadata?.messageId === "string" ? payload.metadata.messageId : void 0;
-        const senderLabel = typeof payload.metadata?.fromId === "string" ? payload.metadata.fromId : "agent";
-        const recipientLabel = typeof payload.metadata?.toId === "string" ? payload.metadata.toId : "recipient";
+        const senderLabel = resolveParticipantLabel(payload.metadata, "from");
+        const recipientLabel = resolveParticipantLabel(payload.metadata, "to");
         const preview = typeof payload.metadata?.preview === "string" ? payload.metadata.preview : "(no preview)";
         const replyToMessageId = typeof payload.metadata?.replyToMessageId === "string" ? payload.metadata.replyToMessageId : void 0;
         const clickUrl = buildNtfyClickUrl({
@@ -64441,6 +64847,16 @@ var init_ntfy_provider = __esm({
 });
 
 // ../engine/src/notification/webhook-provider.ts
+function resolveParticipantLabel2(metadata, kind) {
+  const nameKey = kind === "from" ? "fromName" : "toName";
+  const idKey = kind === "from" ? "fromId" : "toId";
+  const name = typeof metadata?.[nameKey] === "string" ? metadata[nameKey].trim() : "";
+  if (name.length > 0) {
+    return name;
+  }
+  const id = typeof metadata?.[idKey] === "string" ? metadata[idKey].trim() : "";
+  return id.length > 0 ? id : kind === "from" ? "agent" : "recipient";
+}
 var WebhookNotificationProvider;
 var init_webhook_provider = __esm({
   "../engine/src/notification/webhook-provider.ts"() {
@@ -64550,6 +64966,17 @@ var init_webhook_provider = __esm({
             return "Pipeline gridlocked";
           case "fallback-used":
             return `Fusion recovered by switching from ${String(payload.metadata?.primaryModel ?? "primary model")} to ${String(payload.metadata?.fallbackModel ?? "fallback model")} (${String(payload.metadata?.triggerPoint ?? "unknown trigger")})`;
+          case "message:agent-to-user": {
+            const from = resolveParticipantLabel2(payload.metadata, "from");
+            const preview = typeof payload.metadata?.preview === "string" ? payload.metadata.preview : "(no preview)";
+            return `From: ${from} \u2192 You: ${preview}`;
+          }
+          case "message:agent-to-agent": {
+            const from = resolveParticipantLabel2(payload.metadata, "from");
+            const to = resolveParticipantLabel2(payload.metadata, "to");
+            const preview = typeof payload.metadata?.preview === "string" ? payload.metadata.preview : "(no preview)";
+            return `From: ${from} \u2192 To: ${to}: ${preview}`;
+          }
           default:
             return `Event "${event}" for task ${identifier}`;
         }
@@ -64573,6 +65000,8 @@ var init_webhook_provider = __esm({
           return { content: message };
         }
         const messageId = typeof payload.metadata?.messageId === "string" ? payload.metadata.messageId : void 0;
+        const fromLabel = resolveParticipantLabel2(payload.metadata, "from");
+        const toLabel = resolveParticipantLabel2(payload.metadata, "to");
         return {
           event: payload.event,
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -64580,7 +65009,13 @@ var init_webhook_provider = __esm({
             id: payload.taskId,
             title: payload.taskTitle
           },
-          metadata: payload.metadata,
+          metadata: {
+            ...payload.metadata,
+            ...payload.event === "message:agent-to-user" || payload.event === "message:agent-to-agent" ? {
+              fromName: typeof payload.metadata?.fromName === "string" ? payload.metadata.fromName : fromLabel,
+              toName: typeof payload.metadata?.toName === "string" ? payload.metadata.toName : toLabel
+            } : {}
+          },
           clickUrl: buildNtfyClickUrl({
             dashboardHost: this.config.dashboardHost,
             projectId: this.config.projectId,
@@ -64785,6 +65220,8 @@ var init_notification_service = __esm({
         }
         const preview = message.content.length > 100 ? `${message.content.slice(0, 100)}\u2026` : message.content;
         const taskId = typeof message.metadata?.taskId === "string" ? message.metadata.taskId : void 0;
+        const fromName = await this.resolveAgentName(message.fromType, message.fromId, "from");
+        const toName = await this.resolveAgentName(message.toType, message.toId, "to");
         this.maybeNotify(message.id, eventType, {
           taskId,
           taskTitle: void 0,
@@ -64793,8 +65230,10 @@ var init_notification_service = __esm({
             messageId: message.id,
             fromId: message.fromId,
             fromType: message.fromType,
+            ...fromName ? { fromName } : {},
             toId: message.toId,
             toType: message.toType,
+            ...toName ? { toName } : {},
             type: message.type,
             replyToMessageId: message.metadata?.replyTo?.messageId,
             preview
@@ -64804,6 +65243,26 @@ var init_notification_service = __esm({
           `NotificationService.handleMessageSent scheduled eventType=${eventType} messageId=${message.id}`
         );
       }
+      async resolveAgentName(participantType, participantId, direction) {
+        if (participantType !== "agent") {
+          return null;
+        }
+        const resolver = this.options.agentNameResolver;
+        if (!resolver) {
+          return null;
+        }
+        try {
+          const resolved = await resolver(participantId);
+          const trimmed = typeof resolved === "string" ? resolved.trim() : "";
+          return trimmed.length > 0 ? trimmed : null;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          schedulerLog.log(
+            `NotificationService.handleMessageSent failed to resolve ${direction} agent name agentId=${participantId} error=${message}`
+          );
+          return null;
+        }
+      }
       setNotificationsEnabledFromSettings(settings) {
         this.notificationsEnabled = Boolean(
           settings.ntfyEnabled && settings.ntfyTopic || settings.webhookEnabled && settings.webhookUrl
@@ -65006,7 +65465,8 @@ var init_notifier = __esm({
         this.projectId = options.projectId;
         this.notificationService = notificationService ?? new NotificationService(store, {
           projectId: this.projectId,
-          ntfyBaseUrl: options.ntfyBaseUrl
+          ntfyBaseUrl: options.ntfyBaseUrl,
+          agentNameResolver: options.agentNameResolver
         });
         activeNotificationService = this.notificationService;
       }
@@ -65759,20 +66219,20 @@ async function withRateLimitRetry(fn, options = {}) {
   throw lastError ?? new Error("withRateLimitRetry: unexpected state");
 }
 function sleep2(ms, signal) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     if (signal?.aborted) {
       reject(signal.reason ?? new Error("Aborted"));
       return;
     }
-    const timer = setTimeout(resolve23, ms);
+    const timer = setTimeout(resolve24, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
         reject(signal.reason ?? new Error("Aborted"));
       };
       signal.addEventListener("abort", onAbort, { once: true });
-      const origResolve = resolve23;
-      resolve23 = () => {
+      const origResolve = resolve24;
+      resolve24 = () => {
         signal.removeEventListener("abort", onAbort);
         origResolve();
       };
@@ -65861,8 +66321,8 @@ If research is disabled or providers are not configured, use the actionable tool
 
 // ../engine/src/triage.ts
 import { Type as Type2 } from "@mariozechner/pi-ai";
-import { readFile as readFile15 } from "node:fs/promises";
-import { join as join30 } from "node:path";
+import { readFile as readFile16 } from "node:fs/promises";
+import { join as join31 } from "node:path";
 function extractPromptDeclaredTitle(prompt, taskId) {
   const headingMatch = prompt.match(/^#\s+Task:\s+([A-Z]+-\d+)\s+-\s+(.+)$/m);
   if (!headingMatch) return null;
@@ -65890,10 +66350,10 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
   if (!attachments || attachments.length === 0) {
     return { attachmentContents, imageContents };
   }
-  const { readFile: readFile22 } = await import("node:fs/promises");
-  const { join: join46 } = await import("node:path");
+  const { readFile: readFile23 } = await import("node:fs/promises");
+  const { join: join47 } = await import("node:path");
   for (const att of attachments) {
-    const filePath = join46(
+    const filePath = join47(
       rootDir,
       ".fusion",
       "tasks",
@@ -65903,7 +66363,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
     );
     try {
       if (IMAGE_MIME_TYPES.has(att.mimeType)) {
-        const data = await readFile22(filePath);
+        const data = await readFile23(filePath);
         imageContents.push({
           type: "image",
           data: data.toString("base64"),
@@ -65915,7 +66375,7 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
           text: null
         });
       } else {
-        const data = await readFile22(filePath, "utf-8");
+        const data = await readFile23(filePath, "utf-8");
         const text = data.length > TEXT_INLINE_LIMIT ? data.slice(0, TEXT_INLINE_LIMIT) + "\n... (truncated at 50KB)" : data;
         attachmentContents.push({
           originalName: att.originalName,
@@ -66736,8 +67196,8 @@ Write the PROMPT.md directly using the write tool, then call \`fn_review_spec()\
           return false;
         }
         const settings = await this.store.getSettings();
-        const promptPath = join30(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
-        const written = await readFile15(promptPath, "utf-8").catch((err) => {
+        const promptPath = join31(this.rootDir, ".fusion", "tasks", task.id, "PROMPT.md");
+        const written = await readFile16(promptPath, "utf-8").catch((err) => {
           const msg = err instanceof Error ? err.message : String(err);
           planLog.warn(`${task.id}: failed to read PROMPT.md during approved-spec recovery (${promptPath}): ${msg}`);
           return "";
@@ -67244,8 +67704,8 @@ ${triagePluginContributions}` : triageSystemPrompt;
                 await this.store.updateTask(task.id, { status: "needs-replan" });
                 return;
               }
-              const written = await readFile15(
-                join30(this.rootDir, promptPath),
+              const written = await readFile16(
+                join31(this.rootDir, promptPath),
                 "utf-8"
               ).catch((err) => {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -67563,10 +68023,10 @@ Remove or replace these ids and call fn_task_create again.`
               checkpointRef.current = sessionRef.current.sessionManager.getLeafId() ?? null;
             }
             try {
-              const { readFile: readFile22 } = await import("node:fs/promises");
-              const { join: join46 } = await import("node:path");
-              const promptContent = await readFile22(
-                join46(rootDir, promptPath),
+              const { readFile: readFile23 } = await import("node:fs/promises");
+              const { join: join47 } = await import("node:path");
+              const promptContent = await readFile23(
+                join47(rootDir, promptPath),
                 "utf-8"
               ).catch((err) => {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -67797,7 +68257,7 @@ Take a completely different approach to writing this specification. Do NOT repea
 // ../engine/src/verification-utils.ts
 import { spawn as spawn3 } from "node:child_process";
 async function execWithProcessGroup(command, options) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     if (options.signal?.aborted) {
       reject(Object.assign(
         new Error(`Command aborted before start: ${command}`),
@@ -67811,7 +68271,13 @@ async function execWithProcessGroup(command, options) {
       shell: true,
       detached: useProcessGroup,
       stdio: ["ignore", "pipe", "pipe"],
-      ...options.env !== void 0 && { env: { ...process.env, ...options.env } }
+      env: {
+        ...process.env,
+        // Corepack otherwise prompts interactively before fetching a pinned
+        // packageManager version, hanging the non-TTY child until timeout.
+        COREPACK_ENABLE_DOWNLOAD_PROMPT: "0",
+        ...options.env ?? {}
+      }
     });
     let stdout = "";
     let stderr = "";
@@ -67891,7 +68357,7 @@ async function execWithProcessGroup(command, options) {
         return;
       }
       if (code === 0) {
-        resolve23({ stdout, stderr, bufferOverflow: stdoutOverflow || stderrOverflow });
+        resolve24({ stdout, stderr, bufferOverflow: stdoutOverflow || stderrOverflow });
         return;
       }
       reject(Object.assign(
@@ -68286,9 +68752,9 @@ var init_run_audit = __esm({
 // ../engine/src/merger.ts
 import { execSync, exec as exec3, execFile as execFile3 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import { existsSync as existsSync24, readFileSync as readFileSync11, writeFileSync as writeFileSync2, unlinkSync, renameSync as renameSync2 } from "node:fs";
+import { existsSync as existsSync25, readFileSync as readFileSync11, writeFileSync as writeFileSync2, unlinkSync, renameSync as renameSync2 } from "node:fs";
 import { createHash as createHash6 } from "node:crypto";
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 import { hostname } from "node:os";
 import { Type as Type3 } from "typebox";
 function truncateWorkflowScriptOutput(output) {
@@ -68334,7 +68800,7 @@ async function getStagedFiles(cwd) {
   }
 }
 function hasInstallState(rootDir) {
-  return existsSync24(join31(rootDir, "node_modules")) || existsSync24(join31(rootDir, ".pnp.cjs"));
+  return existsSync25(join32(rootDir, "node_modules")) || existsSync25(join32(rootDir, ".pnp.cjs"));
 }
 function shouldSyncDependenciesForMerge(stagedFiles, installStatePresent) {
   if (!installStatePresent) return true;
@@ -68343,18 +68809,18 @@ function shouldSyncDependenciesForMerge(stagedFiles, installStatePresent) {
   );
 }
 function getDependencySyncCommand(rootDir) {
-  if (existsSync24(join31(rootDir, "pnpm-lock.yaml"))) return "pnpm install --frozen-lockfile";
-  if (existsSync24(join31(rootDir, "package-lock.json"))) return "npm install";
-  if (existsSync24(join31(rootDir, "yarn.lock"))) return "yarn install --frozen-lockfile";
-  if (existsSync24(join31(rootDir, "bun.lock")) || existsSync24(join31(rootDir, "bun.lockb"))) {
+  if (existsSync25(join32(rootDir, "pnpm-lock.yaml"))) return "pnpm install --frozen-lockfile";
+  if (existsSync25(join32(rootDir, "package-lock.json"))) return "npm install";
+  if (existsSync25(join32(rootDir, "yarn.lock"))) return "yarn install --frozen-lockfile";
+  if (existsSync25(join32(rootDir, "bun.lock")) || existsSync25(join32(rootDir, "bun.lockb"))) {
     return "bun install --frozen-lockfile";
   }
   return null;
 }
 function computeLockfileHash(rootDir) {
   for (const name of LOCKFILE_CANDIDATES) {
-    const p = join31(rootDir, name);
-    if (existsSync24(p)) {
+    const p = join32(rootDir, name);
+    if (existsSync25(p)) {
       try {
         return createHash6("sha256").update(readFileSync11(p)).digest("hex");
       } catch {
@@ -68366,7 +68832,7 @@ function computeLockfileHash(rootDir) {
 }
 function readInstallMarker(rootDir) {
   try {
-    const value = readFileSync11(join31(rootDir, INSTALL_MARKER_RELPATH), "utf-8").trim();
+    const value = readFileSync11(join32(rootDir, INSTALL_MARKER_RELPATH), "utf-8").trim();
     return value || null;
   } catch {
     return null;
@@ -68374,7 +68840,7 @@ function readInstallMarker(rootDir) {
 }
 function writeInstallMarker(rootDir, hash) {
   try {
-    writeFileSync2(join31(rootDir, INSTALL_MARKER_RELPATH), hash);
+    writeFileSync2(join32(rootDir, INSTALL_MARKER_RELPATH), hash);
   } catch {
   }
 }
@@ -68466,8 +68932,8 @@ function inferDefaultTestCommand(rootDir, explicitTestCommand, explicitBuildComm
       buildSource: explicitBuildCommand?.trim() ? "explicit" : void 0
     };
   }
-  if (existsSync24(join31(rootDir, "pnpm-lock.yaml"))) {
-    if (existsSync24(join31(rootDir, "pnpm-workspace.yaml"))) {
+  if (existsSync25(join32(rootDir, "pnpm-lock.yaml"))) {
+    if (existsSync25(join32(rootDir, "pnpm-workspace.yaml"))) {
       mergerLog.warn(
         `Inferred test command "pnpm test" in a pnpm workspace (${rootDir}). This runs the full monorepo suite on every merge. Consider setting an explicit scoped testCommand in project settings, e.g. \`pnpm -r --filter "...[main]" test\`.`
       );
@@ -68478,21 +68944,21 @@ function inferDefaultTestCommand(rootDir, explicitTestCommand, explicitBuildComm
       buildSource: explicitBuildCommand?.trim() ? "explicit" : void 0
     };
   }
-  if (existsSync24(join31(rootDir, "yarn.lock"))) {
+  if (existsSync25(join32(rootDir, "yarn.lock"))) {
     return {
       command: "yarn test",
       testSource: "inferred",
       buildSource: explicitBuildCommand?.trim() ? "explicit" : void 0
     };
   }
-  if (existsSync24(join31(rootDir, "bun.lock")) || existsSync24(join31(rootDir, "bun.lockb"))) {
+  if (existsSync25(join32(rootDir, "bun.lock")) || existsSync25(join32(rootDir, "bun.lockb"))) {
     return {
       command: "bun test",
       testSource: "inferred",
       buildSource: explicitBuildCommand?.trim() ? "explicit" : void 0
     };
   }
-  if (existsSync24(join31(rootDir, "package-lock.json"))) {
+  if (existsSync25(join32(rootDir, "package-lock.json"))) {
     return {
       command: "npm test",
       testSource: "inferred",
@@ -68931,7 +69397,7 @@ async function stashTreesEqual(rootDir, aSha, bSha) {
 }
 function writeActiveMergerStatus(rootDir, taskId) {
   try {
-    const statusPath = join31(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
+    const statusPath = join32(rootDir, ".git", ACTIVE_MERGER_STATUS_FILENAME);
     const payload = {
       taskId,
       pid: process.pid,
@@ -69362,8 +69828,8 @@ async function findFilesWithConflictMarkers(rootDir, files) {
   const stillConflicted = [];
   for (const file of files) {
     try {
-      const fullPath = join31(rootDir, file);
-      if (!existsSync24(fullPath)) continue;
+      const fullPath = join32(rootDir, file);
+      if (!existsSync25(fullPath)) continue;
       const { stdout } = await execAsync2(
         `git grep -l -e "^<<<<<<< " -e "^=======$" -e "^>>>>>>> " --no-index -- ${quoteArg(fullPath)}`,
         { cwd: rootDir, encoding: "utf-8" }
@@ -69389,7 +69855,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 = join31(rootDir, ".git", `fusion-autostash-${sha.slice(0, 7)}.patch`);
+      const patchPath = join32(rootDir, ".git", `fusion-autostash-${sha.slice(0, 7)}.patch`);
       writeFileSync2(patchPath, patchText, "utf-8");
       try {
         await execAsync2(`git apply --3way --whitespace=nowarn ${quoteArg(patchPath)}`, { cwd: rootDir });
@@ -70226,16 +70692,46 @@ async function resolveTaskDiffBaseRef({
       return mergeBase;
     }
   }
+  let recoveredBase;
+  if (!baseBranch?.trim()) {
+    try {
+      const { stdout } = await execAsync2(`git merge-base ${quotedHeadRef} main`, {
+        cwd,
+        encoding: "utf-8"
+      });
+      recoveredBase = stdout.trim() || void 0;
+    } catch {
+      try {
+        const { stdout } = await execAsync2(`git merge-base ${quotedHeadRef} ${quoteArg("origin/main")}`, {
+          cwd,
+          encoding: "utf-8"
+        });
+        recoveredBase = stdout.trim() || void 0;
+      } catch {
+      }
+    }
+  }
   if (baseCommitSha) {
     try {
       await execAsync2(`git merge-base --is-ancestor ${quoteArg(baseCommitSha)} ${quotedHeadRef}`, {
         cwd,
         encoding: "utf-8"
       });
+      if (recoveredBase && recoveredBase !== baseCommitSha) {
+        try {
+          await execAsync2(`git merge-base --is-ancestor ${quoteArg(baseCommitSha)} ${quoteArg(recoveredBase)}`, {
+            cwd,
+            encoding: "utf-8"
+          });
+          return recoveredBase;
+        } catch {
+        }
+      }
       return baseCommitSha;
     } catch {
     }
   }
+  if (recoveredBase) return recoveredBase;
   try {
     const { stdout } = await execAsync2(`git rev-parse ${quoteArg(`${headRef}~1`)}`, {
       cwd,
@@ -70882,7 +71378,7 @@ async function pushToRemoteAfterMerge(store, rootDir, taskId, settings, options)
 }
 async function createPostMergeWorktree(rootDir, taskId) {
   const randomSuffix = Math.random().toString(36).slice(2, 10);
-  const postMergeWorktree = join31(rootDir, ".worktrees", `post-merge-${taskId}-${randomSuffix}`);
+  const postMergeWorktree = join32(rootDir, ".worktrees", `post-merge-${taskId}-${randomSuffix}`);
   try {
     await execAsync2(`git worktree add ${quoteArg(postMergeWorktree)} HEAD`, { cwd: rootDir });
     return postMergeWorktree;
@@ -71460,7 +71956,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
         }
         if (error.name === "VerificationError") {
           const verificationErr = error;
-          const maxFixRetries = Math.min(settings.verificationFixRetries ?? 3, 3);
+          const maxFixRetries = Math.min(settings.verificationFixRetries ?? 2, 3);
           if (maxFixRetries > 0 && (verificationErr.verificationResult.testResult || verificationErr.verificationResult.buildResult)) {
             mergerLog.log(`${taskId}: deterministic verification failed \u2014 attempting in-merge fix (up to ${maxFixRetries} attempts)`);
             await store.logEntry(taskId, `Verification failed during merge \u2014 attempting in-merge fix (up to ${maxFixRetries} attempts)`);
@@ -71568,7 +72064,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
           throw error;
         }
         if (error.message?.includes("Build verification failed")) {
-          const maxFixRetries = Math.min(settings.verificationFixRetries ?? 3, 3);
+          const maxFixRetries = Math.min(settings.verificationFixRetries ?? 2, 3);
           if (maxFixRetries > 0 && (effectiveTestCommand || effectiveBuildCommand)) {
             mergerLog.log(`${taskId}: build verification failed \u2014 attempting in-merge fix`);
             await store.logEntry(taskId, `Build verification failed during merge \u2014 attempting in-merge fix`);
@@ -71857,7 +72353,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
       }
     }
     throwIfAborted(options.signal, taskId);
-    if (worktreePath && existsSync24(worktreePath)) {
+    if (worktreePath && existsSync25(worktreePath)) {
       const otherUser = await findWorktreeUser(store, worktreePath, taskId);
       if (otherUser) {
         mergerLog.log(`Worktree retained \u2014 still needed by ${otherUser}`);
@@ -73092,7 +73588,7 @@ var init_merger = __esm({
     PUSH_TIMEOUT_MS = 6e4;
     MERGE_COMMIT_LOG_MAX_CHARS = 5e3;
     MERGE_DIFF_STAT_MAX_CHARS = 3e3;
-    INSTALL_MARKER_RELPATH = join31("node_modules", ".fusion-install-marker");
+    INSTALL_MARKER_RELPATH = join32("node_modules", ".fusion-install-marker");
     LOCKFILE_CANDIDATES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb", "bun.lock"];
     VerificationError = class extends Error {
       constructor(message, verificationResult) {
@@ -73122,8 +73618,8 @@ var init_merger = __esm({
 
 // ../engine/src/worktree-names.ts
 import { readdirSync as readdirSync3 } from "node:fs";
-import { join as join32 } from "node:path";
-import { existsSync as existsSync25 } from "node:fs";
+import { join as join33 } from "node:path";
+import { existsSync as existsSync26 } from "node:fs";
 function slugify2(str) {
   return str.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
@@ -73134,7 +73630,7 @@ function generateReservedWorktreeName(rootDir, reservedNames = /* @__PURE__ */ n
   const adjective = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
   const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
   const baseName = `${adjective}-${noun}`;
-  const worktreesDir = join32(rootDir, ".worktrees");
+  const worktreesDir = join33(rootDir, ".worktrees");
   const existing = getExistingWorktreeNames(worktreesDir);
   for (const reserved of reservedNames) {
     existing.add(reserved);
@@ -73168,10 +73664,10 @@ function planTaskWorktreePath(task, rootDir, naming, reservedNames) {
       break;
   }
   reservedNames.add(worktreeName);
-  return join32(rootDir, ".worktrees", worktreeName);
+  return join33(rootDir, ".worktrees", worktreeName);
 }
 function getExistingWorktreeNames(worktreesDir) {
-  if (!existsSync25(worktreesDir)) {
+  if (!existsSync26(worktreesDir)) {
     return /* @__PURE__ */ new Set();
   }
   try {
@@ -73308,8 +73804,8 @@ __export(worktree_pool_exports, {
 });
 import { exec as exec4 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
-import { existsSync as existsSync26, lstatSync, readdirSync as readdirSync4, rmSync as rmSync2 } from "node:fs";
-import { join as join33, relative as relative7, resolve as resolve17, isAbsolute as isAbsolute9 } from "node:path";
+import { existsSync as existsSync27, lstatSync, readdirSync as readdirSync4, rmSync as rmSync2 } from "node:fs";
+import { join as join34, relative as relative8, resolve as resolve18, isAbsolute as isAbsolute10 } from "node:path";
 function getExecStdout(result) {
   if (typeof result === "string") return result;
   if (result && typeof result === "object" && "stdout" in result) {
@@ -73341,7 +73837,7 @@ async function getRegisteredWorktreePaths(rootDir) {
     const paths = /* @__PURE__ */ new Set();
     for (const line of stdout.split("\n")) {
       if (line.startsWith("worktree ")) {
-        paths.add(resolve17(line.slice("worktree ".length)));
+        paths.add(resolve18(line.slice("worktree ".length)));
       }
     }
     return paths;
@@ -73352,29 +73848,29 @@ async function getRegisteredWorktreePaths(rootDir) {
   }
 }
 async function isRegisteredGitWorktree2(rootDir, worktreePath) {
-  return (await getRegisteredWorktreePaths(rootDir)).has(resolve17(worktreePath));
+  return (await getRegisteredWorktreePaths(rootDir)).has(resolve18(worktreePath));
 }
 function hasRequiredWorktreeFiles(worktreePath) {
-  return existsSync26(join33(worktreePath, ".git")) && existsSync26(join33(worktreePath, "package.json"));
+  return existsSync27(join34(worktreePath, ".git")) && existsSync27(join34(worktreePath, "package.json"));
 }
 async function isUsableTaskWorktree(rootDir, worktreePath) {
-  return existsSync26(worktreePath) && await isRegisteredGitWorktree2(rootDir, worktreePath) && hasRequiredWorktreeFiles(worktreePath);
+  return existsSync27(worktreePath) && await isRegisteredGitWorktree2(rootDir, worktreePath) && hasRequiredWorktreeFiles(worktreePath);
 }
 function isInsideWorktreesDir(rootDir, worktreePath) {
-  const worktreesDir = resolve17(rootDir, ".worktrees");
-  const target = resolve17(worktreePath);
-  const rel = relative7(worktreesDir, target);
-  return rel !== "" && !rel.startsWith("..") && !isAbsolute9(rel);
+  const worktreesDir = resolve18(rootDir, ".worktrees");
+  const target = resolve18(worktreePath);
+  const rel = relative8(worktreesDir, target);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute10(rel);
 }
 async function scanIdleWorktrees(rootDir, store) {
-  const worktreesDir = join33(rootDir, ".worktrees");
-  if (!existsSync26(worktreesDir)) {
+  const worktreesDir = join34(rootDir, ".worktrees");
+  if (!existsSync27(worktreesDir)) {
     return [];
   }
   let dirs;
   try {
     const entries = readdirSync4(worktreesDir, { withFileTypes: true });
-    dirs = entries.filter((e) => e.isDirectory()).map((e) => join33(worktreesDir, e.name));
+    dirs = entries.filter((e) => e.isDirectory()).map((e) => join34(worktreesDir, e.name));
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
     worktreePoolLog.warn(`Failed to read .worktrees/ directory: ${errorMessage}`);
@@ -73384,41 +73880,41 @@ async function scanIdleWorktrees(rootDir, store) {
     return [];
   }
   const registeredWorktrees = await getRegisteredWorktreePaths(rootDir);
-  const registeredDirs = dirs.filter((dir) => registeredWorktrees.has(resolve17(dir)));
+  const registeredDirs = dirs.filter((dir) => registeredWorktrees.has(resolve18(dir)));
   const tasks = await store.listTasks({ slim: true, includeArchived: false });
   const activeWorktrees = /* @__PURE__ */ new Set();
   for (const task of tasks) {
-    if (task.worktree && task.column !== "done" && registeredWorktrees.has(resolve17(task.worktree))) {
-      activeWorktrees.add(resolve17(task.worktree));
+    if (task.worktree && task.column !== "done" && registeredWorktrees.has(resolve18(task.worktree))) {
+      activeWorktrees.add(resolve18(task.worktree));
     } else if (task.worktree && task.column !== "done") {
       worktreePoolLog.log(`Ignoring task ${task.id} worktree metadata because it is not a registered git worktree: ${task.worktree}`);
     }
   }
-  return registeredDirs.filter((dir) => !activeWorktrees.has(resolve17(dir)));
+  return registeredDirs.filter((dir) => !activeWorktrees.has(resolve18(dir)));
 }
 async function cleanupOrphanedWorktrees(rootDir, store) {
-  const worktreesDir = join33(rootDir, ".worktrees");
-  if (!existsSync26(worktreesDir)) {
+  const worktreesDir = join34(rootDir, ".worktrees");
+  if (!existsSync27(worktreesDir)) {
     return 0;
   }
   const orphaned = await scanIdleWorktrees(rootDir, store);
   const registeredWorktrees = await getRegisteredWorktreePaths(rootDir);
   let dirs = [];
-  if (existsSync26(worktreesDir)) {
+  if (existsSync27(worktreesDir)) {
     try {
-      dirs = readdirSync4(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join33(worktreesDir, e.name));
+      dirs = readdirSync4(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join34(worktreesDir, e.name));
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
       worktreePoolLog.warn(`Failed to read .worktrees/ directory for cleanup: ${errorMessage}`);
       dirs = [];
     }
   }
-  const unregistered = dirs.filter((dir) => !registeredWorktrees.has(resolve17(dir)));
+  const unregistered = dirs.filter((dir) => !registeredWorktrees.has(resolve18(dir)));
   const candidates = [...orphaned, ...unregistered];
   let cleaned = 0;
   for (const worktreePath of candidates) {
     try {
-      if (registeredWorktrees.has(resolve17(worktreePath))) {
+      if (registeredWorktrees.has(resolve18(worktreePath))) {
         await execAsync3(`git worktree remove "${worktreePath}" --force`, {
           cwd: rootDir
         });
@@ -73438,8 +73934,8 @@ async function cleanupOrphanedWorktrees(rootDir, store) {
   return cleaned;
 }
 async function reapOrphanWorktrees(projectRoot) {
-  const worktreesDir = join33(projectRoot, ".worktrees");
-  if (!existsSync26(worktreesDir)) {
+  const worktreesDir = join34(projectRoot, ".worktrees");
+  if (!existsSync27(worktreesDir)) {
     return 0;
   }
   let entries;
@@ -73447,11 +73943,11 @@ async function reapOrphanWorktrees(projectRoot) {
     entries = readdirSync4(worktreesDir, { withFileTypes: true }).filter((e) => {
       if (!e.isDirectory()) return false;
       try {
-        return lstatSync(join33(worktreesDir, e.name)).isDirectory() && !lstatSync(join33(worktreesDir, e.name)).isSymbolicLink();
+        return lstatSync(join34(worktreesDir, e.name)).isDirectory() && !lstatSync(join34(worktreesDir, e.name)).isSymbolicLink();
       } catch {
         return false;
       }
-    }).map((e) => ({ name: e.name, fullPath: join33(worktreesDir, e.name) }));
+    }).map((e) => ({ name: e.name, fullPath: join34(worktreesDir, e.name) }));
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     worktreePoolLog.warn(`reapOrphanWorktrees: failed to read .worktrees/ \u2014 ${msg}`);
@@ -73461,17 +73957,17 @@ async function reapOrphanWorktrees(projectRoot) {
   const registered = await getRegisteredWorktreePaths(projectRoot);
   let removed = 0;
   for (const { name, fullPath } of entries) {
-    const resolvedFull = resolve17(fullPath);
-    const rel = relative7(resolve17(worktreesDir), resolvedFull);
-    if (!rel || rel.startsWith("..") || isAbsolute9(rel)) {
+    const resolvedFull = resolve18(fullPath);
+    const rel = relative8(resolve18(worktreesDir), resolvedFull);
+    if (!rel || rel.startsWith("..") || isAbsolute10(rel)) {
       worktreePoolLog.warn(`reapOrphanWorktrees: skipping out-of-bounds path ${fullPath}`);
       continue;
     }
     if (registered.has(resolvedFull)) {
       continue;
     }
-    const dotGit = join33(resolvedFull, ".git");
-    if (existsSync26(dotGit)) {
+    const dotGit = join34(resolvedFull, ".git");
+    if (existsSync27(dotGit)) {
       worktreePoolLog.log(`reapOrphanWorktrees: skipping ${name} (has .git entry but not in registered list \u2014 may be partially registered)`);
       continue;
     }
@@ -73531,7 +74027,7 @@ var init_worktree_pool = __esm({
       acquire() {
         for (const path2 of this.idle) {
           this.idle.delete(path2);
-          if (existsSync26(path2)) {
+          if (existsSync27(path2)) {
             return path2;
           }
           worktreePoolLog.log(`Pruned stale entry: ${path2}`);
@@ -73578,7 +74074,7 @@ var init_worktree_pool = __esm({
        */
       rehydrate(idlePaths) {
         for (const path2 of idlePaths) {
-          if (existsSync26(path2)) {
+          if (existsSync27(path2)) {
             this.idle.add(path2);
           } else {
             worktreePoolLog.log(`Rehydrate skipped (not on disk): ${path2}`);
@@ -73634,7 +74130,7 @@ var init_worktree_pool = __esm({
             throw err;
           }
           const conflictingPath = match[1];
-          if (!existsSync26(conflictingPath)) {
+          if (!existsSync27(conflictingPath)) {
             await execAsync3("git worktree prune", { cwd: worktreePath });
             await execAsync3(checkoutCmd, { cwd: worktreePath });
             return branchName;
@@ -73711,8 +74207,8 @@ var init_token_cap_detector = __esm({
 // ../engine/src/step-session-executor.ts
 import { exec as exec5 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
-import { existsSync as existsSync27 } from "node:fs";
-import { join as join34 } from "node:path";
+import { existsSync as existsSync28 } from "node:fs";
+import { join as join35 } from "node:path";
 function parseStepFileScopes(prompt) {
   const result = /* @__PURE__ */ new Map();
   if (!prompt) return result;
@@ -73959,7 +74455,7 @@ function buildReducedStepPrompt(taskDetail, stepIndex) {
   return parts.join("\n").replace(/\n{3,}/g, "\n\n");
 }
 function sleep3(ms) {
-  return new Promise((resolve23) => setTimeout(resolve23, ms));
+  return new Promise((resolve24) => setTimeout(resolve24, ms));
 }
 var execAsync4, stepExecLog, MAX_STEP_RETRIES, RETRY_DELAYS_MS, NOOP_TASK_STORE, StepSessionExecutor;
 var init_step_session_executor = __esm({
@@ -74086,7 +74582,7 @@ var init_step_session_executor = __esm({
         }
         for (const [stepIdx, worktreePath] of this.parallelWorktrees) {
           try {
-            if (existsSync27(worktreePath)) {
+            if (existsSync28(worktreePath)) {
               await execAsync4(`git worktree remove "${worktreePath}" --force`, {
                 cwd: this.options.rootDir
               });
@@ -74442,7 +74938,7 @@ Follow instructions precisely and avoid unrelated changes.`,
         for (const [stepIdx, worktreePath] of worktreePaths) {
           if (worktreePath !== this.options.worktreePath) {
             try {
-              if (existsSync27(worktreePath)) {
+              if (existsSync28(worktreePath)) {
                 await execAsync4(`git worktree remove "${worktreePath}" --force`, {
                   cwd: this.options.rootDir
                 });
@@ -74472,7 +74968,7 @@ Follow instructions precisely and avoid unrelated changes.`,
       async createStepWorktree(stepIndex) {
         const { rootDir } = this.options;
         const name = generateWorktreeName(rootDir);
-        const worktreePath = join34(rootDir, ".worktrees", name);
+        const worktreePath = join35(rootDir, ".worktrees", name);
         const branchName = `fusion/step-${stepIndex}-${name}`;
         stepExecLog.log(`Creating worktree for step ${stepIndex}: ${worktreePath} (branch: ${branchName})`);
         try {
@@ -74546,8 +75042,8 @@ Follow instructions precisely and avoid unrelated changes.`,
 });
 
 // ../engine/src/spec-staleness.ts
-import { stat as stat5 } from "node:fs/promises";
-import { join as join35 } from "node:path";
+import { stat as stat6 } from "node:fs/promises";
+import { join as join36 } from "node:path";
 async function evaluateSpecStaleness(options) {
   const { settings, promptPath, nowMs } = options;
   if (settings.specStalenessEnabled !== true) {
@@ -74564,7 +75060,7 @@ async function evaluateSpecStaleness(options) {
   const now = nowMs ?? Date.now();
   let mtimeMs;
   try {
-    const fileStat = await stat5(promptPath);
+    const fileStat = await stat6(promptPath);
     mtimeMs = fileStat.mtimeMs;
   } catch {
     return {
@@ -74587,7 +75083,7 @@ async function evaluateSpecStaleness(options) {
   };
 }
 function getPromptPath(tasksDir, taskId) {
-  return join35(tasksDir, taskId, "PROMPT.md");
+  return join36(tasksDir, taskId, "PROMPT.md");
 }
 var DEFAULT_SPEC_STALENESS_MAX_AGE_MS;
 var init_spec_staleness = __esm({
@@ -74618,8 +75114,8 @@ var init_task_completion = __esm({
 
 // ../engine/src/run-verification-tool.ts
 import { spawn as spawn4 } from "node:child_process";
-import { existsSync as existsSync28 } from "node:fs";
-import { isAbsolute as isAbsolute10, join as join36 } from "node:path";
+import { existsSync as existsSync29 } from "node:fs";
+import { isAbsolute as isAbsolute11, join as join37 } from "node:path";
 import { Type as Type4 } from "@mariozechner/pi-ai";
 function createBuffer() {
   return { headChunks: [], headBytes: 0, tailChunks: [], tailBytes: 0, totalBytes: 0 };
@@ -74658,11 +75154,17 @@ async function runVerificationCommand3(opts) {
   const warnings = [];
   const stdoutBuf = createBuffer();
   const stderrBuf = createBuffer();
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     const child = spawn4(command, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env },
+      env: {
+        ...process.env,
+        // Corepack otherwise prompts interactively before fetching a pinned
+        // packageManager version, which hangs the non-TTY child until the
+        // hard timeout. Disable the prompt so it proceeds (or errors fast).
+        COREPACK_ENABLE_DOWNLOAD_PROMPT: "0"
+      },
       shell: true
     });
     let timedOut = false;
@@ -74737,7 +75239,7 @@ async function runVerificationCommand3(opts) {
           `[fn_run_verification] command failed (exit=${exitCode}, signal=${signal ?? "none"}): ${command}`
         );
       }
-      resolve23({
+      resolve24({
         success,
         exitCode,
         durationMs,
@@ -74757,7 +75259,7 @@ async function runVerificationCommand3(opts) {
       clearTimeout(hardTimer);
       const durationMs = Date.now() - startMs;
       warnings.push(`Spawn error: ${err.message}`);
-      resolve23({
+      resolve24({
         success: false,
         exitCode: null,
         durationMs,
@@ -74789,10 +75291,10 @@ function createRunVerificationTool(opts) {
         log18.warn(`[fn_run_verification] ${taskId}: ${msg}`);
       }
       let resolvedCwd;
-      if (params.cwd && isAbsolute10(params.cwd)) {
+      if (params.cwd && isAbsolute11(params.cwd)) {
         resolvedCwd = params.cwd;
       } else if (params.cwd) {
-        resolvedCwd = join36(worktreePath, params.cwd);
+        resolvedCwd = join37(worktreePath, params.cwd);
       } else {
         resolvedCwd = worktreePath;
       }
@@ -74807,8 +75309,8 @@ function createRunVerificationTool(opts) {
       }
       let effectiveCommand = command;
       if (command.trimStart().startsWith("pnpm --filter")) {
-        const modulesYaml = join36(rootDir, "node_modules", ".modules.yaml");
-        if (!existsSync28(modulesYaml)) {
+        const modulesYaml = join37(rootDir, "node_modules", ".modules.yaml");
+        if (!existsSync29(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.`;
           warnings.push(msg);
@@ -74919,9 +75421,9 @@ var init_run_verification_tool = __esm({
 // ../engine/src/executor.ts
 import { exec as exec6 } from "node:child_process";
 import { promisify as promisify7 } from "node:util";
-import { isAbsolute as isAbsolute11, join as join37, relative as relative8, resolve as resolvePath } from "node:path";
-import { existsSync as existsSync29 } from "node:fs";
-import { readFile as readFile16, writeFile as writeFile12 } from "node:fs/promises";
+import { isAbsolute as isAbsolute12, join as join38, relative as relative9, resolve as resolvePath } from "node:path";
+import { existsSync as existsSync30 } from "node:fs";
+import { readFile as readFile17, writeFile as writeFile13 } from "node:fs/promises";
 import { Type as Type5 } from "@mariozechner/pi-ai";
 import { ModelRegistry as ModelRegistry2, SessionManager as SessionManager2 } from "@mariozechner/pi-coding-agent";
 function truncateWorkflowScriptOutput2(output) {
@@ -74983,7 +75485,7 @@ function getExecutorSystemPrompt(settings) {
   ].filter((section) => section.trim());
   return sections.join("\n\n");
 }
-function formatTimestamp2(iso) {
+function formatTimestamp3(iso) {
   const date = new Date(iso);
   const now = /* @__PURE__ */ new Date();
   const diffMs = now.getTime() - date.getTime();
@@ -75078,7 +75580,7 @@ git log --oneline
       ""
     ];
     for (const comment of recentComments) {
-      const timestamp = formatTimestamp2(comment.createdAt);
+      const timestamp = formatTimestamp3(comment.createdAt);
       lines.push(`**${comment.author}** \u2014 ${timestamp}`);
       lines.push(`> ${comment.text}`);
       lines.push("");
@@ -75142,7 +75644,7 @@ If lint is configured and failing, fix that too before completion.
 **CRITICAL: Resolve ALL test failures (and any lint/typecheck failures) before completing the task, even if they appear unrelated or pre-existing.** Unrelated failures left unfixed accumulate technical debt and block future integrations. Investigate and fix or suppress them \u2014 do not defer them to a separate task.`;
 }
 function formatCommentForInjection(comment) {
-  const timestamp = formatTimestamp2(comment.createdAt);
+  const timestamp = formatTimestamp3(comment.createdAt);
   return `\u{1F4E3} **New feedback** \u2014 ${timestamp} (${comment.author}):
 
 ${comment.text}
@@ -76545,7 +77047,7 @@ The tool prevents your session from being killed by the inactivity watchdog duri
             );
             return false;
           }
-          if (task.worktree && existsSync29(task.worktree)) {
+          if (task.worktree && existsSync30(task.worktree)) {
             const modifiedFiles = await this.captureModifiedFiles(task.worktree, task.baseCommitSha);
             if (modifiedFiles.length > 0) {
               await this.store.updateTask(task.id, { modifiedFiles });
@@ -76802,7 +77304,7 @@ The tool prevents your session from being killed by the inactivity watchdog duri
         const activeMergeStatuses = /* @__PURE__ */ new Set(["merging", "merging-pr", "merging-fix"]);
         const isActiveTask = activeColumns.has(task.column) || activeMergeStatuses.has(task.status ?? "");
         if (!isActiveTask) {
-          const tasksDir = join37(this.store.getFusionDir(), "tasks");
+          const tasksDir = join38(this.store.getFusionDir(), "tasks");
           const promptPath = getPromptPath(tasksDir, task.id);
           const staleness = await evaluateSpecStaleness({ settings, promptPath });
           if (staleness.isStale) {
@@ -76849,7 +77351,7 @@ The tool prevents your session from being killed by the inactivity watchdog duri
               worktreeName = generateWorktreeName(this.rootDir);
               break;
           }
-          worktreePath = join37(this.rootDir, ".worktrees", worktreeName);
+          worktreePath = join38(this.rootDir, ".worktrees", worktreeName);
         }
         let stuckRequeue = null;
         let taskDone = false;
@@ -76876,7 +77378,7 @@ The tool prevents your session from being killed by the inactivity watchdog duri
             );
           }
           const branchName = task.branch || `fusion/${task.id.toLowerCase()}`;
-          let isResume = existsSync29(worktreePath);
+          let isResume = existsSync30(worktreePath);
           let acquiredFromPool = false;
           const baseBranch = task.executionStartBranch || null;
           if (task.worktree && isResume && !await isUsableTaskWorktree(this.rootDir, worktreePath)) {
@@ -76889,8 +77391,8 @@ The tool prevents your session from being killed by the inactivity watchdog duri
               this.currentRunContext
             );
             await this.store.updateTask(task.id, { worktree: null, branch: null });
-            worktreePath = join37(this.rootDir, ".worktrees", generateWorktreeName(this.rootDir));
-            isResume = existsSync29(worktreePath);
+            worktreePath = join38(this.rootDir, ".worktrees", generateWorktreeName(this.rootDir));
+            isResume = existsSync30(worktreePath);
           }
           if (!isResume) {
             if (this.options.pool && settings.recycleWorktrees) {
@@ -77289,7 +77791,7 @@ ${summary}`,
                     executorLog.warn(`\u26A1 ${task.id} transient error \u2014 retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay3}: ${errorMessage}`);
                     await this.store.logEntry(task.id, `Transient error (retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay3}): ${errorMessage}`, void 0, this.currentRunContext);
                   }
-                  if (worktreePath && existsSync29(worktreePath)) {
+                  if (worktreePath && existsSync30(worktreePath)) {
                     try {
                       await execAsync5(`git worktree remove "${worktreePath}" --force`, { cwd: this.rootDir });
                       await audit.git({ type: "worktree:remove", target: worktreePath });
@@ -77357,7 +77859,7 @@ ${summary}`,
                     if (!preserveProgress) {
                       await this.resetStepsIfWorkLost(latestTask);
                     }
-                    if (worktreePath && existsSync29(worktreePath)) {
+                    if (worktreePath && existsSync30(worktreePath)) {
                       try {
                         await execAsync5(`git worktree remove "${worktreePath}" --force`, { cwd: this.rootDir });
                       } catch (wtErr) {
@@ -77478,7 +77980,7 @@ ${summary}`,
             const executorFallbackProvider = settings.fallbackProvider;
             const executorFallbackModelId = settings.fallbackModelId;
             const executorThinkingLevel = detail.thinkingLevel ?? settings.defaultThinkingLevel;
-            const isResuming = !!task.sessionFile && existsSync29(task.sessionFile);
+            const isResuming = !!task.sessionFile && existsSync30(task.sessionFile);
             const sessionManager = isResuming ? SessionManager2.open(task.sessionFile) : SessionManager2.create(worktreePath);
             executorLog.log(`${task.id}: creating agent session (provider=${executorProvider ?? "default"}, model=${executorModelId ?? "default"}, resuming=${isResuming})`);
             const executorInstructions = await this.resolveInstructionsForRole("executor");
@@ -77993,7 +78495,7 @@ ${executorPluginContributions}` : executorSystemPrompt;
               this.options.onComplete?.(task);
             } else {
               executorLog.log(`${task.id} paused \u2014 moving to todo`);
-              if (worktreePath && existsSync29(worktreePath)) {
+              if (worktreePath && existsSync30(worktreePath)) {
                 try {
                   await execAsync5(`git worktree remove "${worktreePath}" --force`, { cwd: this.rootDir });
                   executorLog.log(`Removed old worktree for paused task: ${worktreePath}`);
@@ -78089,7 +78591,7 @@ ${executorPluginContributions}` : executorSystemPrompt;
                   executorLog.warn(`\u26A1 ${task.id} transient error \u2014 retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay3}: ${errorMessage}`);
                   await this.store.logEntry(task.id, `Transient error (retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay3}): ${errorMessage}`, void 0, this.currentRunContext);
                 }
-                if (worktreePath && existsSync29(worktreePath)) {
+                if (worktreePath && existsSync30(worktreePath)) {
                   try {
                     await execAsync5(`git worktree remove "${worktreePath}" --force`, { cwd: this.rootDir });
                     executorLog.log(`Removed old worktree for transient retry: ${worktreePath}`);
@@ -78161,7 +78663,7 @@ ${executorPluginContributions}` : executorSystemPrompt;
                 if (!preserveProgress) {
                   await this.resetStepsIfWorkLost(latestTask);
                 }
-                if (worktreePath && existsSync29(worktreePath)) {
+                if (worktreePath && existsSync30(worktreePath)) {
                   try {
                     await execAsync5(`git worktree remove "${worktreePath}" --force`, { cwd: this.rootDir });
                     executorLog.log(`Removed old worktree for stuck-killed retry: ${worktreePath}`);
@@ -78731,10 +79233,10 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
        * The section is replaced entirely to avoid accumulation of old feedback.
        */
       async injectWorkflowRevisionInstructions(task, feedback) {
-        const promptPath = join37(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
+        const promptPath = join38(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
         let content;
         try {
-          content = await readFile16(promptPath, "utf-8");
+          content = await readFile17(promptPath, "utf-8");
         } catch {
           executorLog.warn(`${task.id}: PROMPT.md not found at ${promptPath}, skipping revision injection`);
           return;
@@ -78771,7 +79273,7 @@ ${feedback}
           }
         }
         try {
-          await writeFile12(promptPath, newContent);
+          await writeFile13(promptPath, newContent);
           executorLog.log(`${task.id}: injected workflow revision instructions into PROMPT.md`);
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
@@ -79067,10 +79569,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, retryCount) {
-        const promptPath = join37(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
+        const promptPath = join38(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
         let content;
         try {
-          content = await readFile16(promptPath, "utf-8");
+          content = await readFile17(promptPath, "utf-8");
         } catch {
           executorLog.warn(`${task.id}: PROMPT.md not found at ${promptPath}, skipping workflow failure injection`);
           return;
@@ -79120,7 +79622,7 @@ ${failureFeedback}
           }
         }
         try {
-          await writeFile12(promptPath, newContent);
+          await writeFile13(promptPath, newContent);
           executorLog.log(`${task.id}: injected workflow step failure instructions into PROMPT.md (retry ${retryCount}/${MAX_WORKFLOW_STEP_RETRIES})`);
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
@@ -79677,7 +80179,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
               );
             }
             const delay3 = this.WORKTREE_RETRY_DELAYS[attempt] || 1e3;
-            await new Promise((resolve23) => setTimeout(resolve23, delay3));
+            await new Promise((resolve24) => setTimeout(resolve24, delay3));
           }
         }
         throw new Error("Unexpected exit from worktree creation retry loop");
@@ -79899,7 +80401,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
        * rather than fail the task permanently.
        */
       async resolveWorktreeStartPoint(startPoint, taskId) {
-        const command = isAbsolute11(startPoint) && existsSync29(startPoint) ? `git -C "${startPoint}" rev-parse --verify HEAD^{commit}` : `git rev-parse --verify "${startPoint}^{commit}"`;
+        const command = isAbsolute12(startPoint) && existsSync30(startPoint) ? `git -C "${startPoint}" rev-parse --verify HEAD^{commit}` : `git rev-parse --verify "${startPoint}^{commit}"`;
         try {
           const { stdout } = await execAsync5(command, { cwd: this.rootDir });
           return stdout.trim() || startPoint;
@@ -79919,7 +80421,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
        */
       async tryCreateWorktree(branch, path2, taskId, startPoint, attemptNumber = 0, recoveryDepth = 0) {
         await this.assertWorktreePathNotNested(path2, taskId);
-        if (existsSync29(path2)) {
+        if (existsSync30(path2)) {
           const isRegistered = await this.isRegisteredWorktree(path2);
           if (!isRegistered) {
             await this.store.logEntry(
@@ -80070,7 +80572,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
         );
         if (shouldGenerateNewName) {
           const conflictStartPoint = branch;
-          const newPath = join37(this.rootDir, ".worktrees", generateWorktreeName(this.rootDir));
+          const newPath = join38(this.rootDir, ".worktrees", generateWorktreeName(this.rootDir));
           for (let suffix = 2; suffix <= 6; suffix++) {
             const suffixedBranch = `${branch}-${suffix}`;
             try {
@@ -80117,8 +80619,8 @@ Review the work done in this worktree and evaluate it against the criteria in yo
         for (const wt of registered) {
           if (wt === rootResolved) continue;
           if (wt === target) continue;
-          const rel = relative8(wt, target);
-          if (rel && !rel.startsWith("..") && !isAbsolute11(rel)) {
+          const rel = relative9(wt, target);
+          if (rel && !rel.startsWith("..") && !isAbsolute12(rel)) {
             await this.store.logEntry(
               taskId,
               `Refusing to create nested worktree`,
@@ -80694,7 +81196,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
                 metadata: { type: "spawned", parentTaskId: taskId }
               });
               const childWorktreeName = generateWorktreeName(this.rootDir);
-              const childWorktreePath = join37(this.rootDir, ".worktrees", childWorktreeName);
+              const childWorktreePath = join38(this.rootDir, ".worktrees", childWorktreeName);
               const childBranch = `fusion/spawn-${agent.id}`;
               await this.createWorktree(childBranch, childWorktreePath, taskId, worktreePath);
               await this.options.agentStore.updateAgentState(agent.id, "active");
@@ -81090,9 +81592,9 @@ var init_node_routing_policy = __esm({
 });
 
 // ../engine/src/scheduler.ts
-import { existsSync as existsSync30 } from "node:fs";
-import { readFile as readFile17 } from "node:fs/promises";
-import { join as join38 } from "node:path";
+import { existsSync as existsSync31 } from "node:fs";
+import { readFile as readFile18 } from "node:fs/promises";
+import { join as join39 } from "node:path";
 function pathsOverlap2(a, b) {
   for (const pa of a) {
     const prefixA = pa.endsWith("/*") ? pa.slice(0, -1) : null;
@@ -81264,16 +81766,16 @@ var init_scheduler = __esm({
        * @returns Object with `valid: true` if checks pass, or `valid: false` with a `reason` string if they fail
        */
       async validateTaskFilesystem(id) {
-        const taskDir = join38(this.store.getTasksDir(), id);
-        if (!existsSync30(taskDir)) {
+        const taskDir = join39(this.store.getTasksDir(), id);
+        if (!existsSync31(taskDir)) {
           return { valid: false, reason: "missing directory" };
         }
-        const promptPath = join38(taskDir, "PROMPT.md");
-        if (!existsSync30(promptPath)) {
+        const promptPath = join39(taskDir, "PROMPT.md");
+        if (!existsSync31(promptPath)) {
           return { valid: false, reason: "missing or empty PROMPT.md" };
         }
         try {
-          const content = await readFile17(promptPath, "utf-8");
+          const content = await readFile18(promptPath, "utf-8");
           if (!content || content.trim().length === 0) {
             return { valid: false, reason: "missing or empty PROMPT.md" };
           }
@@ -83470,8 +83972,8 @@ var agent_reflection_exports = {};
 __export(agent_reflection_exports, {
   AgentReflectionService: () => AgentReflectionService
 });
-import { readFile as readFile18 } from "node:fs/promises";
-import { isAbsolute as isAbsolute12, resolve as resolve18 } from "node:path";
+import { readFile as readFile19 } from "node:fs/promises";
+import { isAbsolute as isAbsolute13, resolve as resolve19 } from "node:path";
 var reflectionLog, REFLECTION_SYSTEM_PROMPT, DEFAULT_OUTCOME_LIMIT, AgentReflectionService;
 var init_agent_reflection = __esm({
   "../engine/src/agent-reflection.ts"() {
@@ -83782,9 +84284,9 @@ Rules:
           pieces.push(agent.instructionsText.trim());
         }
         if (agent.instructionsPath?.trim()) {
-          const resolvedPath = isAbsolute12(agent.instructionsPath) ? agent.instructionsPath : resolve18(this.rootDir, agent.instructionsPath);
+          const resolvedPath = isAbsolute13(agent.instructionsPath) ? agent.instructionsPath : resolve19(this.rootDir, agent.instructionsPath);
           try {
-            const content = await readFile18(resolvedPath, "utf-8");
+            const content = await readFile19(resolvedPath, "utf-8");
             if (content.trim()) {
               pieces.push(content.trim());
             }
@@ -87273,7 +87775,7 @@ var init_evaluator = __esm({
 // ../engine/src/cron-runner.ts
 import { exec as exec7 } from "node:child_process";
 function execCommand(command, options) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     exec7(command, options, (error, stdout, stderr) => {
       const stdoutText = typeof stdout === "string" ? stdout : String(stdout ?? "");
       const stderrText = typeof stderr === "string" ? stderr : String(stderr ?? "");
@@ -87284,7 +87786,7 @@ function execCommand(command, options) {
         reject(errWithOutput);
         return;
       }
-      resolve23({ stdout: stdoutText, stderr: stderrText });
+      resolve24({ stdout: stdoutText, stderr: stderrText });
     });
   });
 }
@@ -87318,6 +87820,36 @@ function isInProcessBackupCommand(command) {
   }
   return true;
 }
+function isInProcessMemoryBackupCommand(command) {
+  if (!command) return false;
+  const trimmed = command.trim();
+  if (!trimmed) return false;
+  if (SHELL_METACHARACTERS_REGEX.test(trimmed)) return false;
+  const tokens = trimmed.split(/\s+/).map((tok) => tok.toLowerCase());
+  let cursor = 0;
+  if (tokens[cursor] === "npx") {
+    cursor += 1;
+    while (cursor < tokens.length) {
+      const tok = tokens[cursor];
+      if (tok === void 0 || !tok.startsWith("-")) break;
+      const takesValue = (tok === "-p" || tok === "--package") && cursor + 1 < tokens.length && tokens[cursor + 1] !== void 0 && !tokens[cursor + 1].startsWith("-");
+      cursor += takesValue ? 2 : 1;
+    }
+  }
+  const binary = tokens[cursor];
+  if (!binary || !FUSION_BINARY_TOKENS.has(binary)) return false;
+  cursor += 1;
+  if (tokens[cursor] !== "memory-backup") return false;
+  cursor += 1;
+  if (tokens[cursor] !== "--create") return false;
+  cursor += 1;
+  for (; cursor < tokens.length; cursor += 1) {
+    const tok = tokens[cursor];
+    if (!tok) continue;
+    if (!tok.startsWith("-")) return false;
+  }
+  return true;
+}
 function isInProcessScheduledEvalCommand(command) {
   if (!command) return false;
   const trimmed = command.trim();
@@ -87525,6 +88057,9 @@ var init_cron_runner = __esm({
         if (isInProcessBackupCommand(schedule.command)) {
           return this.executeBackupInProcess(schedule, startedAt);
         }
+        if (isInProcessMemoryBackupCommand(schedule.command)) {
+          return this.executeMemoryBackupInProcess(schedule, startedAt);
+        }
         if (isInProcessScheduledEvalCommand(schedule.command)) {
           return this.executeScheduledEvalInProcess(schedule, startedAt);
         }
@@ -87578,6 +88113,21 @@ var init_cron_runner = __esm({
           completedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
       }
+      async executeMemoryBackupInProcess(schedule, startedAt) {
+        const action = await this.runMemoryBackupActionInProcess();
+        if (action.success) {
+          log15.log(`\u2713 ${schedule.name} completed in-process`);
+        } else {
+          log15.warn(`\u2717 ${schedule.name} in-process memory backup ${action.error ? `threw: ${action.error}` : `reported failure: ${action.output}`}`);
+        }
+        return {
+          success: action.success,
+          output: action.output,
+          error: action.error,
+          startedAt,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
       /**
        * Shared in-process backup execution used by both the legacy-command path
        * and the command-step path. Returns the success/output/error tuple in
@@ -87635,6 +88185,22 @@ var init_cron_runner = __esm({
           return { success: false, output: "", error: message };
         }
       }
+      async runMemoryBackupActionInProcess() {
+        try {
+          const { runMemoryBackupCommand: runMemoryBackupCommand2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+          const fusionDir = this.store.getFusionDir();
+          const settings = await this.store.getSettings();
+          const result = await runMemoryBackupCommand2(fusionDir, settings);
+          return {
+            success: result.success,
+            output: truncateOutput2(result.output ?? "", ""),
+            error: result.success ? void 0 : result.output
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return { success: false, output: "", error: message };
+        }
+      }
       /**
        * Execute multiple steps sequentially.
        * Aggregates per-step results into an overall AutomationRunResult.
@@ -87736,6 +88302,19 @@ var init_cron_runner = __esm({
             completedAt: (/* @__PURE__ */ new Date()).toISOString()
           };
         }
+        if (isInProcessMemoryBackupCommand(step.command)) {
+          const action = await this.runMemoryBackupActionInProcess();
+          return {
+            stepId: step.id,
+            stepName: step.name,
+            stepIndex,
+            success: action.success,
+            output: action.output,
+            error: action.error,
+            startedAt,
+            completedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
         try {
           const { stdout, stderr } = await execCommand(step.command, {
             timeout: timeoutMs,
@@ -88109,6 +88688,30 @@ var init_routine_runner = __esm({
             };
           }
         }
+        if (isInProcessMemoryBackupCommand(command) && this.options.taskStore) {
+          try {
+            const { runMemoryBackupCommand: runMemoryBackupCommand2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+            const fusionDir = this.options.taskStore.getFusionDir();
+            const settings = await this.options.taskStore.getSettings();
+            const result = await runMemoryBackupCommand2(fusionDir, settings);
+            return {
+              success: result.success,
+              output: truncateOutput3(result.output ?? "", ""),
+              error: result.success ? void 0 : result.output,
+              startedAt,
+              completedAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+              success: false,
+              output: "",
+              error: message,
+              startedAt,
+              completedAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+          }
+        }
         try {
           const { stdout, stderr } = await execAsync6(command, {
             timeout: timeoutMs ?? DEFAULT_TIMEOUT_MS8,
@@ -88835,8 +89438,8 @@ var init_stuck_task_detector = __esm({
 // ../engine/src/self-healing.ts
 import { exec as exec9, execSync as execSync2 } from "node:child_process";
 import { promisify as promisify9 } from "node:util";
-import { existsSync as existsSync31, readdirSync as readdirSync5, rmSync as rmSync3, statSync as statSync5 } from "node:fs";
-import { isAbsolute as isAbsolute13, join as join39, relative as relative9, resolve as resolve19 } from "node:path";
+import { existsSync as existsSync32, readdirSync as readdirSync5, rmSync as rmSync3, statSync as statSync5 } from "node:fs";
+import { isAbsolute as isAbsolute14, join as join40, relative as relative10, resolve as resolve20 } from "node:path";
 function commitOwnedByTask2(taskId, subject, body) {
   return body.includes(`Fusion-Task-Id: ${taskId}`) || subject.includes(taskId);
 }
@@ -88873,7 +89476,7 @@ function isNoTaskDoneFailure(task) {
 function hasStepProgress(task) {
   return task.steps.some((step) => step.status !== "pending");
 }
-var log17, execAsync7, APPROVED_TRIAGE_RECOVERY_GRACE_MS, ORPHANED_EXECUTION_RECOVERY_GRACE_MS, ACTIVE_MERGE_STATUSES, NON_TERMINAL_STEP_STATUSES2, GHOST_REVIEW_PRESERVED_STATUSES, ORPHANED_WITH_WORKTREE_GRACE_MS, MAX_TASK_DONE_RETRIES, MAX_AUTO_MERGE_RETRIES, DEFAULT_STALE_MERGING_STATUS_MIN_AGE_MS, SelfHealingManager;
+var log17, execAsync7, APPROVED_TRIAGE_RECOVERY_GRACE_MS, ORPHANED_EXECUTION_RECOVERY_GRACE_MS, ACTIVE_MERGE_STATUSES, NON_TERMINAL_STEP_STATUSES2, GHOST_REVIEW_PRESERVED_STATUSES, ORPHANED_WITH_WORKTREE_GRACE_MS, MAX_TASK_DONE_RETRIES, MAX_AUTO_MERGE_RETRIES, DEADLOCK_RECOVERY_COOLDOWN_MS, DEFAULT_STALE_MERGING_STATUS_MIN_AGE_MS, SelfHealingManager;
 var init_self_healing = __esm({
   "../engine/src/self-healing.ts"() {
     "use strict";
@@ -88897,6 +89500,7 @@ var init_self_healing = __esm({
     ORPHANED_WITH_WORKTREE_GRACE_MS = 3e5;
     MAX_TASK_DONE_RETRIES = 3;
     MAX_AUTO_MERGE_RETRIES = 3;
+    DEADLOCK_RECOVERY_COOLDOWN_MS = 15 * 6e4;
     DEFAULT_STALE_MERGING_STATUS_MIN_AGE_MS = 5 * 6e4;
     SelfHealingManager = class _SelfHealingManager {
       constructor(store, options) {
@@ -88913,6 +89517,8 @@ var init_self_healing = __esm({
       maintenanceRunning = false;
       // ── Event listener cleanup ──────────────────────────────────────────
       settingsListener = null;
+      // ── Per-task deadlock recovery cooldown ─────────────────────────────
+      deadlockRecoveryCooldown = /* @__PURE__ */ new Map();
       // ── Lifecycle ───────────────────────────────────────────────────────
       start() {
         this.settingsListener = ({ settings, previous }) => {
@@ -88944,6 +89550,8 @@ var init_self_healing = __esm({
           { name: "failed-pre-merge-steps", fn: () => this.recoverReviewTasksWithFailedPreMergeSteps().then(() => void 0) },
           { name: "interrupted-merging", fn: () => this.recoverInterruptedMergingTasks().then(() => void 0) },
           { name: "done-merge-metadata", fn: () => this.recoverDoneTaskMergeMetadata().then(() => void 0) },
+          { name: "recover-already-merged-review", fn: () => this.recoverAlreadyMergedReviewTasks().then(() => void 0) },
+          { name: "recover-stuck-merge-deadlocks", fn: () => this.recoverStuckMergeDeadlocks().then(() => void 0) },
           { name: "misclassified-failures", fn: () => this.recoverMisclassifiedFailures().then(() => void 0) },
           { name: "partial-progress-no-task-done", fn: () => this.recoverPartialProgressNoTaskDoneFailures().then(() => void 0) },
           { name: "orphaned-executions", fn: () => this.recoverOrphanedExecutions().then(() => void 0) },
@@ -89351,7 +89959,7 @@ var init_self_healing = __esm({
         return null;
       }
       async cleanupWorktreeOnly(task) {
-        if (task.worktree && existsSync31(task.worktree)) {
+        if (task.worktree && existsSync32(task.worktree)) {
           try {
             await execAsync7(`git worktree remove ${shellQuote(task.worktree)} --force`, {
               cwd: this.options.rootDir,
@@ -89366,7 +89974,7 @@ var init_self_healing = __esm({
         }
       }
       async cleanupInterruptedMergeArtifacts(task) {
-        if (task.worktree && existsSync31(task.worktree)) {
+        if (task.worktree && existsSync32(task.worktree)) {
           try {
             await execAsync7(`git worktree remove ${shellQuote(task.worktree)} --force`, {
               cwd: this.options.rootDir,
@@ -89432,6 +90040,7 @@ var init_self_healing = __esm({
               { name: "recover-mergeable-review", fn: () => this.recoverMergeableReviewTasks() },
               { name: "recover-merged-review", fn: () => this.recoverMergedReviewTasks() },
               { name: "recover-already-merged-review", fn: () => this.recoverAlreadyMergedReviewTasks() },
+              { name: "recover-stuck-merge-deadlocks", fn: () => this.recoverStuckMergeDeadlocks() },
               { name: "recover-misclassified-failures", fn: () => this.recoverMisclassifiedFailures() },
               { name: "recover-no-progress-no-task-done", fn: () => this.recoverNoProgressNoTaskDoneFailures() },
               { name: "recover-partial-progress-no-task-done", fn: () => this.recoverPartialProgressNoTaskDoneFailures() },
@@ -90119,6 +90728,99 @@ var init_self_healing = __esm({
           return 0;
         }
       }
+      /**
+       * Recover deadlocked retry-exhausted merge failures that are still blocking
+       * dispatch via `blockedBy` or retained worktree ownership.
+       */
+      async recoverStuckMergeDeadlocks() {
+        try {
+          const settings = await this.store.getSettings();
+          if (settings.globalPause || settings.enginePaused) return 0;
+          const now = Date.now();
+          const inReview = await this.store.listTasks({ column: "in-review", slim: true });
+          const triage = await this.store.listTasks({ column: "triage", slim: true });
+          const todo = await this.store.listTasks({ column: "todo", slim: true });
+          const inProgress = await this.store.listTasks({ column: "in-progress", slim: true });
+          const dependentsByBlocker = /* @__PURE__ */ new Map();
+          for (const task of [...triage, ...todo, ...inProgress]) {
+            if (!task.blockedBy) continue;
+            const dependents = dependentsByBlocker.get(task.blockedBy) ?? [];
+            dependents.push(task);
+            dependentsByBlocker.set(task.blockedBy, dependents);
+          }
+          const candidates = inReview.filter((task) => {
+            const cooldownStart = this.deadlockRecoveryCooldown.get(task.id) ?? 0;
+            const cooldownElapsed = now - cooldownStart;
+            const hasBlockedDependents = (dependentsByBlocker.get(task.id) ?? []).some(
+              (dep) => dep.column === "triage" || dep.column === "todo"
+            );
+            return task.column === "in-review" && !task.paused && task.status === "failed" && (task.mergeRetries ?? 0) >= MAX_AUTO_MERGE_RETRIES && task.mergeDetails?.mergeConfirmed !== true && (hasBlockedDependents || Boolean(task.worktree)) && cooldownElapsed >= DEADLOCK_RECOVERY_COOLDOWN_MS;
+          });
+          if (candidates.length === 0) return 0;
+          let recovered = 0;
+          for (const task of candidates) {
+            const blockedDependents = dependentsByBlocker.get(task.id) ?? [];
+            const blockedTaskIds = blockedDependents.map((dep) => dep.id);
+            try {
+              const landedCommit = await this.findLandedTaskCommit(task);
+              if (landedCommit) {
+                const mergeDetails = {
+                  commitSha: landedCommit.sha,
+                  filesChanged: landedCommit.filesChanged,
+                  insertions: landedCommit.insertions,
+                  deletions: landedCommit.deletions,
+                  mergeCommitMessage: landedCommit.subject,
+                  mergedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  mergeConfirmed: true,
+                  prNumber: task.prInfo?.number
+                };
+                await this.store.updateTask(task.id, {
+                  status: null,
+                  error: null,
+                  mergeRetries: 0,
+                  worktree: null,
+                  branch: null,
+                  mergeDetails
+                });
+                await this.store.moveTask(task.id, "done");
+                await this.cleanupInterruptedMergeArtifacts(task);
+                const clearedDependents = [];
+                for (const dep of blockedDependents) {
+                  try {
+                    await this.store.updateTask(dep.id, { blockedBy: null });
+                    await this.store.logEntry(dep.id, `Auto-recovered: cleared stale blockedBy ${task.id} after deadlock recovery`);
+                    clearedDependents.push(dep.id);
+                  } catch (depErr) {
+                    const depErrMessage = depErr instanceof Error ? depErr.message : String(depErr);
+                    log17.warn(`self-heal:deadlock-recovery-dependent-error ${JSON.stringify({ blockerTaskId: task.id, dependentTaskId: dep.id, error: depErrMessage })}`);
+                  }
+                }
+                await this.store.logEntry(
+                  task.id,
+                  `Auto-recovered: merge deadlock resolved via landed commit ${landedCommit.sha.slice(0, 8)}${clearedDependents.length > 0 ? `; cleared blockedBy on ${clearedDependents.join(", ")}` : ""}`
+                );
+                log17.log(`self-heal:deadlock-recovered ${JSON.stringify({ stuckTaskId: task.id, blockedTaskIds, attributedSha: landedCommit.sha, action: "reattributed" })}`);
+                recovered++;
+              } else {
+                await this.store.updateTask(task.id, { paused: true });
+                await this.store.logEntry(task.id, "merge-deadlock-detected: requires manual intervention \u2014 verified content not on main");
+                log17.warn(`self-heal:deadlock-recovered ${JSON.stringify({ stuckTaskId: task.id, blockedTaskIds, attributedSha: null, action: "paused-for-manual" })}`);
+                recovered++;
+              }
+            } catch (err) {
+              const errorMessage = err instanceof Error ? err.message : String(err);
+              log17.warn(`self-heal:deadlock-recovery-error ${JSON.stringify({ stuckTaskId: task.id, blockedTaskIds, error: errorMessage })}`);
+            } finally {
+              this.deadlockRecoveryCooldown.set(task.id, Date.now());
+            }
+          }
+          return recovered;
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          log17.error(`Stuck merge deadlock recovery failed: ${errorMessage}`);
+          return 0;
+        }
+      }
       /**
        * Recover retry-exhausted failed review tasks whose content already landed on
        * the integration branch via a non-canonical merge lineage.
@@ -90257,7 +90959,7 @@ var init_self_healing = __esm({
               return false;
             }
             const staleness = now - new Date(t.updatedAt).getTime();
-            const hasWorktree = t.worktree && existsSync31(t.worktree);
+            const hasWorktree = t.worktree && existsSync32(t.worktree);
             const graceMs = hasWorktree ? ORPHANED_WITH_WORKTREE_GRACE_MS : ORPHANED_EXECUTION_RECOVERY_GRACE_MS;
             return staleness >= graceMs;
           });
@@ -90266,7 +90968,7 @@ var init_self_healing = __esm({
           let recovered = 0;
           for (const task of orphaned) {
             try {
-              const hadWorktree = task.worktree && existsSync31(task.worktree);
+              const hadWorktree = task.worktree && existsSync32(task.worktree);
               const reason = hadWorktree ? "worktree exists but no active session" : "missing worktree/session";
               if (this.options.leaseManager && task.checkedOutBy) {
                 const leaseRecovered = await this.options.leaseManager.recoverAbandonedLease(
@@ -90569,7 +91271,7 @@ var init_self_healing = __esm({
         }
       }
       async hasRecoverableGitWork(task) {
-        if (task.worktree && existsSync31(task.worktree)) {
+        if (task.worktree && existsSync32(task.worktree)) {
           try {
             const { stdout: status } = await execAsync7("git status --porcelain", {
               cwd: task.worktree,
@@ -90754,22 +91456,22 @@ var init_self_healing = __esm({
        * tracks registered idle worktrees, never these orphans.
        */
       async reapUnregisteredOrphans() {
-        const worktreesDir = join39(this.options.rootDir, ".worktrees");
-        if (!existsSync31(worktreesDir)) return 0;
+        const worktreesDir = join40(this.options.rootDir, ".worktrees");
+        if (!existsSync32(worktreesDir)) return 0;
         let dirs;
         try {
-          dirs = readdirSync5(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join39(worktreesDir, e.name));
+          dirs = readdirSync5(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join40(worktreesDir, e.name));
         } catch (err) {
           log17.warn(`Failed to read .worktrees/ for unregistered orphan reap: ${err instanceof Error ? err.message : String(err)}`);
           return 0;
         }
         if (dirs.length === 0) return 0;
         const registered = await getRegisteredWorktreePaths(this.options.rootDir);
-        const unregistered = dirs.filter((d) => !registered.has(resolve19(d)));
+        const unregistered = dirs.filter((d) => !registered.has(resolve20(d)));
         let cleaned = 0;
         for (const path2 of unregistered) {
-          const rel = relative9(worktreesDir, path2);
-          if (rel === "" || rel.startsWith("..") || isAbsolute13(rel)) {
+          const rel = relative10(worktreesDir, path2);
+          if (rel === "" || rel.startsWith("..") || isAbsolute14(rel)) {
             log17.warn(`Refusing to remove path outside .worktrees: ${path2}`);
             continue;
           }
@@ -90863,8 +91565,8 @@ var init_self_healing = __esm({
       }
       /** Remove oldest idle worktrees if total count exceeds 2× maxWorktrees. */
       async enforceWorktreeCap() {
-        const worktreesDir = join39(this.options.rootDir, ".worktrees");
-        if (!existsSync31(worktreesDir)) return;
+        const worktreesDir = join40(this.options.rootDir, ".worktrees");
+        if (!existsSync32(worktreesDir)) return;
         try {
           const settings = await this.store.getSettings();
           const cap = (settings.maxWorktrees ?? 4) * 2;
@@ -91645,13 +92347,13 @@ var init_plugin_runner = __esm({
        * Returns the result on success, throws on timeout.
        */
       withTimeout(promise, ms, timeoutMessage) {
-        return new Promise((resolve23, reject) => {
+        return new Promise((resolve24, reject) => {
           const timer = setTimeout(() => {
             reject(new Error(timeoutMessage));
           }, ms);
           promise.then((result) => {
             clearTimeout(timer);
-            resolve23(result);
+            resolve24(result);
           }).catch((err) => {
             clearTimeout(timer);
             reject(err);
@@ -92558,7 +93260,7 @@ var init_in_process_runtime = __esm({
             runtimeLog.log(
               `Waiting for ${metrics.inFlightTasks} in-flight tasks to complete...`
             );
-            await new Promise((resolve23) => setTimeout(resolve23, 1e3));
+            await new Promise((resolve24) => setTimeout(resolve24, 1e3));
           }
           const finalMetrics = this.getMetrics();
           if (finalMetrics.inFlightTasks > 0) {
@@ -92988,13 +93690,13 @@ var init_ipc_host = __esm({
         }
         const id = generateCorrelationId();
         const message = { type, id, payload };
-        return new Promise((resolve23, reject) => {
+        return new Promise((resolve24, reject) => {
           const timeout = setTimeout(() => {
             this.pendingCommands.delete(id);
             reject(new Error(`Command ${type} timed out after ${timeoutMs ?? this.commandTimeoutMs}ms`));
           }, timeoutMs ?? this.commandTimeoutMs);
           this.pendingCommands.set(id, {
-            resolve: resolve23,
+            resolve: resolve24,
             reject,
             timeout,
             type
@@ -93072,7 +93774,7 @@ var init_ipc_host = __esm({
 import { EventEmitter as EventEmitter20 } from "node:events";
 import { fork } from "node:child_process";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { dirname as dirname11, join as join40 } from "node:path";
+import { dirname as dirname12, join as join41 } from "node:path";
 var HealthMonitor, ChildProcessRuntime;
 var init_child_process_runtime = __esm({
   "../engine/src/runtimes/child-process-runtime.ts"() {
@@ -93232,9 +93934,9 @@ var init_child_process_runtime = __esm({
        */
       getWorkerPath() {
         const isCompiled = !import.meta.url.endsWith(".ts");
-        const currentDir = dirname11(fileURLToPath3(import.meta.url));
+        const currentDir = dirname12(fileURLToPath3(import.meta.url));
         const workerFile = isCompiled ? "child-process-worker.js" : "child-process-worker.ts";
-        return join40(currentDir, workerFile);
+        return join41(currentDir, workerFile);
       }
       /**
        * Set up event forwarding from IPC host to runtime listeners.
@@ -93803,8 +94505,8 @@ var init_remote_node_client = __esm({
         return error instanceof TypeError;
       }
       async sleep(ms) {
-        await new Promise((resolve23) => {
-          setTimeout(resolve23, ms);
+        await new Promise((resolve24) => {
+          setTimeout(resolve24, ms);
         });
       }
     };
@@ -94068,14 +94770,14 @@ var init_remote_node_runtime = __esm({
         return error instanceof Error ? error : new Error(String(error));
       }
       async sleep(ms, signal) {
-        await new Promise((resolve23) => {
+        await new Promise((resolve24) => {
           const timeout = setTimeout(() => {
             cleanup();
-            resolve23();
+            resolve24();
           }, ms);
           const onAbort = () => {
             cleanup();
-            resolve23();
+            resolve24();
           };
           const cleanup = () => {
             clearTimeout(timeout);
@@ -95026,10 +95728,10 @@ var init_tunnel_process_manager = __esm({
           lastError: null
         });
         this.emitLog("info", "manager", `Stopping ${currentHandle.provider} tunnel (pid=${currentHandle.child.pid ?? "n/a"})`);
-        this.activeStopPromise = new Promise((resolve23) => {
+        this.activeStopPromise = new Promise((resolve24) => {
           const onClose = () => {
             currentHandle.child.removeListener("close", onClose);
-            resolve23();
+            resolve24();
           };
           currentHandle.child.once("close", onClose);
           killManagedProcess(currentHandle.child, "SIGTERM");
@@ -95302,17 +96004,25 @@ var init_project_engine = __esm({
           onClosedPrFeedback: (taskId, prInfo, comments) => this.prCommentHandler.createFollowUpTask(taskId, prInfo, comments)
         });
         if (!this.options.skipNotifier) {
+          const agentStore = this.runtime.getAgentStore();
+          const agentNameResolver = agentStore ? async (agentId) => {
+            const agent = await agentStore.getAgent(agentId);
+            const name = typeof agent?.name === "string" ? agent.name.trim() : "";
+            return name.length > 0 ? name : null;
+          } : void 0;
           this.notificationService = new NotificationService(store, {
             projectId: this.options.projectId,
             ntfyBaseUrl: this.options.ntfyBaseUrl,
-            messageStore: this.runtime.getMessageStore()
+            messageStore: this.runtime.getMessageStore(),
+            agentNameResolver
           });
           await this.notificationService.start();
           this.notifier = new NtfyNotifier(
             store,
             {
               projectId: this.options.projectId,
-              ntfyBaseUrl: this.options.ntfyBaseUrl
+              ntfyBaseUrl: this.options.ntfyBaseUrl,
+              agentNameResolver
             },
             this.notificationService
           );
@@ -95670,12 +96380,12 @@ ${detail}`
        */
       async onMerge(taskId) {
         if (this.mergeActive.has(taskId)) {
-          return new Promise((resolve23, reject) => {
-            this.manualMergeResolvers.set(taskId, { resolve: resolve23, reject });
+          return new Promise((resolve24, reject) => {
+            this.manualMergeResolvers.set(taskId, { resolve: resolve24, reject });
           });
         }
-        return new Promise((resolve23, reject) => {
-          this.manualMergeResolvers.set(taskId, { resolve: resolve23, reject });
+        return new Promise((resolve24, reject) => {
+          this.manualMergeResolvers.set(taskId, { resolve: resolve24, reject });
           this.internalEnqueueMerge(taskId);
         });
       }
@@ -95942,7 +96652,15 @@ ${detail}`
       }
       internalEnqueueMerge(taskId) {
         if (this.shuttingDown) return;
-        if (this.mergeActive.has(taskId)) return;
+        if (this.mergeActive.has(taskId)) {
+          const isActuallyLive = this.mergeQueue.includes(taskId) || this.activeMergeTaskId === taskId;
+          if (!isActuallyLive) {
+            runtimeLog.warn(
+              `internalEnqueueMerge(${taskId}): skipped \u2014 mergeActive entry is leaked (not queued, not active). reconcileStaleMergeActive() will clear it on the next sweep.`
+            );
+          }
+          return;
+        }
         this.mergeActive.add(taskId);
         this.mergeQueue.push(taskId);
         void this.drainMergeQueue().catch((err) => {
@@ -96421,17 +97139,40 @@ ${detail}`
           setTimeout(async () => {
             try {
               const latestTask = await store.getTask(task.id).catch(() => null);
-              if (!latestTask) return;
-              if (latestTask.column !== "in-review") return;
-              if (latestTask.paused) return;
-              if (this.options.getTaskMergeBlocker?.(latestTask)) return;
+              if (!latestTask) {
+                runtimeLog.warn(`Auto-merge handoff (${task.id}): task disappeared during grace period`);
+                return;
+              }
+              if (latestTask.column !== "in-review") {
+                runtimeLog.log(`Auto-merge handoff (${task.id}) skipped: column changed to ${latestTask.column}`);
+                return;
+              }
+              if (latestTask.paused) {
+                runtimeLog.log(`Auto-merge handoff (${task.id}) skipped: task paused`);
+                return;
+              }
+              const blockerReason = this.options.getTaskMergeBlocker?.(latestTask);
+              if (blockerReason) {
+                runtimeLog.log(`Auto-merge handoff (${task.id}) skipped: ${blockerReason}`);
+                return;
+              }
               const settings = await store.getSettings();
-              if (settings.globalPause || settings.enginePaused) return;
-              if (!settings.autoMerge) return;
+              if (settings.globalPause || settings.enginePaused) {
+                runtimeLog.log(`Auto-merge handoff (${task.id}) skipped: ${settings.globalPause ? "globalPause" : "enginePaused"} active`);
+                return;
+              }
+              if (!settings.autoMerge) {
+                runtimeLog.log(`Auto-merge handoff (${task.id}) skipped: autoMerge disabled`);
+                return;
+              }
+              if (this.mergeActive.has(task.id) && !this.mergeQueue.includes(task.id) && this.activeMergeTaskId !== task.id) {
+                runtimeLog.warn(`Auto-merge handoff (${task.id}): clearing stale mergeActive before enqueue`);
+                this.mergeActive.delete(task.id);
+              }
               this.internalEnqueueMerge(task.id);
             } catch (err) {
               runtimeLog.warn(
-                `Auto-merge: failed to read settings for task:moved on ${task.id}: ${err instanceof Error ? err.message : String(err)}`
+                `Auto-merge handoff (${task.id}) failed: ${err instanceof Error ? err.message : String(err)}`
               );
             }
           }, MERGE_HANDOFF_GRACE_MS);
@@ -99674,7 +100415,7 @@ function buildHermesArgs(prompt, settings, resumeSessionId) {
 async function invokeHermesCli(prompt, settings, resumeSessionId, signal) {
   const args = buildHermesArgs(prompt, settings, resumeSessionId);
   const binary = resolveBinaryForSpawn(settings.binaryPath);
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     let settled = false;
     const spawnEnv = { ...process.env, PYTHONUNBUFFERED: "1" };
     if (settings.profile) {
@@ -99742,7 +100483,7 @@ ${combined}`));
         return;
       }
       try {
-        resolve23(parseHermesOutput(stdout, stderr));
+        resolve24(parseHermesOutput(stdout, stderr));
       } catch (parseErr) {
         reject(parseErr);
       }
@@ -99772,37 +100513,37 @@ var init_cli_spawn = __esm({
 });
 
 // ../../plugins/fusion-plugin-hermes-runtime/dist/fusion-skill-install.js
-import { cpSync, existsSync as existsSync32, lstatSync as lstatSync2, mkdirSync as mkdirSync6, readFileSync as readFileSync12, readlinkSync, rmSync as rmSync4, symlinkSync, unlinkSync as unlinkSync2 } from "node:fs";
+import { cpSync, existsSync as existsSync33, lstatSync as lstatSync2, mkdirSync as mkdirSync6, readFileSync as readFileSync12, readlinkSync, rmSync as rmSync4, symlinkSync, unlinkSync as unlinkSync2 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { basename as basename8, dirname as dirname12, join as join41, resolve as resolve20 } from "node:path";
+import { basename as basename8, dirname as dirname13, join as join42, resolve as resolve21 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function resolveHermesHome(profile) {
-  const base = process.env.HERMES_HOME ?? join41(homedir7(), ".hermes");
+  const base = process.env.HERMES_HOME ?? join42(homedir7(), ".hermes");
   if (!profile || profile === "default")
     return base;
-  return join41(base, "profiles", profile);
+  return join42(base, "profiles", profile);
 }
 function getFusionSkillSourceCandidates(moduleUrl = import.meta.url) {
   const here = fileURLToPath4(moduleUrl);
-  const moduleDir = dirname12(here);
+  const moduleDir = dirname13(here);
   return [
-    resolve20(moduleDir, "..", "..", "..", "..", "packages", "cli", "skill", FUSION_SKILL_NAME),
-    resolve20(moduleDir, "..", "..", "..", "skill", FUSION_SKILL_NAME),
-    resolve20(moduleDir, "..", "..", "skill", FUSION_SKILL_NAME),
-    resolve20(moduleDir, "..", "..", "..", "..", "skill", FUSION_SKILL_NAME)
+    resolve21(moduleDir, "..", "..", "..", "..", "packages", "cli", "skill", FUSION_SKILL_NAME),
+    resolve21(moduleDir, "..", "..", "..", "skill", FUSION_SKILL_NAME),
+    resolve21(moduleDir, "..", "..", "skill", FUSION_SKILL_NAME),
+    resolve21(moduleDir, "..", "..", "..", "..", "skill", FUSION_SKILL_NAME)
   ];
 }
 function resolveBundledFusionSkillSource() {
   const candidates = getFusionSkillSourceCandidates();
   for (const candidate of candidates) {
-    if (existsSync32(join41(candidate, "SKILL.md")))
+    if (existsSync33(join42(candidate, "SKILL.md")))
       return candidate;
   }
   return null;
 }
 function installFusionSkillIntoHermesHome(options = {}) {
   const sourceDir = options.sourceDir ?? resolveBundledFusionSkillSource();
-  const targetDir = join41(resolveHermesHome(options.profile), "skills", FUSION_SKILL_NAME);
+  const targetDir = join42(resolveHermesHome(options.profile), "skills", FUSION_SKILL_NAME);
   if (!sourceDir) {
     return {
       outcome: "warning",
@@ -99812,16 +100553,16 @@ function installFusionSkillIntoHermesHome(options = {}) {
     };
   }
   try {
-    mkdirSync6(dirname12(targetDir), { recursive: true });
+    mkdirSync6(dirname13(targetDir), { recursive: true });
     let replaced = false;
-    if (existsSync32(targetDir) || isBrokenSymlink(targetDir)) {
-      const stat8 = lstatSync2(targetDir);
-      if (stat8.isSymbolicLink()) {
+    if (existsSync33(targetDir) || isBrokenSymlink(targetDir)) {
+      const stat9 = lstatSync2(targetDir);
+      if (stat9.isSymbolicLink()) {
         const currentTarget = safeReadlink(targetDir);
-        if (currentTarget && resolve20(dirname12(targetDir), currentTarget) === resolve20(sourceDir)) {
+        if (currentTarget && resolve21(dirname13(targetDir), currentTarget) === resolve21(sourceDir)) {
           return { outcome: "already-installed", sourceDir, targetDir };
         }
-        if (!looksLikeFusionSkillTarget(resolve20(dirname12(targetDir), currentTarget ?? ""))) {
+        if (!looksLikeFusionSkillTarget(resolve21(dirname13(targetDir), currentTarget ?? ""))) {
           return {
             outcome: "skipped",
             sourceDir,
@@ -99884,15 +100625,15 @@ function safeReadlink(path2) {
 }
 function isBrokenSymlink(path2) {
   try {
-    const stat8 = lstatSync2(path2);
-    return stat8.isSymbolicLink() && !existsSync32(path2);
+    const stat9 = lstatSync2(path2);
+    return stat9.isSymbolicLink() && !existsSync33(path2);
   } catch {
     return false;
   }
 }
 function looksLikePriorFusionInstall(path2) {
-  const skillMd = join41(path2, "SKILL.md");
-  if (!existsSync32(skillMd))
+  const skillMd = join42(path2, "SKILL.md");
+  if (!existsSync33(skillMd))
     return false;
   try {
     const body = readFileSync12(skillMd, "utf-8");
@@ -99906,7 +100647,7 @@ function looksLikeFusionSkillTarget(path2) {
     return false;
   if (basename8(path2).toLowerCase() === FUSION_SKILL_NAME)
     return true;
-  return existsSync32(join41(path2, "SKILL.md"));
+  return existsSync33(join42(path2, "SKILL.md"));
 }
 var FUSION_SKILL_NAME;
 var init_fusion_skill_install = __esm({
@@ -100069,7 +100810,7 @@ var init_dist = __esm({
 // ../../plugins/fusion-plugin-openclaw-runtime/dist/pi-module.js
 import { spawn as spawn7 } from "node:child_process";
 import { randomUUID as randomUUID18 } from "node:crypto";
-import { readFile as readFile19 } from "node:fs/promises";
+import { readFile as readFile20 } from "node:fs/promises";
 function asString(v) {
   return typeof v === "string" && v.trim() !== "" ? v.trim() : void 0;
 }
@@ -100146,8 +100887,8 @@ function createCliSession(opts) {
   };
 }
 async function configureOpenClawMcpServer(opts) {
-  const serverValue = await readFile19(opts.serverConfigPath, "utf-8");
-  await new Promise((resolve23, reject) => {
+  const serverValue = await readFile20(opts.serverConfigPath, "utf-8");
+  await new Promise((resolve24, reject) => {
     const child = spawn7(opts.binaryPath, ["--no-color", "--profile", opts.profile, "mcp", "set", opts.serverName, serverValue], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -100158,7 +100899,7 @@ async function configureOpenClawMcpServer(opts) {
     child.on("error", (err) => reject(new Error(`openclaw: failed to configure MCP server \u2014 ${err.message}`)));
     child.on("close", (code) => {
       if (code === 0) {
-        resolve23();
+        resolve24();
         return;
       }
       reject(new Error(`openclaw: mcp set failed (${String(code)}): ${extractStderrError(stderr)}`));
@@ -100169,7 +100910,7 @@ async function promptCli(session, message, config, callbacks, signal) {
   const args = buildOpenClawArgs(config, session, message);
   const cb = { ...session.callbacks, ...callbacks };
   cb.onToolStart?.("openclaw.agent", { sessionId: session.sessionId });
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     let settled = false;
     const child = spawn7(config.binaryPath, args, {
       stdio: ["ignore", "pipe", "pipe"]
@@ -100262,7 +101003,7 @@ async function promptCli(session, message, config, callbacks, signal) {
         ...metaError ? { error: metaError } : {},
         ...errorText.length > 0 ? { toolErrors: errorText } : {}
       });
-      resolve23();
+      resolve24();
     });
   });
 }
@@ -100285,9 +101026,9 @@ var init_pi_module = __esm({
 // ../../plugins/fusion-plugin-openclaw-runtime/dist/mcp-config.js
 import { writeFileSync as writeFileSync3 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join42 } from "node:path";
+import { join as join43 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
-import { dirname as dirname13 } from "node:path";
+import { dirname as dirname14 } from "node:path";
 function toolsToMcpToolDefs(tools) {
   if (!Array.isArray(tools))
     return [];
@@ -100299,16 +101040,16 @@ function toolsToMcpToolDefs(tools) {
 }
 function writeOpenClawMcpBridgeFiles(toolDefs, cacheKey) {
   const suffix = cacheKey ? `${process.pid}-${cacheKey}` : `${process.pid}`;
-  const schemaPath = join42(tmpdir4(), `openclaw-runtime-mcp-schemas-${suffix}.json`);
+  const schemaPath = join43(tmpdir4(), `openclaw-runtime-mcp-schemas-${suffix}.json`);
   writeFileSync3(schemaPath, JSON.stringify(toolDefs));
   const __filename = fileURLToPath5(import.meta.url);
-  const __dirname2 = dirname13(__filename);
-  const serverPath = join42(__dirname2, "mcp-schema-server.cjs");
+  const __dirname2 = dirname14(__filename);
+  const serverPath = join43(__dirname2, "mcp-schema-server.cjs");
   const serverConfig = {
     command: "node",
     args: [serverPath, schemaPath]
   };
-  const serverConfigPath = join42(tmpdir4(), `openclaw-runtime-mcp-server-${suffix}.json`);
+  const serverConfigPath = join43(tmpdir4(), `openclaw-runtime-mcp-server-${suffix}.json`);
   writeFileSync3(serverConfigPath, JSON.stringify(serverConfig));
   return {
     schemaPath,
@@ -100553,7 +101294,7 @@ var init_context = __esm({
 
 // ../dashboard/src/github.ts
 function delay2(ms) {
-  return new Promise((resolve23) => setTimeout(resolve23, ms));
+  return new Promise((resolve24) => setTimeout(resolve24, ms));
 }
 function normalizeCheckState(state) {
   switch ((state ?? "").toLowerCase()) {
@@ -107071,10 +107812,10 @@ var require_browser3 = __commonJS({
           text = canvas;
           canvas = void 0;
         }
-        return new Promise(function(resolve23, reject) {
+        return new Promise(function(resolve24, reject) {
           try {
             const data = QRCode2.create(text, opts);
-            resolve23(renderFunc(data, canvas, opts));
+            resolve24(renderFunc(data, canvas, opts));
           } catch (e) {
             reject(e);
           }
@@ -107156,11 +107897,11 @@ var require_server = __commonJS({
     }
     function render(renderFunc, text, params) {
       if (!params.cb) {
-        return new Promise(function(resolve23, reject) {
+        return new Promise(function(resolve24, reject) {
           try {
             const data = QRCode2.create(text, params.opts);
             return renderFunc(data, params.opts, function(err, data2) {
-              return err ? reject(err) : resolve23(data2);
+              return err ? reject(err) : resolve24(data2);
             });
           } catch (e) {
             reject(e);
@@ -107621,7 +108362,7 @@ var init_exec_file = __esm({
 
 // ../dashboard/src/routes/register-project-routes.ts
 import * as fsPromises from "node:fs/promises";
-var access5, stat6, mkdir13, readdir8, rm2;
+var access5, stat7, mkdir14, readdir9, rm3;
 var init_register_project_routes = __esm({
   "../dashboard/src/routes/register-project-routes.ts"() {
     "use strict";
@@ -107631,10 +108372,10 @@ var init_register_project_routes = __esm({
     init_project_store_resolver();
     ({
       access: access5,
-      stat: stat6,
-      mkdir: mkdir13,
-      readdir: readdir8,
-      rm: rm2
+      stat: stat7,
+      mkdir: mkdir14,
+      readdir: readdir9,
+      rm: rm3
     } = fsPromises);
   }
 });
@@ -107794,7 +108535,7 @@ var init_agent_generation = __esm({
 
 // ../dashboard/src/routes/register-agent-import-export-generation-routes.ts
 import * as fsPromises2 from "node:fs/promises";
-var mkdtemp, access6, stat7, mkdir14, rm3, fsWriteFile;
+var mkdtemp, access6, stat8, mkdir15, rm4, fsWriteFile;
 var init_register_agent_import_export_generation_routes = __esm({
   "../dashboard/src/routes/register-agent-import-export-generation-routes.ts"() {
     "use strict";
@@ -107802,7 +108543,7 @@ var init_register_agent_import_export_generation_routes = __esm({
     init_ai_session_diagnostics();
     init_sse_buffer();
     init_agent_generation();
-    ({ mkdtemp, access: access6, stat: stat7, mkdir: mkdir14, rm: rm3, writeFile: fsWriteFile } = fsPromises2);
+    ({ mkdtemp, access: access6, stat: stat8, mkdir: mkdir15, rm: rm4, writeFile: fsWriteFile } = fsPromises2);
   }
 });
 
@@ -107889,7 +108630,7 @@ var init_droid_cli_probe = __esm({
 // ../../plugins/fusion-plugin-cursor-runtime/src/cli-spawn.ts
 import { spawn as spawn10 } from "node:child_process";
 async function runCursorCommand(binary, args, timeoutMs) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     const child = spawn10(binary, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -107898,7 +108639,7 @@ async function runCursorCommand(binary, args, timeoutMs) {
         child.kill("SIGKILL");
       } catch {
       }
-      resolve23({ code: 124, stdout, stderr });
+      resolve24({ code: 124, stdout, stderr });
     }, timeoutMs);
     child.stdout?.on("data", (c) => {
       stdout += c.toString("utf-8");
@@ -107908,11 +108649,11 @@ async function runCursorCommand(binary, args, timeoutMs) {
     });
     child.once("error", () => {
       clearTimeout(timer);
-      resolve23({ code: 127, stdout, stderr });
+      resolve24({ code: 127, stdout, stderr });
     });
     child.once("close", (code) => {
       clearTimeout(timer);
-      resolve23({ code, stdout, stderr });
+      resolve24({ code, stdout, stderr });
     });
   });
 }
@@ -108411,7 +109152,7 @@ async function spawnPaperclipCliJson(args, opts) {
   }
   const timeoutMs = opts.cliTimeoutMs ?? 15e3;
   const label = ["paperclipai", ...args].join(" ");
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     let child;
     try {
       child = spawn13(bin, fullArgs, { stdio: ["ignore", "pipe", "pipe"] });
@@ -108457,7 +109198,7 @@ async function spawnPaperclipCliJson(args, opts) {
         return;
       }
       try {
-        resolve23(JSON.parse(cleaned));
+        resolve24(JSON.parse(cleaned));
       } catch {
         reject(new Error(`${label} returned non-JSON output: ${cleaned.slice(0, 200)}`));
       }
@@ -108527,7 +109268,7 @@ var init_paperclip_client = __esm({
 // ../../plugins/fusion-plugin-paperclip-runtime/dist/runtime-adapter.js
 import { randomUUID as randomUUID21 } from "node:crypto";
 function sleep4(ms) {
-  return new Promise((resolve23) => setTimeout(resolve23, ms));
+  return new Promise((resolve24) => setTimeout(resolve24, ms));
 }
 function asString2(value) {
   return typeof value === "string" ? value : void 0;
@@ -113048,7 +113789,7 @@ var init_auth_middleware = __esm({
 
 // ../dashboard/src/server.ts
 import express from "express";
-import { join as join43, dirname as dirname14 } from "node:path";
+import { join as join44, dirname as dirname15 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function clearAiSessionCleanupInterval() {
   if (!aiSessionCleanupIntervalHandle) {
@@ -113084,7 +113825,7 @@ var init_server = __esm({
     init_auth_middleware();
     init_remote_auth();
     init_cli_package_version();
-    __dirname = dirname14(fileURLToPath6(import.meta.url));
+    __dirname = dirname15(fileURLToPath6(import.meta.url));
     MIN_AI_SESSION_TTL_MS = 10 * 60 * 1e3;
     MAX_AI_SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
     MIN_AI_SESSION_CLEANUP_INTERVAL_MS = 60 * 1e3;
@@ -113156,7 +113897,7 @@ var init_src5 = __esm({
 });
 
 // src/project-context.ts
-import { resolve as resolve21, dirname as dirname15, basename as basename9 } from "node:path";
+import { resolve as resolve22, dirname as dirname16, basename as basename9 } from "node:path";
 async function resolveProject(projectNameFlag, cwd = process.cwd(), globalDir) {
   const central = new CentralCore(globalDir);
   await central.init();
@@ -113232,10 +113973,10 @@ async function clearDefaultProject(globalDir) {
   await globalStore.updateSettings(rest);
 }
 async function detectProjectFromCwd(cwd, central) {
-  const startDir = resolve21(cwd);
+  const startDir = resolve22(cwd);
   let currentDir = startDir;
   while (true) {
-    const kbPath = resolve21(currentDir, ".fusion", "fusion.db");
+    const kbPath = resolve22(currentDir, ".fusion", "fusion.db");
     if (isValidSqliteDatabaseFile(kbPath)) {
       const project = await central.getProjectByPath(currentDir);
       if (project) {
@@ -113249,7 +113990,7 @@ async function detectProjectFromCwd(cwd, central) {
         };
       }
     }
-    const parentDir = dirname15(currentDir);
+    const parentDir = dirname16(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -113340,8 +114081,8 @@ __export(task_exports, {
   runTaskUpdate: () => runTaskUpdate
 });
 import { createInterface as createInterface2 } from "node:readline/promises";
-import { watchFile, unwatchFile, statSync as statSync6, existsSync as existsSync33, readFileSync as readFileSync13 } from "node:fs";
-import { basename as basename10, join as join44 } from "node:path";
+import { watchFile, unwatchFile, statSync as statSync6, existsSync as existsSync34, readFileSync as readFileSync13 } from "node:fs";
+import { basename as basename10, join as join45 } from "node:path";
 function getGitHubIssueUrl(sourceMetadata) {
   if (!sourceMetadata || typeof sourceMetadata !== "object") return void 0;
   const issueUrl = sourceMetadata.issueUrl;
@@ -113517,10 +114258,10 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName,
   }
   console.log(`    Path:   .fusion/tasks/${task.id}/`);
   if (attachFiles && attachFiles.length > 0) {
-    const { readFile: readFile22 } = await import("node:fs/promises");
-    const { basename: basename12, extname: extname4, resolve: resolve23 } = await import("node:path");
+    const { readFile: readFile23 } = await import("node:fs/promises");
+    const { basename: basename12, extname: extname4, resolve: resolve24 } = await import("node:path");
     for (const filePath of attachFiles) {
-      const resolvedPath = resolve23(filePath);
+      const resolvedPath = resolve24(filePath);
       const filename = basename12(resolvedPath);
       const ext = extname4(filename).toLowerCase();
       const mimeType = MIME_TYPES[ext];
@@ -113530,7 +114271,7 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName,
       }
       let content;
       try {
-        content = await readFile22(resolvedPath);
+        content = await readFile23(resolvedPath);
       } catch {
         console.error(`    \u2717 Cannot read file: ${filePath}`);
         continue;
@@ -113596,11 +114337,11 @@ async function runTaskLog(id, message, outcome, projectName) {
   console.log(`  \u2713 ${id}: logged "${message}"`);
   console.log();
 }
-function formatTimestamp3(timestamp) {
+function formatTimestamp4(timestamp) {
   return new Date(timestamp).toLocaleTimeString();
 }
 function formatLogEntry(entry) {
-  const ts = formatTimestamp3(entry.timestamp);
+  const ts = formatTimestamp4(entry.timestamp);
   const agent = entry.agent ? `[${entry.agent.toUpperCase()}] ` : "";
   switch (entry.type) {
     case "text":
@@ -113654,8 +114395,8 @@ async function runTaskLogs(id, options = {}, projectName) {
   printEntries(filteredEntries);
   if (options.follow) {
     const projectPath = projectContext?.projectPath ?? process.cwd();
-    const logPath = join44(projectPath, ".fusion", "tasks", id, "agent.log");
-    if (!existsSync33(logPath)) {
+    const logPath = join45(projectPath, ".fusion", "tasks", id, "agent.log");
+    if (!existsSync34(logPath)) {
       console.log(`
   Waiting for log file to be created...`);
     }
@@ -113816,10 +114557,10 @@ async function runTaskMerge(id, projectName) {
   }
 }
 async function runTaskAttach(id, filePath, projectName) {
-  const { readFile: readFile22 } = await import("node:fs/promises");
+  const { readFile: readFile23 } = await import("node:fs/promises");
   const { basename: basename12, extname: extname4 } = await import("node:path");
-  const { resolve: resolve23 } = await import("node:path");
-  const resolvedPath = resolve23(filePath);
+  const { resolve: resolve24 } = await import("node:path");
+  const resolvedPath = resolve24(filePath);
   const filename = basename12(resolvedPath);
   const ext = extname4(filename).toLowerCase();
   const mimeType = MIME_TYPES[ext];
@@ -113830,7 +114571,7 @@ async function runTaskAttach(id, filePath, projectName) {
   }
   let content;
   try {
-    content = await readFile22(resolvedPath);
+    content = await readFile23(resolvedPath);
   } catch {
     console.error(`Cannot read file: ${filePath}`);
     process.exit(1);
@@ -114360,12 +115101,12 @@ async function promptText(question) {
   console.log("  (Enter your response. Type DONE on its own line when finished):\n");
   const rl = createInterface2({ input: process.stdin, output: process.stdout });
   const lines = [];
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     const askLine = () => {
       rl.question("  ").then((line) => {
         if (line.trim() === "DONE") {
           rl.close();
-          resolve23(lines.join("\n"));
+          resolve24(lines.join("\n"));
         } else {
           lines.push(line);
           askLine();
@@ -114770,9 +115511,9 @@ async function runSkillsInstall(args, options) {
     stdio: "inherit",
     shell: true
   });
-  const exitCode = await new Promise((resolve23, reject) => {
+  const exitCode = await new Promise((resolve24, reject) => {
     child.on("exit", (code) => {
-      resolve23(code ?? 1);
+      resolve24(code ?? 1);
     });
     child.on("error", (err) => {
       reject(err);
@@ -114800,9 +115541,9 @@ init_gh_cli();
 init_src2();
 import { Type as Type8 } from "typebox";
 import { StringEnum } from "@mariozechner/pi-ai";
-import { resolve as resolve22, basename as basename11, extname as extname3, join as join45 } from "node:path";
-import { readFile as readFile21 } from "node:fs/promises";
-import { existsSync as existsSync34 } from "node:fs";
+import { resolve as resolve23, basename as basename11, extname as extname3, join as join46 } from "node:path";
+import { readFile as readFile22 } from "node:fs/promises";
+import { existsSync as existsSync35 } from "node:fs";
 import { spawn as spawn12 } from "node:child_process";
 var MIME_TYPES2 = {
   ".png": "image/png",
@@ -114820,14 +115561,14 @@ var MIME_TYPES2 = {
   ".xml": "application/xml"
 };
 function resolveProjectRoot2(cwd) {
-  let current = resolve22(cwd);
+  let current = resolve23(cwd);
   while (true) {
-    if (existsSync34(join45(current, ".fusion"))) {
+    if (existsSync35(join46(current, ".fusion"))) {
       return current;
     }
-    const parent = resolve22(current, "..");
+    const parent = resolve23(current, "..");
     if (parent === current) {
-      return resolve22(cwd);
+      return resolve23(cwd);
     }
     current = parent;
   }
@@ -114843,7 +115584,7 @@ async function getStore2(cwd) {
   return store;
 }
 function getFusionDir(cwd) {
-  return join45(resolveProjectRoot2(cwd), ".fusion");
+  return join46(resolveProjectRoot2(cwd), ".fusion");
 }
 async function validateAssignableAgentId(cwd, agentId, task, override = false) {
   const { AgentStore: AgentStore2, isEphemeralAgent: isEphemeralAgent2 } = await Promise.resolve().then(() => (init_src(), src_exports));
@@ -114991,10 +115732,10 @@ async function sleepWithSignal(ms, signal) {
   if (ms <= 0) {
     return;
   }
-  await new Promise((resolve23, reject) => {
+  await new Promise((resolve24, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve23();
+      resolve24();
     }, ms);
     const onAbort = () => {
       clearTimeout(timer);
@@ -115332,7 +116073,7 @@ Column: triage
       path: Type8.String({ description: "Path to the file to attach" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const filePath = resolve22(ctx.cwd, params.path.replace(/^@/, ""));
+      const filePath = resolve23(ctx.cwd, params.path.replace(/^@/, ""));
       const filename = basename11(filePath);
       const ext = extname3(filename).toLowerCase();
       const mimeType = MIME_TYPES2[ext];
@@ -115343,7 +116084,7 @@ Column: triage
       }
       let content;
       try {
-        content = await readFile21(filePath);
+        content = await readFile22(filePath);
       } catch {
         throw new Error(`Cannot read file: ${params.path}`);
       }
@@ -117269,12 +118010,12 @@ ${lines.join("\n")}` }],
       child.stderr?.on("data", (data) => {
         stderr += data.toString();
       });
-      const exitCode = await new Promise((resolve23) => {
+      const exitCode = await new Promise((resolve24) => {
         child.on("exit", (code) => {
-          resolve23(code ?? 1);
+          resolve24(code ?? 1);
         });
         child.on("error", () => {
-          resolve23(1);
+          resolve24(1);
         });
       });
       try {