@runfusion/fusion 0.8.0 → 0.8.2

package/dist/bin.js

@@ -2434,7 +2434,7 @@ var init_db = __esm({
     "use strict";
     init_sqlite_adapter();
     init_types();
-    SCHEMA_VERSION = 50;
+    SCHEMA_VERSION = 51;
     SCHEMA_SQL = `
 -- Tasks table with JSON columns for nested data
 CREATE TABLE IF NOT EXISTS tasks (
@@ -3967,6 +3967,13 @@ CREATE INDEX IF NOT EXISTS idxTodoItemsSortOrder ON todo_items(listId, sortOrder
             this.addColumnIfMissing("tasks", "effectiveNodeSource", "TEXT");
           });
         }
+        if (version < 51) {
+          this.applyMigration(51, () => {
+            if (this.hasTable("chat_messages")) {
+              this.addColumnIfMissing("chat_messages", "attachments", "TEXT");
+            }
+          });
+        }
       }
       /**
        * Run a single migration step inside a transaction and bump the version.
@@ -6479,9 +6486,9 @@ var init_global_settings = __esm({
        * Serialize operations via promise chain to prevent lost-update races.
        */
       withLock(fn) {
-        let resolve36;
+        let resolve39;
         const next = new Promise((r) => {
-          resolve36 = r;
+          resolve39 = r;
         });
         const prev = this.lock;
         this.lock = next;
@@ -6489,7 +6496,7 @@ var init_global_settings = __esm({
           try {
             return await fn();
           } finally {
-            resolve36();
+            resolve39();
           }
         });
       }
@@ -11799,8 +11806,8 @@ import { join as join8, dirname as dirname2 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getAppVersion() {
   if (cachedVersion !== null) return cachedVersion;
-  const __dirname3 = dirname2(fileURLToPath(import.meta.url));
-  let currentDir = __dirname3;
+  const __dirname2 = dirname2(fileURLToPath(import.meta.url));
+  let currentDir = __dirname2;
   for (let i = 0; i < 10; i++) {
     try {
       const pkgPath = join8(currentDir, "package.json");
@@ -27785,9 +27792,9 @@ var init_automation_store = __esm({
        */
       withScheduleLock(id, fn) {
         const prev = this.scheduleLocks.get(id) ?? Promise.resolve();
-        let resolve36;
+        let resolve39;
         const next = new Promise((r) => {
-          resolve36 = r;
+          resolve39 = r;
         });
         this.scheduleLocks.set(id, next);
         return prev.then(async () => {
@@ -27797,7 +27804,7 @@ var init_automation_store = __esm({
             if (this.scheduleLocks.get(id) === next) {
               this.scheduleLocks.delete(id);
             }
-            resolve36();
+            resolve39();
           }
         });
       }
@@ -29585,7 +29592,7 @@ var init_project_memory = __esm({
 // ../core/src/run-command.ts
 import { spawn } from "node:child_process";
 function runCommandAsync(command, options = {}) {
-  return new Promise((resolve36) => {
+  return new Promise((resolve39) => {
     const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
     let stdout = "";
     let stderr = "";
@@ -29644,7 +29651,7 @@ function runCommandAsync(command, options = {}) {
         clearTimeout(forceKillTimer);
         forceKillTimer = null;
       }
-      resolve36({
+      resolve39({
         stdout,
         stderr,
         exitCode: null,
@@ -29662,7 +29669,7 @@ function runCommandAsync(command, options = {}) {
       }
       signalProcessGroup("SIGTERM");
       scheduleForceKill(NORMAL_CLEANUP_FORCE_KILL_DELAY_MS);
-      resolve36({
+      resolve39({
         stdout,
         stderr,
         exitCode: code,
@@ -30812,9 +30819,9 @@ ${outcome}`;
        * lost-update races on the nextId counter.
        */
       withConfigLock(fn) {
-        let resolve36;
+        let resolve39;
         const next = new Promise((r) => {
-          resolve36 = r;
+          resolve39 = r;
         });
         const prev = this.configLock;
         this.configLock = next;
@@ -30822,7 +30829,7 @@ ${outcome}`;
           try {
             return await fn();
           } finally {
-            resolve36();
+            resolve39();
           }
         });
       }
@@ -30832,9 +30839,9 @@ ${outcome}`;
        */
       withTaskLock(id, fn) {
         const prev = this.taskLocks.get(id) ?? Promise.resolve();
-        let resolve36;
+        let resolve39;
         const next = new Promise((r) => {
-          resolve36 = r;
+          resolve39 = r;
         });
         this.taskLocks.set(id, next);
         return prev.then(async () => {
@@ -30844,7 +30851,7 @@ ${outcome}`;
             if (this.taskLocks.get(id) === next) {
               this.taskLocks.delete(id);
             }
-            resolve36();
+            resolve39();
           }
         });
       }
@@ -32502,8 +32509,8 @@ ${task.description}
           if (this.isWatching) this.taskCache.delete(id);
           const dir2 = this.taskDir(id);
           if (existsSync12(dir2)) {
-            const { rm: rm5 } = await import("node:fs/promises");
-            await rm5(dir2, { recursive: true });
+            const { rm: rm6 } = await import("node:fs/promises");
+            await rm6(dir2, { recursive: true });
           }
           for (const dependentTask of rewrittenDependents) {
             this.emit("task:updated", dependentTask);
@@ -32838,8 +32845,8 @@ ${task.description}
           this.archiveDb.upsert(entry);
           this.db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
           this.db.bumpLastModified();
-          const { rm: rm5 } = await import("node:fs/promises");
-          await rm5(dir2, { recursive: true, force: true });
+          const { rm: rm6 } = await import("node:fs/promises");
+          await rm6(dir2, { recursive: true, force: true });
           if (this.isWatching) {
             this.taskCache.delete(id);
           }
@@ -32999,7 +33006,7 @@ ${task.description}
               }
             }
           }
-          await new Promise((resolve36) => setImmediate(resolve36));
+          await new Promise((resolve39) => setImmediate(resolve39));
           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();
@@ -33019,7 +33026,7 @@ ${task.description}
               this.emit("task:updated", task);
             }
             if (i > 0 && i % 50 === 0) {
-              await new Promise((resolve36) => setImmediate(resolve36));
+              await new Promise((resolve39) => setImmediate(resolve39));
             }
           }
           const elapsed = Date.now() - startTime;
@@ -33802,14 +33809,14 @@ ${task.description}
         if (rows.length === 0) {
           return;
         }
-        const { rm: rm5 } = await import("node:fs/promises");
+        const { rm: rm6 } = 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 rm5(this.taskDir(task.id), { recursive: true, force: true });
+          await rm6(this.taskDir(task.id), { recursive: true, force: true });
           if (this.isWatching) {
             this.taskCache.delete(task.id);
           }
@@ -33832,8 +33839,8 @@ ${task.description}
           this.archiveDb.upsert(entry);
           this.db.prepare("DELETE FROM tasks WHERE id = ?").run(task.id);
           this.db.bumpLastModified();
-          const { rm: rm5 } = await import("node:fs/promises");
-          await rm5(dir2, { recursive: true, force: true });
+          const { rm: rm6 } = await import("node:fs/promises");
+          await rm6(dir2, { recursive: true, force: true });
           if (this.isWatching) {
             this.taskCache.delete(task.id);
           }
@@ -34845,7 +34852,7 @@ function runGh(args, cwd) {
 }
 function runGhAsync(args, cwdOrOptions) {
   const { cwd, signal: externalSignal, timeoutMs = DEFAULT_GH_TIMEOUT_MS } = normalizeRunGhOptions(cwdOrOptions);
-  return new Promise((resolve36, reject2) => {
+  return new Promise((resolve39, reject2) => {
     if (externalSignal?.aborted) {
       reject2(makeGhError(`gh command aborted: ${describeAbortReason(externalSignal.reason)}`, "ABORT_ERR"));
       return;
@@ -34896,7 +34903,7 @@ function runGhAsync(args, cwdOrOptions) {
           ghError.stderr = stderr ?? "";
           reject2(ghError);
         } else {
-          resolve36(stdout ?? "");
+          resolve39(stdout ?? "");
         }
       }
     );
@@ -35184,9 +35191,9 @@ var init_routine_store = __esm({
        */
       withRoutineLock(id, fn) {
         const prev = this.routineLocks.get(id) ?? Promise.resolve();
-        let resolve36;
+        let resolve39;
         const next = new Promise((r) => {
-          resolve36 = r;
+          resolve39 = r;
         });
         this.routineLocks.set(id, next);
         return prev.then(async () => {
@@ -35196,7 +35203,7 @@ var init_routine_store = __esm({
             if (this.routineLocks.get(id) === next) {
               this.routineLocks.delete(id);
             }
-            resolve36();
+            resolve39();
           }
         });
       }
@@ -35795,13 +35802,13 @@ var init_plugin_loader = __esm({
        * Execute a promise with a timeout.
        */
       withTimeout(promise, ms, timeoutMessage) {
-        return new Promise((resolve36, reject2) => {
+        return new Promise((resolve39, reject2) => {
           const timer = setTimeout(() => {
             reject2(new Error(timeoutMessage));
           }, ms);
           promise.then((result) => {
             clearTimeout(timer);
-            resolve36(result);
+            resolve39(result);
           }).catch((err) => {
             clearTimeout(timer);
             reject2(err);
@@ -39008,7 +39015,7 @@ var require_get_stream = __commonJS({
       };
       const { maxBuffer } = options;
       let stream;
-      await new Promise((resolve36, reject2) => {
+      await new Promise((resolve39, reject2) => {
         const rejectPromise = (error) => {
           if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
             error.bufferedData = stream.getBufferedValue();
@@ -39020,7 +39027,7 @@ var require_get_stream = __commonJS({
             rejectPromise(error);
             return;
           }
-          resolve36();
+          resolve39();
         });
         stream.on("data", () => {
           if (stream.getBufferedLength() > maxBuffer) {
@@ -40314,7 +40321,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((resolve36, reject2) => {
+        return new Promise((resolve39, reject2) => {
           this.zipfile.on("error", (err) => {
             this.canceled = true;
             reject2(err);
@@ -40323,7 +40330,7 @@ var require_extract_zip = __commonJS({
           this.zipfile.on("close", () => {
             if (!this.canceled) {
               debug("zip extraction complete");
-              resolve36();
+              resolve39();
             }
           });
           this.zipfile.on("entry", async (entry) => {
@@ -47773,10 +47780,10 @@ function pushAlias(aliases, value) {
   if (pathRef !== normalized && pathRef.length > 0) {
     aliases.add(pathRef);
   }
-  const basename16 = extractPathBasename(value);
-  if (basename16) {
-    aliases.add(basename16);
-    const basenameSlug = slugifyAgentReference(basename16);
+  const basename17 = extractPathBasename(value);
+  if (basename17) {
+    aliases.add(basename17);
+    const basenameSlug = slugifyAgentReference(basename17);
     if (basenameSlug.length > 0) {
       aliases.add(basenameSlug);
     }
@@ -48503,6 +48510,7 @@ var init_chat_store = __esm({
           content: row.content,
           thinkingOutput: row.thinkingOutput ?? null,
           metadata: fromJson(row.metadata) ?? null,
+          attachments: fromJson(row.attachments) ?? void 0,
           createdAt: row.createdAt
         };
       }
@@ -48721,11 +48729,12 @@ var init_chat_store = __esm({
           content: input.content,
           thinkingOutput: input.thinkingOutput ?? null,
           metadata: input.metadata ?? null,
+          attachments: input.attachments,
           createdAt: now
         };
         this.db.prepare(`
-      INSERT INTO chat_messages (id, sessionId, role, content, thinkingOutput, metadata, createdAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO chat_messages (id, sessionId, role, content, thinkingOutput, metadata, attachments, createdAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
           message.id,
           message.sessionId,
@@ -48733,6 +48742,7 @@ var init_chat_store = __esm({
           message.content,
           message.thinkingOutput,
           toJsonNullable(message.metadata),
+          toJsonNullable(message.attachments),
           message.createdAt
         );
         this.db.prepare("UPDATE chat_sessions SET updatedAt = ? WHERE id = ?").run(now, sessionId);
@@ -48740,6 +48750,28 @@ var init_chat_store = __esm({
         this.emit("chat:message:added", message);
         return message;
       }
+      /**
+       * Append a file attachment metadata record to an existing message.
+       */
+      addMessageAttachment(sessionId, messageId, attachment) {
+        const message = this.getMessage(messageId);
+        if (!message || message.sessionId !== sessionId) {
+          throw new Error(`Message ${messageId} not found in session ${sessionId}`);
+        }
+        const updatedAttachments = [...message.attachments ?? [], attachment];
+        this.db.prepare(`
+      UPDATE chat_messages
+      SET attachments = ?
+      WHERE id = ?
+    `).run(toJsonNullable(updatedAttachments), messageId);
+        const updated = this.getMessage(messageId);
+        if (!updated) {
+          throw new Error(`Failed to update message ${messageId}`);
+        }
+        this.db.bumpLastModified();
+        this.emit("chat:message:updated", updated);
+        return updated;
+      }
       /**
        * Get messages for a chat session with optional filtering.
        *
@@ -51040,12 +51072,12 @@ var init_concurrency = __esm({
           this._active++;
           return Promise.resolve();
         }
-        return new Promise((resolve36) => {
+        return new Promise((resolve39) => {
           this._waiters.push({
             priority,
             resolve: () => {
               this._active++;
-              resolve36();
+              resolve39();
             }
           });
         });
@@ -53466,20 +53498,20 @@ async function withRateLimitRetry(fn, options = {}) {
   throw lastError ?? new Error("withRateLimitRetry: unexpected state");
 }
 function sleep(ms, signal) {
-  return new Promise((resolve36, reject2) => {
+  return new Promise((resolve39, reject2) => {
     if (signal?.aborted) {
       reject2(signal.reason ?? new Error("Aborted"));
       return;
     }
-    const timer = setTimeout(resolve36, ms);
+    const timer = setTimeout(resolve39, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
         reject2(signal.reason ?? new Error("Aborted"));
       };
       signal.addEventListener("abort", onAbort, { once: true });
-      const origResolve = resolve36;
-      resolve36 = () => {
+      const origResolve = resolve39;
+      resolve39 = () => {
         signal.removeEventListener("abort", onAbort);
         origResolve();
       };
@@ -55446,7 +55478,7 @@ import { existsSync as existsSync21 } from "node:fs";
 import { join as join26 } from "node:path";
 import { Type as Type3 } from "typebox";
 async function execWithProcessGroup(command, options) {
-  return new Promise((resolve36, reject2) => {
+  return new Promise((resolve39, reject2) => {
     if (options.signal?.aborted) {
       reject2(Object.assign(
         new Error(`Command aborted before start: ${command}`),
@@ -55539,7 +55571,7 @@ async function execWithProcessGroup(command, options) {
         return;
       }
       if (code === 0) {
-        resolve36({ stdout, stderr, bufferOverflow: stdoutOverflow || stderrOverflow });
+        resolve39({ stdout, stderr, bufferOverflow: stdoutOverflow || stderrOverflow });
         return;
       }
       reject2(Object.assign(
@@ -56102,21 +56134,31 @@ ${failureContext.output.slice(0, VERIFICATION_LOG_MAX_CHARS)}
     return false;
   }
 }
-async function amendMergeCommitWithFixes(rootDir, taskId, authorArg) {
+function resetMergeWithWarn(rootDir, taskId, label) {
+  try {
+    execSync("git reset --merge", { cwd: rootDir, stdio: "pipe" });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    mergerLog.warn(`${taskId}: git reset --merge cleanup failed during ${label}: ${msg}`);
+  }
+}
+function buildDeterministicMergeMessage(params) {
+  const { taskId, branch, commitLog, includeTaskId } = params;
+  const prefix = includeTaskId ? `feat(${taskId})` : "feat";
+  const subject = `${prefix}: merge ${branch}`;
+  const body = commitLog && commitLog.trim().length > 0 ? commitLog.trim() : `- merge ${branch}`;
+  const escape = (s) => s.replace(/(["\\$`])/g, "\\$1");
+  return {
+    subjectArg: `-m "${escape(subject)}"`,
+    bodyArg: `-m "${escape(body)}"`
+  };
+}
+async function commitOrAmendMergeWithFixes(rootDir, taskId, branch, commitLog, includeTaskId, preAttemptHeadSha, authorArg) {
   try {
-    const { stdout: stagedFiles } = await execAsync2("git diff --cached --name-only", {
-      cwd: rootDir,
-      encoding: "utf-8"
-    });
     const { stdout: unstagedFiles } = await execAsync2("git diff --name-only", {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const hasChanges = stagedFiles.trim().length > 0 || unstagedFiles.trim().length > 0;
-    if (!hasChanges) {
-      mergerLog.log(`${taskId}: no changes to amend after verification fix`);
-      return false;
-    }
     if (unstagedFiles.trim().length > 0) {
       await execAsync2("git add -A", { cwd: rootDir });
     }
@@ -56124,12 +56166,10 @@ async function amendMergeCommitWithFixes(rootDir, taskId, authorArg) {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const gitlinkPaths = [];
     for (const line of staged.split("\n")) {
       const match = line.match(/^:\d{6} 160000 [^\t]+\t(.+)$/);
-      if (match) gitlinkPaths.push(match[1]);
-    }
-    for (const path5 of gitlinkPaths) {
+      if (!match) continue;
+      const path5 = match[1];
       mergerLog.warn(`${taskId}: refusing to stage gitlink "${path5}" (project uses no submodules \u2014 likely a nested worktree). Unstaging.`);
       try {
         await execAsync2(`git reset HEAD -- "${path5}"`, { cwd: rootDir });
@@ -56142,15 +56182,43 @@ async function amendMergeCommitWithFixes(rootDir, taskId, authorArg) {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    if (finalStaged.trim().length > 0) {
-      await execAsync2(`git commit --amend --no-edit${authorArg}`, { cwd: rootDir });
-      mergerLog.log(`${taskId}: amended merge commit with verification fixes`);
+    const hasStaged = finalStaged.trim().length > 0;
+    const { stdout: currentHeadOut } = await execAsync2("git rev-parse HEAD", {
+      cwd: rootDir,
+      encoding: "utf-8"
+    });
+    const currentHead = currentHeadOut.trim();
+    const headMoved = currentHead !== preAttemptHeadSha;
+    if (!hasStaged && !headMoved) {
+      mergerLog.warn(
+        `${taskId}: refusing to record merge \u2014 no commit was created and no changes are staged. This usually means the AI agent never ran git commit and the in-merge fix had nothing to add.`
+      );
+      return false;
+    }
+    const { subjectArg, bodyArg } = buildDeterministicMergeMessage({
+      taskId,
+      branch,
+      commitLog,
+      includeTaskId
+    });
+    const trailerArg = buildTaskIdTrailerArg(taskId);
+    if (!headMoved) {
+      await execAsync2(
+        `git commit ${subjectArg} ${bodyArg}${trailerArg}${authorArg}`,
+        { cwd: rootDir }
+      );
+      mergerLog.log(`${taskId}: created fresh merge commit after verification fix (no prior commit to amend)`);
       return true;
     }
-    return false;
+    await execAsync2(
+      `git commit --amend ${subjectArg} ${bodyArg}${trailerArg}${authorArg}`,
+      { cwd: rootDir }
+    );
+    mergerLog.log(`${taskId}: amended merge commit with verification fixes (deterministic message)`);
+    return true;
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
-    mergerLog.warn(`${taskId}: failed to amend merge commit: ${errorMessage}`);
+    mergerLog.warn(`${taskId}: failed to finalize merge commit: ${errorMessage}`);
     return false;
   }
 }
@@ -56401,6 +56469,11 @@ function getCommitAuthorArg(settings) {
   const email = settings.commitAuthorEmail || "noreply@runfusion.ai";
   return ` --author="${name} <${email}>"`;
 }
+function buildSourceIssueRef(sourceIssue) {
+  if (!sourceIssue || sourceIssue.provider !== "github") return "";
+  if (!sourceIssue.repository || !sourceIssue.issueNumber) return "";
+  return `${sourceIssue.repository}#${sourceIssue.issueNumber}`;
+}
 function buildMergeSystemPrompt(includeTaskId, agentPrompts, authorArg) {
   const commitFormat = includeTaskId ? `\`\`\`
 git commit -m "<type>(<scope>): <summary>" -m "<body>"${authorArg || ""}
@@ -56411,6 +56484,7 @@ Message format:
 - **Scope:** the task ID (e.g., KB-001)
 - **Summary:** one line describing what the squash brings in (imperative mood)
 - **Body:** 2-5 bullet points summarizing the key changes, each starting with "- "
+- **GitHub reference:** when the prompt includes a source issue reference, add \`Ref: owner/repo#N\` to the commit body
 ${authorArg ? `- **Author:** Always include the --author flag as shown in the example above.` : ""}
 
 Example:
@@ -56428,6 +56502,7 @@ Message format:
 - **Type:** feat, fix, refactor, docs, test, chore
 - **Summary:** one line describing what the squash brings in (imperative mood)
 - **Body:** 2-5 bullet points summarizing the key changes, each starting with "- "
+- **GitHub reference:** when the prompt includes a source issue reference, add \`Ref: owner/repo#N\` to the commit body
 ${authorArg ? `- **Author:** Always include the --author flag as shown in the example above.` : ""}
 Do NOT include a scope in the commit message type.
 
@@ -56811,6 +56886,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
     throw new Error(`Cannot merge ${taskId}: ${mergeBlocker}`);
   }
   const branch = task.branch || `fusion/${taskId.toLowerCase()}`;
+  const sourceIssueRef = buildSourceIssueRef(task.sourceIssue);
   const worktreePath = task.worktree;
   const result = {
     task,
@@ -57114,6 +57190,17 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
       void 0,
       "merger"
     );
+    let preAttemptHeadSha = "";
+    try {
+      const { stdout } = await execAsync2("git rev-parse HEAD", {
+        cwd: rootDir,
+        encoding: "utf-8"
+      });
+      preAttemptHeadSha = stdout.trim();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      mergerLog.warn(`${taskId}: failed to capture pre-attempt HEAD (${msg}) \u2014 verification-fix finalizer will fall back to amend`);
+    }
     try {
       const success = await executeMergeAttempt({
         store,
@@ -57123,6 +57210,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
         commitLog,
         diffStat,
         includeTaskId,
+        sourceIssueRef,
         smartConflictResolution,
         mergeConflictStrategy,
         attemptNum,
@@ -57231,12 +57319,27 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
             }
             if (fixSuccess) {
               const authorArg = getCommitAuthorArg(settings);
-              await amendMergeCommitWithFixes(rootDir, taskId, authorArg);
+              const finalized = await commitOrAmendMergeWithFixes(
+                rootDir,
+                taskId,
+                branch,
+                commitLog,
+                includeTaskId,
+                preAttemptHeadSha,
+                authorArg
+              );
+              if (!finalized) {
+                resetMergeWithWarn(rootDir, taskId, "verification-fix finalize");
+                throw new Error(
+                  `${taskId}: verification fix succeeded but no merge commit could be created \u2014 refusing to mark merge complete.`
+                );
+              }
               return true;
             }
           }
         }
         mergerLog.error(`${taskId}: deterministic verification failed \u2014 aborting merge (in-merge fix exhausted or disabled)`);
+        resetMergeWithWarn(rootDir, taskId, "deterministic-verification rollback");
         throw error;
       }
       if (error.message?.includes("Build verification failed")) {
@@ -57307,7 +57410,21 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
           }
           if (fixSuccess) {
             const authorArg = getCommitAuthorArg(settings);
-            await amendMergeCommitWithFixes(rootDir, taskId, authorArg);
+            const finalized = await commitOrAmendMergeWithFixes(
+              rootDir,
+              taskId,
+              branch,
+              commitLog,
+              includeTaskId,
+              preAttemptHeadSha,
+              authorArg
+            );
+            if (!finalized) {
+              resetMergeWithWarn(rootDir, taskId, "build-verification fix finalize");
+              throw new Error(
+                `${taskId}: build verification fix succeeded but no merge commit could be created \u2014 refusing to mark merge complete.`
+              );
+            }
             return true;
           }
         }
@@ -57321,10 +57438,11 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
             await audit.git({ type: "reset:hard", target: branch, metadata: { purpose: "build-retry" } });
           } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            mergerLog.warn(`${taskId}: git reset --merge cleanup failed (build-retry): ${msg}`);
+            mergerLog.warn(`${taskId}: git reset --merge cleanup failed during build-verification rollback (build-retry): ${msg}`);
           }
           return false;
         }
+        resetMergeWithWarn(rootDir, taskId, "build-verification rollback (no retries left)");
         throw error;
       }
       if (error.name === "MergeNonConflictError") {
@@ -57672,6 +57790,7 @@ async function executeMergeAttempt(params, aiTracker) {
     commitLog,
     diffStat,
     includeTaskId,
+    sourceIssueRef,
     smartConflictResolution,
     attemptNum,
     options,
@@ -57862,19 +57981,12 @@ async function executeMergeAttempt(params, aiTracker) {
       simplifiedContext: attemptNum === 2,
       options,
       testCommand,
-      buildCommand: buildCommand2
+      buildCommand: buildCommand2,
+      sourceIssueRef
     });
     if (!agentResult.success) {
       const errorMessage = agentResult.error || "Build verification failed";
       await store.logEntry(taskId, "Build verification failed during merge", errorMessage);
-      try {
-        execSync("git reset --merge", { cwd: rootDir, stdio: "pipe" });
-      } catch (resetErr) {
-        const msg = resetErr instanceof Error ? resetErr.message : String(resetErr);
-        mergerLog.warn(
-          `${taskId}: git reset --merge cleanup failed during build-verification rollback (build-verification reset, build-retry): ${msg}`
-        );
-      }
       throw new Error(`Build verification failed for ${taskId}: ${errorMessage}`);
     }
     if (testCommand || buildCommand2) {
@@ -57890,6 +58002,24 @@ async function executeMergeAttempt(params, aiTracker) {
         options.signal
       );
     }
+    try {
+      const authorArg = getCommitAuthorArg(params.settings);
+      const { subjectArg, bodyArg } = buildDeterministicMergeMessage({
+        taskId,
+        branch,
+        commitLog,
+        includeTaskId
+      });
+      const trailerArg = buildTaskIdTrailerArg(taskId);
+      await execAsync2(
+        `git commit --amend ${subjectArg} ${bodyArg}${trailerArg}${authorArg}`,
+        { cwd: rootDir }
+      );
+      mergerLog.log(`${taskId}: rewrote AI-authored merge commit message with deterministic body`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      mergerLog.warn(`${taskId}: failed to canonicalize merge commit message (${msg}) \u2014 keeping AI-written message`);
+    }
     return true;
   } catch (error) {
     if (error instanceof Error && error.name === "MergeAbortedError") {
@@ -57912,7 +58042,7 @@ async function executeMergeAttempt(params, aiTracker) {
   }
 }
 async function attemptWithSideStrategy(params, side = "theirs", aiTracker) {
-  const { rootDir, branch, commitLog, includeTaskId, taskId, store, settings, testCommand, buildCommand: buildCommand2, testSource, buildSource } = params;
+  const { rootDir, branch, commitLog, includeTaskId, sourceIssueRef, taskId, store, settings, testCommand, buildCommand: buildCommand2, testSource, buildSource } = params;
   mergerLog.log(`${taskId}: attempting merge with -X ${side} strategy`);
   try {
     throwIfAborted(params.options.signal, taskId);
@@ -57953,8 +58083,9 @@ async function attemptWithSideStrategy(params, side = "theirs", aiTracker) {
     const fallbackPrefix = includeTaskId ? `feat(${taskId})` : "feat";
     const authorArg = getCommitAuthorArg(settings);
     const trailerArg = buildTaskIdTrailerArg(taskId);
+    const issueRefBodyArg = sourceIssueRef ? ` -m "Ref: ${sourceIssueRef}"` : "";
     await execAsync2(
-      `git commit -m "${fallbackPrefix}: merge ${branch} (auto-resolved)" -m "${escapedLog}"${trailerArg}${authorArg}`,
+      `git commit -m "${fallbackPrefix}: merge ${branch} (auto-resolved)" -m "${escapedLog}"${issueRefBodyArg}${trailerArg}${authorArg}`,
       { cwd: rootDir }
     );
     mergerLog.log(`${taskId}: committed with -X ${side} auto-resolution`);
@@ -57991,6 +58122,7 @@ async function runAiAgentForCommit(params) {
     includeTaskId,
     hasConflicts,
     simplifiedContext,
+    sourceIssueRef,
     options,
     testCommand,
     buildCommand: buildCommand2
@@ -58089,7 +58221,8 @@ async function runAiAgentForCommit(params) {
       simplifiedContext,
       testCommand,
       buildCommand: buildCommand2,
-      authorArg
+      authorArg,
+      sourceIssueRef
     });
     mergerLog.log(`${taskId}: starting fresh merge agent session`);
     try {
@@ -58121,7 +58254,8 @@ async function runAiAgentForCommit(params) {
           // Also skip detailed context
           testCommand,
           buildCommand: buildCommand2,
-          authorArg
+          authorArg,
+          sourceIssueRef
         });
         try {
           await withRateLimitRetry(async () => {
@@ -58163,8 +58297,9 @@ async function runAiAgentForCommit(params) {
         const fallbackPrefix = includeTaskId ? `feat(${taskId})` : "feat";
         const authorArg2 = getCommitAuthorArg(settings);
         const trailerArg = buildTaskIdTrailerArg(taskId);
+        const issueRefBodyArg = sourceIssueRef ? ` -m "Ref: ${sourceIssueRef}"` : "";
         await execAsync2(
-          `git commit -m "${fallbackPrefix}: merge ${branch}" -m "${escapedLog}"${trailerArg}${authorArg2}`,
+          `git commit -m "${fallbackPrefix}: merge ${branch}" -m "${escapedLog}"${issueRefBodyArg}${trailerArg}${authorArg2}`,
           { cwd: rootDir }
         );
       } else {
@@ -58187,7 +58322,7 @@ async function runAiAgentForCommit(params) {
   }
 }
 function buildMergePrompt(params) {
-  const { taskId, branch, commitLog, diffStat, hasConflicts, simplifiedContext, testCommand, buildCommand: buildCommand2, authorArg } = params;
+  const { taskId, branch, commitLog, diffStat, hasConflicts, simplifiedContext, sourceIssueRef, testCommand, buildCommand: buildCommand2, authorArg } = params;
   const truncatedCommitLog = truncateWithEllipsis(commitLog, MERGE_COMMIT_LOG_MAX_CHARS);
   const truncatedDiffStat = truncateWithEllipsis(diffStat, MERGE_DIFF_STAT_MAX_CHARS);
   const parts = [
@@ -58223,6 +58358,13 @@ function buildMergePrompt(params) {
       `Write and run the \`git commit\` command with a good message summarizing the work.${authorArg ? ` Be sure to include \`${authorArg.trim()}\` in the commit command.` : ""}`
     );
   }
+  if (sourceIssueRef) {
+    parts.push(
+      "",
+      "Include this in the commit message body:",
+      `- Ref: ${sourceIssueRef}`
+    );
+  }
   if (testCommand) {
     parts.push(
       "",
@@ -59398,7 +59540,7 @@ function resolveExecutorModelPair(taskModelProvider, taskModelId, settings) {
   return { provider: void 0, modelId: void 0 };
 }
 function sleep2(ms) {
-  return new Promise((resolve36) => setTimeout(resolve36, ms));
+  return new Promise((resolve39) => setTimeout(resolve39, ms));
 }
 var execAsync4, stepExecLog, MAX_STEP_RETRIES, RETRY_DELAYS_MS, NOOP_TASK_STORE, StepSessionExecutor;
 var init_step_session_executor = __esm({
@@ -60146,6 +60288,7 @@ function buildExecutionPrompt(task, rootDir, settings, worktreePath) {
   const reviewMatch = prompt.match(/##\s*Review Level[:\s]*(\d)/);
   const reviewLevel = reviewMatch ? parseInt(reviewMatch[1], 10) : 0;
   const authorArg = settings?.commitAuthorEnabled !== false ? ` --author="${settings?.commitAuthorName || "Fusion"} <${settings?.commitAuthorEmail || "noreply@runfusion.ai"}>"` : "";
+  const sourceIssueRef = task.sourceIssue?.provider === "github" && task.sourceIssue.repository && task.sourceIssue.issueNumber ? `${task.sourceIssue.repository}#${task.sourceIssue.issueNumber}` : "";
   const hasProgress = task.steps.length > 0 && task.steps.some((s) => s.status !== "pending");
   let progressSection = "";
   if (hasProgress) {
@@ -60248,7 +60391,7 @@ ${hasProgress ? `Resume from Step ${task.currentStep}. Do NOT redo completed ste
 Use \`fn_task_update\` to report progress on every step transition.
 Use \`fn_task_log\` for important actions and decisions.
 Use \`fn_task_create\` for truly separate follow-up work, not for fixes required to get tests, build, or typecheck back to green.
-Commit at step boundaries: \`git commit -m "feat(${task.id}): complete Step N \u2014 description"${authorArg}\`
+Commit at step boundaries: \`git commit -m "feat(${task.id}): complete Step N \u2014 description"${sourceIssueRef ? ` -m "Ref: ${sourceIssueRef}"` : ""}${authorArg}\`
 When all steps are complete: call \`fn_task_done()\`
 
 If a build command is configured, run that exact command in this worktree before calling \`fn_task_done()\`.
@@ -60281,7 +60424,7 @@ function detectReviewHandoffIntent(commentText) {
   ];
   return handoffPhrases.some((phrase) => text.includes(phrase));
 }
-var execAsync5, STEP_STATUSES, MAX_WORKFLOW_STEP_RETRIES, MAX_TASK_DONE_SESSION_RETRIES, MAX_TASK_DONE_REQUEUE_RETRIES, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2, NonRetryableWorktreeError, taskUpdateParams, taskAddDepParams, spawnAgentParams, reviewStepParams, EXECUTOR_SYSTEM_PROMPT, TaskExecutor;
+var execAsync5, STEP_STATUSES, MAX_WORKFLOW_STEP_RETRIES, MAX_TASK_DONE_SESSION_RETRIES, MAX_TASK_DONE_REQUEUE_RETRIES, COMPLETED_TASK_WATCHDOG_MS, WORKFLOW_RERUN_WATCHDOG_MS, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2, NonRetryableWorktreeError, taskUpdateParams, taskAddDepParams, spawnAgentParams, reviewStepParams, EXECUTOR_SYSTEM_PROMPT, TaskExecutor;
 var init_executor = __esm({
   "../engine/src/executor.ts"() {
     "use strict";
@@ -60317,6 +60460,8 @@ var init_executor = __esm({
     MAX_WORKFLOW_STEP_RETRIES = 3;
     MAX_TASK_DONE_SESSION_RETRIES = 3;
     MAX_TASK_DONE_REQUEUE_RETRIES = 3;
+    COMPLETED_TASK_WATCHDOG_MS = 6e4;
+    WORKFLOW_RERUN_WATCHDOG_MS = 15e3;
     WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2 = 4e3;
     NonRetryableWorktreeError = class extends Error {
     };
@@ -60434,6 +60579,7 @@ If the task's PROMPT.md includes a "Documentation Requirements" section listing
 ## Git discipline
 - Commit after completing each step (not after every file change)
 - Use conventional commit messages prefixed with the task ID
+- When the task has a GitHub issue reference, include \`Ref: owner/repo#N\` in the commit body
 - Do NOT commit broken or half-implemented code
 
 ## Worktree Boundaries
@@ -60526,6 +60672,7 @@ Lint, tests, and typecheck are also hard quality gates:
         store.on("task:moved", ({ task, from, to }) => {
           executorLog.log(`[event:task:moved] ${task.id}: ${from} \u2192 ${to}`);
           if (to === "in-progress") {
+            this.clearWorkflowRerunWatchdog(task.id);
             executorLog.log(`[event:task:moved] Initiating execute() for ${task.id}`);
             void (async () => {
               const taskForExecution = await this.resetMergeStateIfNeeded(task, from);
@@ -60534,6 +60681,7 @@ Lint, tests, and typecheck are also hard quality gates:
               (err) => executorLog.error(`Failed to start ${task.id}:`, err)
             );
           } else if (from === "in-progress") {
+            this.clearCompletedTaskWatchdog(task.id);
             if (this.activeSessions.has(task.id)) {
               executorLog.log(`${task.id} moved from in-progress to ${to} \u2014 terminating agent session`);
               this.pausedAborted.add(task.id);
@@ -60725,6 +60873,10 @@ Lint, tests, and typecheck are also hard quality gates:
       spawnedAgents = /* @__PURE__ */ new Map();
       /** Per-task baseline of session stats used for delta persistence across repeated updates. */
       tokenUsageBaselines = /* @__PURE__ */ new Map();
+      /** One-shot watchdogs for completed tasks that should have transitioned to in-review. */
+      completedTaskWatchdogs = /* @__PURE__ */ new Map();
+      /** One-shot watchdogs for workflow reruns that should have bounced back to in-progress. */
+      workflowRerunWatchdogs = /* @__PURE__ */ new Map();
       async finalizeAlreadyReviewedTask(taskId) {
         const latestTask = await this.store.getTask(taskId);
         if (!latestTask || latestTask.column !== "in-review") {
@@ -60880,6 +61032,120 @@ Lint, tests, and typecheck are also hard quality gates:
           await this.store.updateTask(task.id, updates);
         }
       }
+      clearCompletedTaskWatchdog(taskId) {
+        const handle = this.completedTaskWatchdogs.get(taskId);
+        if (!handle) return;
+        clearTimeout(handle);
+        this.completedTaskWatchdogs.delete(taskId);
+      }
+      clearWorkflowRerunWatchdog(taskId) {
+        const handle = this.workflowRerunWatchdogs.get(taskId);
+        if (!handle) return;
+        clearTimeout(handle);
+        this.workflowRerunWatchdogs.delete(taskId);
+      }
+      scheduleCompletedTaskWatchdog(taskId, trigger) {
+        this.clearCompletedTaskWatchdog(taskId);
+        const handle = setTimeout(async () => {
+          this.completedTaskWatchdogs.delete(taskId);
+          let currentTask = null;
+          try {
+            currentTask = await this.store.getTask(taskId);
+          } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            executorLog.warn(`${taskId}: completed-task watchdog could not read latest task state: ${errorMessage}`);
+            return;
+          }
+          if (!currentTask || currentTask.column !== "in-progress" || currentTask.paused) {
+            return;
+          }
+          if (this.activeSessions.has(taskId) || this.activeStepExecutors.has(taskId) || this.recoveringCompleted.has(taskId)) {
+            return;
+          }
+          if (!this.isTaskWorkComplete(currentTask)) {
+            return;
+          }
+          executorLog.warn(
+            `${taskId}: completed-task watchdog fired after ${COMPLETED_TASK_WATCHDOG_MS / 1e3}s (${trigger}) \u2014 attempting direct recovery to in-review`
+          );
+          await this.store.logEntry(
+            taskId,
+            `Watchdog: task remained in-progress ${COMPLETED_TASK_WATCHDOG_MS / 1e3}s after ${trigger} \u2014 attempting direct recovery to in-review`
+          ).catch(() => void 0);
+          this.recoveringCompleted.add(taskId);
+          try {
+            const recovered = await this.recoverCompletedTask(currentTask);
+            if (!recovered) {
+              await this.store.logEntry(
+                taskId,
+                "Watchdog recovery attempt could not finalize completed task \u2014 leaving for follow-up recovery"
+              ).catch(() => void 0);
+            }
+          } finally {
+            this.recoveringCompleted.delete(taskId);
+          }
+        }, COMPLETED_TASK_WATCHDOG_MS);
+        this.completedTaskWatchdogs.set(taskId, handle);
+      }
+      async performWorkflowRerunBounce(taskId, worktreePath) {
+        const latestTask = await this.store.getTask(taskId);
+        if (!latestTask) {
+          throw new Error("task missing during workflow rerun bounce");
+        }
+        if (latestTask.column === "in-progress") {
+          await this.store.moveTask(taskId, "todo");
+          await this.store.updateTask(taskId, { worktree: worktreePath });
+          await this.store.moveTask(taskId, "in-progress");
+          return;
+        }
+        if (latestTask.column === "todo") {
+          await this.store.updateTask(taskId, { worktree: worktreePath });
+          await this.store.moveTask(taskId, "in-progress");
+          return;
+        }
+        throw new Error(`task is in '${latestTask.column}', cannot bounce to in-progress`);
+      }
+      scheduleWorkflowRerun(taskId, worktreePath, successMessage) {
+        this.clearWorkflowRerunWatchdog(taskId);
+        setTimeout(async () => {
+          try {
+            await this.performWorkflowRerunBounce(taskId, worktreePath);
+            executorLog.log(successMessage);
+          } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            executorLog.error(`${taskId}: failed to schedule rerun bounce: ${errorMessage}`);
+          }
+        }, 0);
+        const watchdog = setTimeout(async () => {
+          this.workflowRerunWatchdogs.delete(taskId);
+          let currentTask = null;
+          try {
+            currentTask = await this.store.getTask(taskId);
+          } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            executorLog.warn(`${taskId}: workflow rerun watchdog could not read latest task state: ${errorMessage}`);
+            return;
+          }
+          if (!currentTask || currentTask.paused || currentTask.column === "in-progress") {
+            return;
+          }
+          executorLog.warn(
+            `${taskId}: workflow rerun watchdog fired after ${WORKFLOW_RERUN_WATCHDOG_MS / 1e3}s \u2014 task is still ${currentTask.column}; retrying handoff once`
+          );
+          await this.store.logEntry(
+            taskId,
+            `Watchdog: workflow rerun handoff stalled for ${WORKFLOW_RERUN_WATCHDOG_MS / 1e3}s (still ${currentTask.column}) \u2014 retrying once`
+          ).catch(() => void 0);
+          try {
+            await this.performWorkflowRerunBounce(taskId, worktreePath);
+            executorLog.warn(`${taskId}: workflow rerun watchdog retry succeeded`);
+          } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            executorLog.error(`${taskId}: workflow rerun watchdog retry failed: ${errorMessage}`);
+          }
+        }, WORKFLOW_RERUN_WATCHDOG_MS);
+        this.workflowRerunWatchdogs.set(taskId, watchdog);
+      }
       async shouldFinalizeCompletedTask(taskId, taskDone) {
         const task = await this.store.getTask(taskId);
         const completionBlocker = await this.getTaskCompletionBlocker(task);
@@ -61013,6 +61279,7 @@ Lint, tests, and typecheck are also hard quality gates:
           }
           await this.persistTokenUsage(task.id);
           await this.store.moveTask(task.id, "in-review");
+          this.clearCompletedTaskWatchdog(task.id);
           await this.store.logEntry(task.id, "Auto-recovered: task work was complete but stuck in in-progress \u2014 moved to in-review");
           executorLog.log(`\u2713 ${task.id} auto-recovered completed task \u2192 in-review`);
           this.options.onComplete?.(task);
@@ -61509,6 +61776,7 @@ Lint, tests, and typecheck are also hard quality gates:
                   executorLog.log(`${task.id}: captured ${modifiedFiles.length} modified files`);
                   await audit.filesystem({ type: "file:capture-modified", target: task.id, metadata: { files: modifiedFiles } });
                 }
+                this.scheduleCompletedTaskWatchdog(task.id, "step-session completion");
                 if (executionMode !== "fast") {
                   const workflowResult = await this.runWorkflowSteps(task, worktreePath, settings);
                   if (!workflowResult.allPassed) {
@@ -61529,6 +61797,7 @@ Lint, tests, and typecheck are also hard quality gates:
                 }
                 await this.store.updateTask(task.id, { workflowStepRetries: void 0, taskDoneRetryCount: null });
                 await this.store.moveTask(task.id, "in-review");
+                this.clearCompletedTaskWatchdog(task.id);
                 await audit.database({ type: "task:move", target: task.id, metadata: { to: "in-review" } });
                 executorLog.log(`\u2713 ${task.id} completed (step-session) \u2192 in-review`);
                 this.options.onComplete?.(task);
@@ -61865,6 +62134,7 @@ Lint, tests, and typecheck are also hard quality gates:
                   await this.store.logEntry(task.id, "Execution paused after completion \u2014 finalizing to in-review");
                   await this.persistTokenUsage(task.id);
                   await this.store.moveTask(task.id, "in-review");
+                  this.clearCompletedTaskWatchdog(task.id);
                   this.options.onComplete?.(task);
                 } else {
                   executorLog.log(`${task.id} paused (graceful session exit) \u2014 moving to todo`);
@@ -61885,6 +62155,7 @@ Lint, tests, and typecheck are also hard quality gates:
                   taskDone = true;
                   executorLog.log(`${task.id} all steps done \u2014 treating as implicit fn_task_done`);
                   await this.store.logEntry(task.id, "All steps complete \u2014 implicit fn_task_done (agent did not call tool explicitly)", void 0, this.currentRunContext);
+                  this.scheduleCompletedTaskWatchdog(task.id, "implicit fn_task_done");
                 }
               }
               if (taskDone) {
@@ -61894,6 +62165,7 @@ Lint, tests, and typecheck are also hard quality gates:
                   await this.store.updateTask(task.id, { modifiedFiles });
                   executorLog.log(`${task.id}: captured ${modifiedFiles.length} modified files`);
                 }
+                this.scheduleCompletedTaskWatchdog(task.id, "task completion");
                 if (executionMode !== "fast") {
                   const workflowResult = await this.runWorkflowSteps(task, worktreePath, settings);
                   if (!workflowResult.allPassed) {
@@ -61915,6 +62187,7 @@ Lint, tests, and typecheck are also hard quality gates:
                 await this.store.updateTask(task.id, { workflowStepRetries: void 0, taskDoneRetryCount: null });
                 await this.persistTokenUsage(task.id);
                 await this.store.moveTask(task.id, "in-review");
+                this.clearCompletedTaskWatchdog(task.id);
                 executorLog.log(`\u2713 ${task.id} completed \u2192 in-review`);
                 this.options.onComplete?.(task);
               } else {
@@ -61988,6 +62261,7 @@ Lint, tests, and typecheck are also hard quality gates:
                       taskDone = true;
                       executorLog.log(`${task.id} all steps done \u2014 treating as implicit fn_task_done`);
                       await this.store.logEntry(task.id, "All steps complete \u2014 implicit fn_task_done (agent did not call tool explicitly)", void 0, this.currentRunContext);
+                      this.scheduleCompletedTaskWatchdog(task.id, "implicit fn_task_done");
                     }
                   }
                 }
@@ -61998,6 +62272,7 @@ Lint, tests, and typecheck are also hard quality gates:
                     await this.store.updateTask(task.id, { modifiedFiles });
                     executorLog.log(`${task.id}: captured ${modifiedFiles.length} modified files`);
                   }
+                  this.scheduleCompletedTaskWatchdog(task.id, "task completion retry");
                   if (executionMode !== "fast") {
                     const workflowResult = await this.runWorkflowSteps(task, worktreePath, settings);
                     if (!workflowResult.allPassed) {
@@ -62015,6 +62290,7 @@ Lint, tests, and typecheck are also hard quality gates:
                   await this.store.updateTask(task.id, { workflowStepRetries: void 0, taskDoneRetryCount: null });
                   await this.persistTokenUsage(task.id);
                   await this.store.moveTask(task.id, "in-review");
+                  this.clearCompletedTaskWatchdog(task.id);
                   executorLog.log(`\u2713 ${task.id} completed on retry \u2192 in-review`);
                   this.options.onComplete?.(task);
                 } else {
@@ -62442,6 +62718,7 @@ Lint, tests, and typecheck are also hard quality gates:
               await store.updateTask(taskId, { summary: params.summary });
             }
             await store.logEntry(taskId, "Task marked done by agent");
+            this.scheduleCompletedTaskWatchdog(taskId, "fn_task_done");
             const successMessage = params.summary ? "Task marked complete with summary. All steps done. Moving to in-review." : "Task marked complete. All steps done. Moving to in-review.";
             return {
               content: [{ type: "text", text: successMessage }],
@@ -62668,6 +62945,7 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
        */
       async handleWorkflowRevisionRequest(task, worktreePath, feedback, stepName) {
         executorLog.log(`${task.id}: workflow revision requested by step "${stepName}"`);
+        this.clearCompletedTaskWatchdog(task.id);
         const updatedTask = await this.store.getTask(task.id);
         const reopen = await this.reopenLastStepForRevision(task.id, updatedTask);
         const reopenSummary = reopen ? `re-opening Step ${reopen.index + 1} ("${reopen.name}") for in-place fix` : "no step to re-open (none were completed)";
@@ -62682,21 +62960,11 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
           sessionFile: null
         });
         executorLog.log(`${task.id}: scheduling fresh execution after revision request`);
-        setTimeout(async () => {
-          try {
-            await this.store.moveTask(task.id, "todo");
-            await this.store.updateTask(task.id, { worktree: worktreePath });
-            await this.store.moveTask(task.id, "in-progress");
-            executorLog.log(`${task.id}: revision rerun scheduled \u2014 moved to todo then in-progress`);
-          } catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            executorLog.error(`${task.id}: failed to schedule revision rerun: ${errorMessage}`);
-            await this.store.logEntry(
-              task.id,
-              "Workflow revision requested \u2014 executor ready for fresh execution"
-            );
-          }
-        }, 0);
+        this.scheduleWorkflowRerun(
+          task.id,
+          worktreePath,
+          `${task.id}: revision rerun scheduled \u2014 moved to todo then in-progress`
+        );
       }
       /**
        * Re-open the last non-pending step so a revision/failure handler gives the
@@ -62783,6 +63051,7 @@ ${feedback}
        * @returns true if a retry was scheduled, false if retries are exhausted
        */
       async handleWorkflowStepFailure(task, worktreePath, failureFeedback, stepName) {
+        this.clearCompletedTaskWatchdog(task.id);
         const currentRetries = task.workflowStepRetries ?? 0;
         if (currentRetries >= MAX_WORKFLOW_STEP_RETRIES) {
           executorLog.warn(`${task.id}: workflow step "${stepName}" failed \u2014 retries exhausted (${MAX_WORKFLOW_STEP_RETRIES}/${MAX_WORKFLOW_STEP_RETRIES})`);
@@ -62801,21 +63070,11 @@ ${feedback}
           sessionFile: null
         });
         executorLog.log(`${task.id}: scheduling fresh execution after workflow step failure (retry ${retryCount}/${MAX_WORKFLOW_STEP_RETRIES})`);
-        setTimeout(async () => {
-          try {
-            await this.store.moveTask(task.id, "todo");
-            await this.store.updateTask(task.id, { worktree: worktreePath });
-            await this.store.moveTask(task.id, "in-progress");
-            executorLog.log(`${task.id}: workflow step retry scheduled \u2014 moved to todo then in-progress`);
-          } catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            executorLog.error(`${task.id}: failed to schedule workflow step retry: ${errorMessage}`);
-            await this.store.logEntry(
-              task.id,
-              "Workflow step failed \u2014 executor ready for fresh execution"
-            );
-          }
-        }, 0);
+        this.scheduleWorkflowRerun(
+          task.id,
+          worktreePath,
+          `${task.id}: workflow step retry scheduled \u2014 moved to todo then in-progress`
+        );
         return true;
       }
       /**
@@ -62825,6 +63084,7 @@ ${feedback}
        */
       async sendTaskBackForFix(task, worktreePath, failureFeedback, stepName, reason) {
         const taskId = task.id;
+        this.clearCompletedTaskWatchdog(taskId);
         await this.store.addTaskComment(
           taskId,
           `${reason}. The failing workflow step was "${stepName}". Feedback:
@@ -62846,17 +63106,11 @@ Please fix the issues so the verification can pass on the next attempt.`,
           sessionFile: null,
           workflowStepRetries: 0
         });
-        setTimeout(async () => {
-          try {
-            await this.store.moveTask(taskId, "todo");
-            await this.store.updateTask(taskId, { worktree: worktreePath });
-            await this.store.moveTask(taskId, "in-progress");
-            executorLog.log(`${taskId}: sent back to in-progress for remediation`);
-          } catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            executorLog.error(`${taskId}: failed to move back to in-progress: ${errorMessage}`);
-          }
-        }, 0);
+        this.scheduleWorkflowRerun(
+          taskId,
+          worktreePath,
+          `${taskId}: sent back to in-progress for remediation`
+        );
       }
       /**
        * Inject or update the "Workflow Step Failure" section in PROMPT.md.
@@ -63407,7 +63661,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
               );
             }
             const delay2 = this.WORKTREE_RETRY_DELAYS[attempt] || 1e3;
-            await new Promise((resolve36) => setTimeout(resolve36, delay2));
+            await new Promise((resolve39) => setTimeout(resolve39, delay2));
           }
         }
         throw new Error("Unexpected exit from worktree creation retry loop");
@@ -72731,13 +72985,13 @@ var init_plugin_runner = __esm({
        * Returns the result on success, throws on timeout.
        */
       withTimeout(promise, ms, timeoutMessage) {
-        return new Promise((resolve36, reject2) => {
+        return new Promise((resolve39, reject2) => {
           const timer = setTimeout(() => {
             reject2(new Error(timeoutMessage));
           }, ms);
           promise.then((result) => {
             clearTimeout(timer);
-            resolve36(result);
+            resolve39(result);
           }).catch((err) => {
             clearTimeout(timer);
             reject2(err);
@@ -73406,7 +73660,7 @@ var init_in_process_runtime = __esm({
             runtimeLog.log(
               `Waiting for ${metrics.inFlightTasks} in-flight tasks to complete...`
             );
-            await new Promise((resolve36) => setTimeout(resolve36, 1e3));
+            await new Promise((resolve39) => setTimeout(resolve39, 1e3));
           }
           const finalMetrics = this.getMetrics();
           if (finalMetrics.inFlightTasks > 0) {
@@ -73803,13 +74057,13 @@ var init_ipc_host = __esm({
         }
         const id = generateCorrelationId();
         const message = { type, id, payload };
-        return new Promise((resolve36, reject2) => {
+        return new Promise((resolve39, reject2) => {
           const timeout2 = setTimeout(() => {
             this.pendingCommands.delete(id);
             reject2(new Error(`Command ${type} timed out after ${timeoutMs ?? this.commandTimeoutMs}ms`));
           }, timeoutMs ?? this.commandTimeoutMs);
           this.pendingCommands.set(id, {
-            resolve: resolve36,
+            resolve: resolve39,
             reject: reject2,
             timeout: timeout2,
             type
@@ -74618,8 +74872,8 @@ var init_remote_node_client = __esm({
         return error instanceof TypeError;
       }
       async sleep(ms) {
-        await new Promise((resolve36) => {
-          setTimeout(resolve36, ms);
+        await new Promise((resolve39) => {
+          setTimeout(resolve39, ms);
         });
       }
     };
@@ -74883,14 +75137,14 @@ var init_remote_node_runtime = __esm({
         return error instanceof Error ? error : new Error(String(error));
       }
       async sleep(ms, signal) {
-        await new Promise((resolve36) => {
+        await new Promise((resolve39) => {
           const timeout2 = setTimeout(() => {
             cleanup();
-            resolve36();
+            resolve39();
           }, ms);
           const onAbort = () => {
             cleanup();
-            resolve36();
+            resolve39();
           };
           const cleanup = () => {
             clearTimeout(timeout2);
@@ -75777,10 +76031,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((resolve36) => {
+        this.activeStopPromise = new Promise((resolve39) => {
           const onClose = () => {
             currentHandle.child.removeListener("close", onClose);
-            resolve36();
+            resolve39();
           };
           currentHandle.child.once("close", onClose);
           killManagedProcess(currentHandle.child, "SIGTERM");
@@ -76336,12 +76590,12 @@ ${detail}`
        */
       async onMerge(taskId) {
         if (this.mergeActive.has(taskId)) {
-          return new Promise((resolve36, reject2) => {
-            this.manualMergeResolvers.set(taskId, { resolve: resolve36, reject: reject2 });
+          return new Promise((resolve39, reject2) => {
+            this.manualMergeResolvers.set(taskId, { resolve: resolve39, reject: reject2 });
           });
         }
-        return new Promise((resolve36, reject2) => {
-          this.manualMergeResolvers.set(taskId, { resolve: resolve36, reject: reject2 });
+        return new Promise((resolve39, reject2) => {
+          this.manualMergeResolvers.set(taskId, { resolve: resolve39, reject: reject2 });
           this.internalEnqueueMerge(taskId);
         });
       }
@@ -82211,7 +82465,7 @@ function hermesProfileHome(profileName) {
 async function listHermesProfiles(opts) {
   const binary = resolveBinaryForSpawn(opts?.binaryPath ?? "hermes");
   const timeoutMs = opts?.timeoutMs ?? 5e3;
-  return new Promise((resolve36, reject2) => {
+  return new Promise((resolve39, reject2) => {
     let settled = false;
     const child = spawn4(binary, ["profile", "list"], {
       stdio: ["ignore", "pipe", "pipe"],
@@ -82254,7 +82508,7 @@ async function listHermesProfiles(opts) {
 ${combined}`));
         return;
       }
-      resolve36(parseProfileListOutput(stdout));
+      resolve39(parseProfileListOutput(stdout));
     });
   });
 }
@@ -82331,7 +82585,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((resolve36, reject2) => {
+  return new Promise((resolve39, reject2) => {
     let settled = false;
     const spawnEnv = { ...process.env, PYTHONUNBUFFERED: "1" };
     if (settings.profile) {
@@ -82399,7 +82653,7 @@ ${combined}`));
         return;
       }
       try {
-        resolve36(parseHermesOutput(stdout, stderr));
+        resolve39(parseHermesOutput(stdout, stderr));
       } catch (parseErr) {
         reject2(parseErr);
       }
@@ -82717,7 +82971,7 @@ async function promptCli(session, message, config, callbacks, signal) {
   const args = buildOpenClawArgs(config, session.sessionId, message);
   const cb = { ...session.callbacks, ...callbacks };
   cb.onToolStart?.("openclaw.agent", { sessionId: session.sessionId });
-  return new Promise((resolve36, reject2) => {
+  return new Promise((resolve39, reject2) => {
     let settled = false;
     const child = spawn6(config.binaryPath, args, {
       stdio: ["ignore", "pipe", "pipe"]
@@ -82810,7 +83064,7 @@ async function promptCli(session, message, config, callbacks, signal) {
         ...metaError ? { error: metaError } : {},
         ...errorText.length > 0 ? { toolErrors: errorText } : {}
       });
-      resolve36();
+      resolve39();
     });
   });
 }
@@ -83552,10 +83806,10 @@ function registerTaskWorkflowRoutes(ctx, deps) {
         nextRecoveryAt: null
       });
       if (retrySpecification) {
-        const { rm: rm5 } = await import("node:fs/promises");
+        const { rm: rm6 } = await import("node:fs/promises");
         const { join: join65 } = await import("node:path");
         const promptPath = join65(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
-        await rm5(promptPath, { force: true });
+        await rm6(promptPath, { force: true });
         await scopedStore.logEntry(req.params.id, "Retry requested from dashboard (planning retry budget reset)");
         const updated2 = await scopedStore.getTask(req.params.id);
         res.json(updated2);
@@ -83975,10 +84229,10 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       }
       await scopedStore.logEntry(task.id, "Plan rejected by user", "Specification will be regenerated");
       await scopedStore.updateTask(task.id, { status: void 0 });
-      const { rm: rm5 } = await import("node:fs/promises");
+      const { rm: rm6 } = await import("node:fs/promises");
       const { join: join65 } = await import("node:path");
       const promptPath = join65(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
-      await rm5(promptPath, { force: true });
+      await rm6(promptPath, { force: true });
       const updated = await scopedStore.getTask(task.id);
       res.json(updated);
     } catch (err) {
@@ -84246,10 +84500,10 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       const task = await scopedStore.getTask(req.params.id);
       if (task.column === "triage") {
         await scopedStore.logEntry(task.id, "AI spec revision requested", feedback);
-        const { rm: rm6 } = await import("node:fs/promises");
+        const { rm: rm7 } = await import("node:fs/promises");
         const { join: join66 } = await import("node:path");
         const promptPath2 = join66(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
-        await rm6(promptPath2, { force: true });
+        await rm7(promptPath2, { force: true });
         await scopedStore.updateTask(task.id, { status: "needs-replan" });
         const updated2 = await scopedStore.getTask(task.id);
         res.json(updated2);
@@ -84263,10 +84517,10 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       }
       await scopedStore.logEntry(task.id, "AI spec revision requested", feedback);
       const updated = await scopedStore.moveTask(task.id, "triage");
-      const { rm: rm5 } = await import("node:fs/promises");
+      const { rm: rm6 } = await import("node:fs/promises");
       const { join: join65 } = await import("node:path");
       const promptPath = join65(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
-      await rm5(promptPath, { force: true });
+      await rm6(promptPath, { force: true });
       await scopedStore.updateTask(task.id, { status: "needs-replan" });
       res.json(updated);
     } catch (err) {
@@ -84284,10 +84538,10 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       const task = await scopedStore.getTask(req.params.id);
       if (task.column === "triage") {
         await scopedStore.logEntry(task.id, "Specification rebuild requested by user");
-        const { rm: rm6 } = await import("node:fs/promises");
+        const { rm: rm7 } = await import("node:fs/promises");
         const { join: join66 } = await import("node:path");
         const promptPath2 = join66(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
-        await rm6(promptPath2, { force: true });
+        await rm7(promptPath2, { force: true });
         await scopedStore.updateTask(task.id, { status: "needs-replan" });
         const updated2 = await scopedStore.getTask(task.id);
         res.json(updated2);
@@ -84299,10 +84553,10 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       }
       await scopedStore.logEntry(task.id, "Specification rebuild requested by user");
       const updated = await scopedStore.moveTask(task.id, "triage");
-      const { rm: rm5 } = await import("node:fs/promises");
+      const { rm: rm6 } = await import("node:fs/promises");
       const { join: join65 } = await import("node:path");
       const promptPath = join65(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
-      await rm5(promptPath, { force: true });
+      await rm6(promptPath, { force: true });
       await scopedStore.updateTask(task.id, { status: "needs-replan" });
       res.json(updated);
     } catch (err) {
@@ -85582,6 +85836,11 @@ async function ensureEngineReady5() {
   } catch {
   }
 }
+function formatAttachmentSize(size) {
+  if (size < 1024) return `${size}B`;
+  if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}KB`;
+  return `${(size / (1024 * 1024)).toFixed(1)}MB`;
+}
 function validateFilePath(basePath, filePath) {
   if (filePath.includes("\0")) {
     throw new Error(`Access denied: Invalid characters in path`);
@@ -85911,7 +86170,7 @@ var init_chat = __esm({
        * @param modelProvider - Optional model provider override
        * @param modelId - Optional model ID override
        */
-      async sendMessage(sessionId, content, modelProvider, modelId) {
+      async sendMessage(sessionId, content, modelProvider, modelId, attachments) {
         const abortController = new AbortController();
         this.activeGenerations.set(sessionId, { abortController });
         const session = this.chatStore.getSession(sessionId);
@@ -85935,7 +86194,8 @@ var init_chat = __esm({
             this.chatStore.addMessage(sessionId, {
               role: "user",
               content,
-              metadata: mentions.length > 0 ? { mentions } : void 0
+              metadata: mentions.length > 0 ? { mentions } : void 0,
+              attachments
             });
           } catch (err) {
             chatStreamManager.broadcast(sessionId, {
@@ -86012,6 +86272,7 @@ ${mentionContext}`;
             (message) => message.role === "user" || message.role === "assistant"
           );
           const resolvedContent = await resolveFileReferences(content, this.rootDir);
+          const attachmentSummary = attachments && attachments.length > 0 ? `[User attached: ${attachments.map((attachment) => `${attachment.originalName} (${attachment.mimeType}, ${formatAttachmentSize(attachment.size)})`).join(", ")}]` : "";
           const promptContent = conversationMessages.length > 0 ? [
             "## Previous Conversation",
             "",
@@ -86022,8 +86283,9 @@ ${mentionContext}`;
             "",
             "## Current Message",
             "",
+            attachmentSummary,
             resolvedContent
-          ].join("\n") : resolvedContent;
+          ].filter(Boolean).join("\n") : [attachmentSummary, resolvedContent].filter(Boolean).join("\n\n");
           agentResult = await createFnAgent8({
             cwd: this.rootDir,
             systemPrompt,
@@ -86100,7 +86362,7 @@ ${mentionContext}`;
           });
           chatStreamManager.broadcast(sessionId, {
             type: "done",
-            data: { messageId: assistantMessage.id }
+            data: { messageId: assistantMessage.id, attachments }
           });
         } catch (err) {
           if (abortController.signal.aborted) {
@@ -86166,9 +86428,36 @@ ${mentionContext}`;
 });
 
 // ../dashboard/src/routes/register-chat-routes.ts
+import { randomUUID as randomUUID15 } from "node:crypto";
+import { createReadStream as createReadStream2 } from "node:fs";
+import { mkdir as mkdir12, rm as rm2, writeFile as writeFile12 } from "node:fs/promises";
+import { basename as basename9, join as join37, resolve as resolve17 } from "node:path";
+function resolveAttachmentPath(rootDir, sessionId, filename) {
+  const sessionDir = resolve17(rootDir, ".fusion", "chat-attachments", sessionId);
+  const safeName = basename9(filename);
+  const filePath = resolve17(sessionDir, safeName);
+  if (!filePath.startsWith(`${sessionDir}/`) && filePath !== sessionDir) {
+    throw badRequest("Invalid attachment path");
+  }
+  return { sessionDir, filePath };
+}
 function registerChatRoutes(ctx, deps) {
   const { router, options, getProjectContext: getProjectContext3, chatLogger, rethrowAsApiError: rethrowAsApiError7 } = ctx;
-  const { parseLastEventId: parseLastEventId3, validateOptionalModelField: validateOptionalModelField2 } = deps;
+  const { parseLastEventId: parseLastEventId3, validateOptionalModelField: validateOptionalModelField2, upload: upload2 } = deps;
+  const uploadChatAttachment = (req, res, next) => {
+    upload2.single("file")(req, res, (err) => {
+      if (!err) {
+        next();
+        return;
+      }
+      const multerError = err;
+      if (multerError?.code === "LIMIT_FILE_SIZE") {
+        next(badRequest(`File too large. Maximum: ${CHAT_MAX_ATTACHMENT_SIZE} bytes (5MB)`));
+        return;
+      }
+      next(err);
+    });
+  };
   router.get("/chat/sessions", rateLimit(RATE_LIMITS.api), async (req, res) => {
     try {
       const chatStore = options?.chatStore;
@@ -86368,6 +86657,84 @@ function registerChatRoutes(ctx, deps) {
       rethrowAsApiError7(err, "Failed to get chat messages");
     }
   });
+  router.post("/chat/sessions/:id/attachments", rateLimit(RATE_LIMITS.mutation), uploadChatAttachment, async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) {
+        throw internalError("Chat store not available");
+      }
+      const sessionId = String(req.params.id);
+      const session = chatStore.getSession(sessionId);
+      if (!session) {
+        throw notFound(`Chat session ${sessionId} not found`);
+      }
+      const file = req.file;
+      if (!file) {
+        throw badRequest("file is required");
+      }
+      if (!CHAT_ALLOWED_MIME_TYPES.has(file.mimetype)) {
+        throw badRequest(`Invalid mime type '${file.mimetype}'`);
+      }
+      if (file.size > CHAT_MAX_ATTACHMENT_SIZE) {
+        throw badRequest(`File too large (${file.size} bytes). Maximum: ${CHAT_MAX_ATTACHMENT_SIZE} bytes (5MB)`);
+      }
+      const { store: scopedStore } = await getProjectContext3(req);
+      const rootDir = scopedStore.getRootDir();
+      const sessionDir = resolve17(rootDir, ".fusion", "chat-attachments", sessionId);
+      await mkdir12(sessionDir, { recursive: true });
+      const sanitizedFilename = (file.originalname || "attachment").replace(/[^a-zA-Z0-9._-]/g, "_");
+      const filename = `${Date.now()}-${sanitizedFilename}`;
+      const filePath = join37(sessionDir, filename);
+      await writeFile12(filePath, file.buffer);
+      const attachment = {
+        id: `att-${randomUUID15().slice(0, 8)}`,
+        filename,
+        originalName: file.originalname,
+        mimeType: file.mimetype,
+        size: file.size,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      res.status(201).json({ attachment });
+    } catch (err) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError7(err, "Failed to upload chat attachment");
+    }
+  });
+  router.get("/chat/sessions/:id/attachments/:filename", async (req, res) => {
+    try {
+      const { store: scopedStore } = await getProjectContext3(req);
+      const rootDir = scopedStore.getRootDir();
+      const { filePath } = resolveAttachmentPath(rootDir, String(req.params.id), String(req.params.filename));
+      const stream = createReadStream2(filePath);
+      stream.on("error", () => {
+        if (!res.headersSent) {
+          res.status(404).json({ error: "Attachment not found" });
+        } else {
+          res.end();
+        }
+      });
+      res.setHeader("Content-Type", "application/octet-stream");
+      stream.pipe(res);
+    } catch (err) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError7(err, "Failed to fetch chat attachment");
+    }
+  });
+  router.delete("/chat/sessions/:id/attachments/:filename", rateLimit(RATE_LIMITS.mutation), async (req, res) => {
+    try {
+      const { store: scopedStore } = await getProjectContext3(req);
+      const rootDir = scopedStore.getRootDir();
+      const { filePath } = resolveAttachmentPath(rootDir, String(req.params.id), String(req.params.filename));
+      await rm2(filePath);
+      res.json({ success: true });
+    } catch (err) {
+      if (err?.code === "ENOENT") {
+        throw notFound("Attachment not found");
+      }
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError7(err, "Failed to delete chat attachment");
+    }
+  });
   router.post("/chat/sessions/:id/messages", rateLimit(RATE_LIMITS.sse), async (req, res) => {
     try {
       const chatStore = options?.chatStore;
@@ -86375,7 +86742,7 @@ function registerChatRoutes(ctx, deps) {
       if (!chatStore || !chatManager) {
         throw internalError("Chat store or manager not available");
       }
-      const { content, modelProvider, modelId } = req.body;
+      const { content, modelProvider, modelId, attachments } = req.body;
       const sessionId = String(req.params.id);
       if (!content || typeof content !== "string" || !content.trim()) {
         throw badRequest("content is required and must be a non-empty string");
@@ -86449,7 +86816,8 @@ function registerChatRoutes(ctx, deps) {
         sessionId,
         content.trim(),
         normalizedProvider,
-        normalizedModelId
+        normalizedModelId,
+        Array.isArray(attachments) ? attachments : void 0
       ).catch((err) => {
         chatLogger.error("Error in sendMessage", {
           error: err.message
@@ -86518,6 +86886,9 @@ function registerChatRoutes(ctx, deps) {
       "PATCH /chat/sessions/:id",
       "DELETE /chat/sessions/:id",
       "GET /chat/sessions/:id/messages",
+      "POST /chat/sessions/:id/attachments",
+      "GET /chat/sessions/:id/attachments/:filename",
+      "DELETE /chat/sessions/:id/attachments/:filename",
       "POST /chat/sessions/:id/messages",
       "POST /chat/sessions/:id/cancel",
       "DELETE /chat/sessions/:id/messages/:messageId"
@@ -86525,12 +86896,26 @@ function registerChatRoutes(ctx, deps) {
     chatLogger.info("routes registered", { chatRoutes });
   }
 }
+var CHAT_ALLOWED_MIME_TYPES, CHAT_MAX_ATTACHMENT_SIZE;
 var init_register_chat_routes = __esm({
   "../dashboard/src/routes/register-chat-routes.ts"() {
     "use strict";
     init_api_error();
     init_rate_limit();
     init_sse_buffer();
+    CHAT_ALLOWED_MIME_TYPES = /* @__PURE__ */ new Set([
+      "image/png",
+      "image/jpeg",
+      "image/gif",
+      "image/webp",
+      "text/plain",
+      "application/json",
+      "text/yaml",
+      "text/x-toml",
+      "text/csv",
+      "application/xml"
+    ]);
+    CHAT_MAX_ATTACHMENT_SIZE = 5 * 1024 * 1024;
   }
 });
 
@@ -87879,7 +88264,7 @@ import * as os3 from "os";
 import * as path2 from "path";
 import * as fs from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { join as join37, dirname as dirname10 } from "node:path";
+import { join as join38, dirname as dirname10 } from "node:path";
 function getNativePrebuildName() {
   const platform3 = process.platform === "darwin" ? "darwin" : process.platform === "linux" ? "linux" : process.platform === "win32" ? "win32" : "unknown";
   const arch = process.arch === "arm64" ? "arm64" : process.arch === "x64" ? "x64" : "unknown";
@@ -87889,12 +88274,12 @@ function findInstalledNodePtyNativeDir() {
   try {
     const packageJsonPath = require2.resolve("node-pty/package.json");
     const pkgRoot = dirname10(packageJsonPath);
-    const releaseDir = join37(pkgRoot, "build", "Release");
-    if (fs.existsSync(join37(releaseDir, "pty.node"))) {
+    const releaseDir = join38(pkgRoot, "build", "Release");
+    if (fs.existsSync(join38(releaseDir, "pty.node"))) {
       return releaseDir;
     }
-    const prebuildDir = join37(pkgRoot, "prebuilds", getNativePrebuildName());
-    if (fs.existsSync(join37(prebuildDir, "pty.node"))) {
+    const prebuildDir = join38(pkgRoot, "prebuilds", getNativePrebuildName());
+    if (fs.existsSync(join38(prebuildDir, "pty.node"))) {
       return prebuildDir;
     }
     return null;
@@ -87920,8 +88305,8 @@ function ensureNodePtyNativePermissions() {
     candidateDirs.add(installedNativeDir);
   }
   for (const nativeDir of candidateDirs) {
-    const helperPath = join37(nativeDir, "spawn-helper");
-    const nativeModulePath = join37(nativeDir, "pty.node");
+    const helperPath = join38(nativeDir, "spawn-helper");
+    const nativeModulePath = join38(nativeDir, "pty.node");
     try {
       fs.chmodSync(helperPath, 493);
     } catch {
@@ -87939,14 +88324,14 @@ function ensureNodePtyNativePermissions() {
 function findStagedNativeDir() {
   const prebuildName = getNativePrebuildName();
   if (process.env.FUSION_RUNTIME_DIR) {
-    const envPath = join37(process.env.FUSION_RUNTIME_DIR, prebuildName);
-    if (fs.existsSync(join37(envPath, "pty.node"))) {
+    const envPath = join38(process.env.FUSION_RUNTIME_DIR, prebuildName);
+    if (fs.existsSync(join38(envPath, "pty.node"))) {
       return envPath;
     }
   }
   const execDir = dirname10(process.execPath);
-  const nextToBinary = join37(execDir, "runtime", prebuildName);
-  if (fs.existsSync(join37(nextToBinary, "pty.node"))) {
+  const nextToBinary = join38(execDir, "runtime", prebuildName);
+  if (fs.existsSync(join38(nextToBinary, "pty.node"))) {
     return nextToBinary;
   }
   return null;
@@ -87966,7 +88351,7 @@ async function loadPtyModule() {
         process.env.NODE_PTY_SPAWN_HELPER_DIR = nativeDir;
       }
       process.env.FUSION_NATIVE_ASSETS_PATH = nativeDir;
-      const nativePath = join37(nativeDir, "pty.node");
+      const nativePath = join38(nativeDir, "pty.node");
       if (fs.existsSync(nativePath)) {
         try {
           const nativeModule = { exports: {} };
@@ -88943,7 +89328,7 @@ var init_register_messaging_scripts = __esm({
 
 // ../dashboard/src/github.ts
 function delay(ms) {
-  return new Promise((resolve36) => setTimeout(resolve36, ms));
+  return new Promise((resolve39) => setTimeout(resolve39, ms));
 }
 function normalizeCheckState(state) {
   switch ((state ?? "").toLowerCase()) {
@@ -93302,7 +93687,7 @@ var init_register_git_github = __esm({
 
 // ../dashboard/src/terminal.ts
 import { spawn as spawn8 } from "node:child_process";
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 import { EventEmitter as EventEmitter31 } from "node:events";
 function extractBaseCommand(command) {
   let trimmed = command.trim();
@@ -93462,7 +93847,7 @@ var init_terminal = __esm({
         if (!validation.valid) {
           return { sessionId: "", error: validation.error };
         }
-        const sessionId = randomUUID15();
+        const sessionId = randomUUID16();
         const childProcess = spawn8(command, [], {
           cwd,
           shell: true,
@@ -93587,20 +93972,20 @@ var init_terminal = __esm({
 });
 
 // ../dashboard/src/file-service.ts
-import { join as join38, resolve as resolve18, relative as relative9, dirname as dirname11, basename as basename10 } from "node:path";
-import { readdir as readdir8, readFile as fsReadFile, writeFile as fsWriteFile, stat as stat7, copyFile as fsCopyFile, rename as fsRename, rm as fsRm, mkdir as mkdir12, access as access4 } from "node:fs/promises";
+import { join as join39, resolve as resolve19, relative as relative9, dirname as dirname11, basename as basename11 } from "node:path";
+import { readdir as readdir8, readFile as fsReadFile, writeFile as fsWriteFile, stat as stat7, copyFile as fsCopyFile, rename as fsRename, rm as fsRm, mkdir as mkdir13, access as access4 } from "node:fs/promises";
 async function getTaskBasePath(store, taskId) {
   try {
     const task = await store.getTask(taskId);
     if (task.worktree) {
       try {
         await access4(task.worktree);
-        return resolve18(task.worktree);
+        return resolve19(task.worktree);
       } catch {
       }
     }
     const rootDir = store.getRootDir();
-    return resolve18(join38(rootDir, ".fusion", "tasks", taskId));
+    return resolve19(join39(rootDir, ".fusion", "tasks", taskId));
   } catch (err) {
     const error = err;
     if (error.code === "ENOENT" || error.message && error.message.includes("not found")) {
@@ -93610,7 +93995,7 @@ async function getTaskBasePath(store, taskId) {
   }
 }
 function getProjectBasePath(store) {
-  return resolve18(store.getRootDir());
+  return resolve19(store.getRootDir());
 }
 async function getWorkspaceBasePath(store, workspace) {
   if (workspace === "project") {
@@ -93626,8 +94011,8 @@ function validatePath(basePath, filePath) {
   if (decodedPath.startsWith("/") || decodedPath.match(/^[a-zA-Z]:/)) {
     throw new FileServiceError(`Access denied: Absolute paths not allowed`, "EINVAL");
   }
-  const resolvedBase = resolve18(basePath);
-  const resolvedPath = resolve18(join38(resolvedBase, decodedPath));
+  const resolvedBase = resolve19(basePath);
+  const resolvedPath = resolve19(join39(resolvedBase, decodedPath));
   const relativePath = relative9(resolvedBase, resolvedPath);
   if (relativePath.startsWith("..") || relativePath.startsWith("../") || relativePath === "..") {
     throw new FileServiceError(`Access denied: Path traversal detected`, "EINVAL");
@@ -93656,7 +94041,7 @@ async function listFilesForBasePath(basePath, subPath) {
     const entries = await readdir8(targetPath, { withFileTypes: true });
     const fileNodes = [];
     for (const entry of entries) {
-      const entryPath = join38(targetPath, entry.name);
+      const entryPath = join39(targetPath, entry.name);
       const entryStats = await stat7(entryPath);
       fileNodes.push({
         name: entry.name,
@@ -93786,7 +94171,7 @@ async function readFile18(store, taskId, filePath) {
   const taskBase = await getTaskBasePath(store, taskId);
   return readFileForBasePath(taskBase, filePath);
 }
-async function writeFile12(store, taskId, filePath, content) {
+async function writeFile13(store, taskId, filePath, content) {
   const taskBase = await getTaskBasePath(store, taskId);
   return writeFileForBasePath(taskBase, filePath, content);
 }
@@ -93805,7 +94190,7 @@ async function writeWorkspaceFile(store, workspace, filePath, content) {
 function validateSourceAndDestination(basePath, sourcePath, destinationPath) {
   const resolvedSource = validatePath(basePath, sourcePath);
   const resolvedDest = validatePath(basePath, destinationPath);
-  const sourceRelative = relative9(resolve18(basePath), resolvedSource);
+  const sourceRelative = relative9(resolve19(basePath), resolvedSource);
   if (!sourceRelative || sourceRelative === "." || sourceRelative === "") {
     throw new FileServiceError("Cannot operate on workspace root directory", "EINVAL");
   }
@@ -93929,7 +94314,7 @@ async function deleteWorkspaceFile(store, workspace, filePath) {
   }
   const workspaceBase = await getWorkspaceBasePath(store, workspace);
   const resolvedPath = validatePath(workspaceBase, filePath);
-  const relativePath = relative9(resolve18(workspaceBase), resolvedPath);
+  const relativePath = relative9(resolve19(workspaceBase), resolvedPath);
   if (!relativePath || relativePath === "." || relativePath === "") {
     throw new FileServiceError("Cannot delete workspace root directory", "EINVAL");
   }
@@ -93970,7 +94355,7 @@ async function renameWorkspaceFile(store, workspace, filePath, newName) {
   }
   const workspaceBase = await getWorkspaceBasePath(store, workspace);
   const resolvedPath = validatePath(workspaceBase, filePath);
-  const relativePath = relative9(resolve18(workspaceBase), resolvedPath);
+  const relativePath = relative9(resolve19(workspaceBase), resolvedPath);
   if (!relativePath || relativePath === "." || relativePath === "") {
     throw new FileServiceError("Cannot rename workspace root directory", "EINVAL");
   }
@@ -93983,12 +94368,12 @@ async function renameWorkspaceFile(store, workspace, filePath, newName) {
     }
     throw err;
   }
-  const destPath = join38(dirname11(resolvedPath), newName);
-  const destRelative = relative9(resolve18(workspaceBase), destPath);
+  const destPath = join39(dirname11(resolvedPath), newName);
+  const destRelative = relative9(resolve19(workspaceBase), destPath);
   if (destRelative.startsWith("..") || destRelative.startsWith("../") || destRelative === "..") {
     throw new FileServiceError("Destination would be outside workspace", "EINVAL");
   }
-  if (!destPath.startsWith(resolve18(workspaceBase))) {
+  if (!destPath.startsWith(resolve19(workspaceBase))) {
     throw new FileServiceError("Destination would be outside workspace", "EINVAL");
   }
   try {
@@ -94017,7 +94402,7 @@ async function getWorkspaceFileForDownload(store, workspace, filePath) {
   }
   const workspaceBase = await getWorkspaceBasePath(store, workspace);
   const resolvedPath = validatePath(workspaceBase, filePath);
-  const relativePath = relative9(resolve18(workspaceBase), resolvedPath);
+  const relativePath = relative9(resolve19(workspaceBase), resolvedPath);
   if (!relativePath || relativePath === "." || relativePath === "") {
     throw new FileServiceError("Cannot download workspace root", "EINVAL");
   }
@@ -94041,7 +94426,7 @@ async function getWorkspaceFileForDownload(store, workspace, filePath) {
       mtime: stats.mtime,
       isFile: true
     },
-    fileName: basename10(resolvedPath)
+    fileName: basename11(resolvedPath)
   };
 }
 async function getWorkspaceFolderForZip(store, workspace, dirPath) {
@@ -94050,7 +94435,7 @@ async function getWorkspaceFolderForZip(store, workspace, dirPath) {
   }
   const workspaceBase = await getWorkspaceBasePath(store, workspace);
   const resolvedPath = validatePath(workspaceBase, dirPath);
-  const relativePath = relative9(resolve18(workspaceBase), resolvedPath);
+  const relativePath = relative9(resolve19(workspaceBase), resolvedPath);
   if (!relativePath || relativePath === "." || relativePath === "") {
     throw new FileServiceError("Cannot download workspace root as ZIP", "EINVAL");
   }
@@ -94069,14 +94454,14 @@ async function getWorkspaceFolderForZip(store, workspace, dirPath) {
   }
   return {
     absolutePath: resolvedPath,
-    dirName: basename10(resolvedPath)
+    dirName: basename11(resolvedPath)
   };
 }
 function isHiddenPathSegment(name) {
   return name.startsWith(".");
 }
 async function walkDirForMarkdown(basePath, currentRelative, results, options) {
-  const currentPath = currentRelative ? join38(basePath, currentRelative) : basePath;
+  const currentPath = currentRelative ? join39(basePath, currentRelative) : basePath;
   let entries;
   try {
     entries = await readdir8(currentPath, { withFileTypes: true });
@@ -94084,7 +94469,7 @@ async function walkDirForMarkdown(basePath, currentRelative, results, options) {
     return;
   }
   for (const entry of entries) {
-    const entryRelativePath = currentRelative ? join38(currentRelative, entry.name) : entry.name;
+    const entryRelativePath = currentRelative ? join39(currentRelative, entry.name) : entry.name;
     if (entry.isDirectory()) {
       if (MARKDOWN_SCAN_EXCLUDED_DIRS.has(entry.name)) {
         continue;
@@ -94101,7 +94486,7 @@ async function walkDirForMarkdown(basePath, currentRelative, results, options) {
     if (!options.showHidden && isHiddenPathSegment(entry.name)) {
       continue;
     }
-    const fullPath = join38(basePath, entryRelativePath);
+    const fullPath = join39(basePath, entryRelativePath);
     let fileStats;
     try {
       fileStats = await stat7(fullPath);
@@ -94151,7 +94536,7 @@ async function scanMarkdownFiles(store, options) {
       return;
     }
     for (const entry of entries) {
-      const entryRelativePath = relativeDir ? join38(relativeDir, entry.name) : entry.name;
+      const entryRelativePath = relativeDir ? join39(relativeDir, entry.name) : entry.name;
       let shouldRecurse = entry.isDirectory();
       if (!shouldRecurse && typeof entry.isSymbolicLink === "function" && entry.isSymbolicLink()) {
         let symlinkPath;
@@ -94241,8 +94626,8 @@ async function searchWorkspaceFiles(store, workspace, query) {
       if (entry.isDirectory() && EXCLUDED_DIRS.has(entry.name)) {
         continue;
       }
-      const fullPath = join38(dir2, entry.name);
-      const relPath = join38(relativeDir, entry.name);
+      const fullPath = join39(dir2, entry.name);
+      const relPath = join39(relativeDir, entry.name);
       if (entry.isFile()) {
         if (entry.name.toLowerCase().includes(lowerQuery)) {
           results.push({
@@ -94260,11 +94645,11 @@ async function searchWorkspaceFiles(store, workspace, query) {
   return { files: results };
 }
 async function copyDirectoryRecursive(source, destination) {
-  await mkdir12(destination, { recursive: true });
+  await mkdir13(destination, { recursive: true });
   const entries = await readdir8(source, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join38(source, entry.name);
-    const destPath = join38(destination, entry.name);
+    const sourcePath = join39(source, entry.name);
+    const destPath = join39(destination, entry.name);
     if (entry.isDirectory()) {
       await copyDirectoryRecursive(sourcePath, destPath);
     } else {
@@ -95181,9 +95566,9 @@ var require_readdir_glob = __commonJS({
     var fs2 = __require("fs");
     var { EventEmitter: EventEmitter35 } = __require("events");
     var { Minimatch } = require_minimatch();
-    var { resolve: resolve36 } = __require("path");
+    var { resolve: resolve39 } = __require("path");
     function readdir12(dir2, strict) {
-      return new Promise((resolve37, reject2) => {
+      return new Promise((resolve40, reject2) => {
         fs2.readdir(dir2, { withFileTypes: true }, (err, files) => {
           if (err) {
             switch (err.code) {
@@ -95191,7 +95576,7 @@ var require_readdir_glob = __commonJS({
                 if (strict) {
                   reject2(err);
                 } else {
-                  resolve37([]);
+                  resolve40([]);
                 }
                 break;
               case "ENOTSUP":
@@ -95201,7 +95586,7 @@ var require_readdir_glob = __commonJS({
               case "ENAMETOOLONG":
               // Filename too long
               case "UNKNOWN":
-                resolve37([]);
+                resolve40([]);
                 break;
               case "ELOOP":
               // Too many levels of symbolic links
@@ -95210,30 +95595,30 @@ var require_readdir_glob = __commonJS({
                 break;
             }
           } else {
-            resolve37(files);
+            resolve40(files);
           }
         });
       });
     }
     function stat12(file, followSymlinks) {
-      return new Promise((resolve37, reject2) => {
+      return new Promise((resolve40, reject2) => {
         const statFunc = followSymlinks ? fs2.stat : fs2.lstat;
         statFunc(file, (err, stats) => {
           if (err) {
             switch (err.code) {
               case "ENOENT":
                 if (followSymlinks) {
-                  resolve37(stat12(file, false));
+                  resolve40(stat12(file, false));
                 } else {
-                  resolve37(null);
+                  resolve40(null);
                 }
                 break;
               default:
-                resolve37(null);
+                resolve40(null);
                 break;
             }
           } else {
-            resolve37(stats);
+            resolve40(stats);
           }
         });
       });
@@ -95323,7 +95708,7 @@ var require_readdir_glob = __commonJS({
             (skip) => new Minimatch(skip, { dot: true })
           );
         }
-        this.iterator = explore(resolve36(cwd || "."), this.options.follow, this.options.stat, this._shouldSkipDirectory.bind(this));
+        this.iterator = explore(resolve39(cwd || "."), this.options.follow, this.options.stat, this._shouldSkipDirectory.bind(this));
         this.paused = false;
         this.inactive = false;
         this.aborted = false;
@@ -95577,10 +95962,10 @@ function awaitify(asyncFn, arity) {
     if (typeof args[arity - 1] === "function") {
       return asyncFn.apply(this, args);
     }
-    return new Promise((resolve36, reject2) => {
+    return new Promise((resolve39, reject2) => {
       args[arity - 1] = (err, ...cbArgs) => {
         if (err) return reject2(err);
-        resolve36(cbArgs.length > 1 ? cbArgs : cbArgs[0]);
+        resolve39(cbArgs.length > 1 ? cbArgs : cbArgs[0]);
       };
       asyncFn.apply(this, args);
     });
@@ -95762,13 +96147,13 @@ function mapSeries(coll, iteratee, callback) {
   return _asyncMap(eachOfSeries$1, coll, iteratee, callback);
 }
 function promiseCallback() {
-  let resolve36, reject2;
+  let resolve39, reject2;
   function callback(err, ...args) {
     if (err) return reject2(err);
-    resolve36(args.length > 1 ? args : args[0]);
+    resolve39(args.length > 1 ? args : args[0]);
   }
   callback[PROMISE_SYMBOL] = new Promise((res, rej) => {
-    resolve36 = res, reject2 = rej;
+    resolve39 = res, reject2 = rej;
   });
   return callback;
 }
@@ -96041,8 +96426,8 @@ function queue$1(worker, concurrency, payload) {
       });
     }
     if (rejectOnError || !callback) {
-      return new Promise((resolve36, reject2) => {
-        res = resolve36;
+      return new Promise((resolve39, reject2) => {
+        res = resolve39;
         rej = reject2;
       });
     }
@@ -96081,10 +96466,10 @@ function queue$1(worker, concurrency, payload) {
   }
   const eventMethod = (name) => (handler) => {
     if (!handler) {
-      return new Promise((resolve36, reject2) => {
+      return new Promise((resolve39, reject2) => {
         once3(name, (err, data) => {
           if (err) return reject2(err);
-          resolve36(data);
+          resolve39(data);
         });
       });
     }
@@ -97745,7 +98130,7 @@ var require_graceful_fs = __commonJS({
     function patch(fs3) {
       polyfills(fs3);
       fs3.gracefulify = patch;
-      fs3.createReadStream = createReadStream3;
+      fs3.createReadStream = createReadStream4;
       fs3.createWriteStream = createWriteStream2;
       var fs$readFile = fs3.readFile;
       fs3.readFile = readFile24;
@@ -97765,8 +98150,8 @@ var require_graceful_fs = __commonJS({
         }
       }
       var fs$writeFile = fs3.writeFile;
-      fs3.writeFile = writeFile17;
-      function writeFile17(path5, data, options, cb) {
+      fs3.writeFile = writeFile18;
+      function writeFile18(path5, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path5, data, options, cb);
@@ -97955,7 +98340,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream3(path5, options) {
+      function createReadStream4(path5, options) {
         return new fs3.ReadStream(path5, options);
       }
       function createWriteStream2(path5, options) {
@@ -102090,25 +102475,25 @@ var require_util2 = __commonJS({
         };
       },
       createDeferredPromise: function() {
-        let resolve36;
+        let resolve39;
         let reject2;
         const promise = new Promise((res, rej) => {
-          resolve36 = res;
+          resolve39 = res;
           reject2 = rej;
         });
         return {
           promise,
-          resolve: resolve36,
+          resolve: resolve39,
           reject: reject2
         };
       },
       promisify(fn) {
-        return new Promise((resolve36, reject2) => {
+        return new Promise((resolve39, reject2) => {
           fn((err, ...args) => {
             if (err) {
               return reject2(err);
             }
-            return resolve36(...args);
+            return resolve39(...args);
           });
         });
       },
@@ -102900,7 +103285,7 @@ var require_end_of_stream2 = __commonJS({
         validateBoolean3(opts.cleanup, "cleanup");
         autoCleanup = opts.cleanup;
       }
-      return new Promise2((resolve36, reject2) => {
+      return new Promise2((resolve39, reject2) => {
         const cleanup = eos(stream, opts, (err) => {
           if (autoCleanup) {
             cleanup();
@@ -102908,7 +103293,7 @@ var require_end_of_stream2 = __commonJS({
           if (err) {
             reject2(err);
           } else {
-            resolve36();
+            resolve39();
           }
         });
       });
@@ -104075,7 +104460,7 @@ var require_readable2 = __commonJS({
         error = this.readableEnded ? null : new AbortError();
         this.destroy(error);
       }
-      return new Promise2((resolve36, reject2) => eos(this, (err) => err && err !== error ? reject2(err) : resolve36(null)));
+      return new Promise2((resolve39, reject2) => eos(this, (err) => err && err !== error ? reject2(err) : resolve39(null)));
     };
     Readable2.prototype.push = function(chunk, encoding) {
       return readableAddChunk(this, chunk, encoding, false);
@@ -104619,12 +105004,12 @@ var require_readable2 = __commonJS({
     }
     async function* createAsyncIterator(stream, options) {
       let callback = nop;
-      function next(resolve36) {
+      function next(resolve39) {
         if (this === stream) {
           callback();
           callback = nop;
         } else {
-          callback = resolve36;
+          callback = resolve39;
         }
       }
       stream.on("readable", next);
@@ -105677,7 +106062,7 @@ var require_duplexify = __commonJS({
       );
     };
     function fromAsyncGen(fn) {
-      let { promise, resolve: resolve36 } = createDeferredPromise();
+      let { promise, resolve: resolve39 } = createDeferredPromise();
       const ac = new AbortController2();
       const signal = ac.signal;
       const value = fn(
@@ -105692,7 +106077,7 @@ var require_duplexify = __commonJS({
               throw new AbortError(void 0, {
                 cause: signal.reason
               });
-            ({ promise, resolve: resolve36 } = createDeferredPromise());
+            ({ promise, resolve: resolve39 } = createDeferredPromise());
             yield chunk;
           }
         })(),
@@ -105703,8 +106088,8 @@ var require_duplexify = __commonJS({
       return {
         value,
         write(chunk, encoding, cb) {
-          const _resolve = resolve36;
-          resolve36 = null;
+          const _resolve = resolve39;
+          resolve39 = null;
           _resolve({
             chunk,
             done: false,
@@ -105712,8 +106097,8 @@ var require_duplexify = __commonJS({
           });
         },
         final(cb) {
-          const _resolve = resolve36;
-          resolve36 = null;
+          const _resolve = resolve39;
+          resolve39 = null;
           _resolve({
             done: true,
             cb
@@ -106165,7 +106550,7 @@ var require_pipeline = __commonJS({
           callback();
         }
       };
-      const wait = () => new Promise2((resolve36, reject2) => {
+      const wait = () => new Promise2((resolve39, reject2) => {
         if (error) {
           reject2(error);
         } else {
@@ -106173,7 +106558,7 @@ var require_pipeline = __commonJS({
             if (error) {
               reject2(error);
             } else {
-              resolve36();
+              resolve39();
             }
           };
         }
@@ -106817,8 +107202,8 @@ var require_operators = __commonJS({
                 next = null;
               }
               if (!done && (queue2.length >= highWaterMark2 || cnt >= concurrency)) {
-                await new Promise2((resolve36) => {
-                  resume = resolve36;
+                await new Promise2((resolve39) => {
+                  resume = resolve39;
                 });
               }
             }
@@ -106852,8 +107237,8 @@ var require_operators = __commonJS({
               queue2.shift();
               maybeResume();
             }
-            await new Promise2((resolve36) => {
-              next = resolve36;
+            await new Promise2((resolve39) => {
+              next = resolve39;
             });
           }
         } finally {
@@ -107111,7 +107496,7 @@ var require_promises = __commonJS({
     var { finished } = require_end_of_stream2();
     require_stream2();
     function pipeline(...streams) {
-      return new Promise2((resolve36, reject2) => {
+      return new Promise2((resolve39, reject2) => {
         let signal;
         let end;
         const lastArg = streams[streams.length - 1];
@@ -107126,7 +107511,7 @@ var require_promises = __commonJS({
             if (err) {
               reject2(err);
             } else {
-              resolve36(value);
+              resolve39(value);
             }
           },
           {
@@ -111899,10 +112284,10 @@ var require_commonjs3 = __commonJS({
        * Return a void Promise that resolves once the stream ends.
        */
       async promise() {
-        return new Promise((resolve36, reject2) => {
+        return new Promise((resolve39, reject2) => {
           this.on(DESTROYED, () => reject2(new Error("stream destroyed")));
           this.on("error", (er) => reject2(er));
-          this.on("end", () => resolve36());
+          this.on("end", () => resolve39());
         });
       }
       /**
@@ -111926,7 +112311,7 @@ var require_commonjs3 = __commonJS({
             return Promise.resolve({ done: false, value: res });
           if (this[EOF])
             return stop();
-          let resolve36;
+          let resolve39;
           let reject2;
           const onerr = (er) => {
             this.off("data", ondata);
@@ -111940,19 +112325,19 @@ var require_commonjs3 = __commonJS({
             this.off("end", onend);
             this.off(DESTROYED, ondestroy);
             this.pause();
-            resolve36({ value, done: !!this[EOF] });
+            resolve39({ value, done: !!this[EOF] });
           };
           const onend = () => {
             this.off("error", onerr);
             this.off("data", ondata);
             this.off(DESTROYED, ondestroy);
             stop();
-            resolve36({ done: true, value: void 0 });
+            resolve39({ done: true, value: void 0 });
           };
           const ondestroy = () => onerr(new Error("stream destroyed"));
           return new Promise((res2, rej) => {
             reject2 = rej;
-            resolve36 = res2;
+            resolve39 = res2;
             this.once(DESTROYED, ondestroy);
             this.once("error", onerr);
             this.once("end", onend);
@@ -112968,9 +113353,9 @@ var require_commonjs4 = __commonJS({
         if (this.#asyncReaddirInFlight) {
           await this.#asyncReaddirInFlight;
         } else {
-          let resolve36 = () => {
+          let resolve39 = () => {
           };
-          this.#asyncReaddirInFlight = new Promise((res) => resolve36 = res);
+          this.#asyncReaddirInFlight = new Promise((res) => resolve39 = res);
           try {
             for (const e of await this.#fs.promises.readdir(fullpath, {
               withFileTypes: true
@@ -112983,7 +113368,7 @@ var require_commonjs4 = __commonJS({
             children.provisional = 0;
           }
           this.#asyncReaddirInFlight = void 0;
-          resolve36();
+          resolve39();
         }
         return children.slice(0, children.provisional);
       }
@@ -115756,11 +116141,11 @@ var require_core = __commonJS({
         this._finalize();
       }
       var self2 = this;
-      return new Promise(function(resolve36, reject2) {
+      return new Promise(function(resolve39, reject2) {
         var errored;
         self2._module.on("end", function() {
           if (!errored) {
-            resolve36();
+            resolve39();
           }
         });
         self2._module.on("error", function(err) {
@@ -118200,8 +118585,8 @@ var require_streamx = __commonJS({
             return this;
           },
           next() {
-            return new Promise(function(resolve36, reject2) {
-              promiseResolve = resolve36;
+            return new Promise(function(resolve39, reject2) {
+              promiseResolve = resolve39;
               promiseReject = reject2;
               const data = stream.read();
               if (data !== null) ondata(data);
@@ -118231,11 +118616,11 @@ var require_streamx = __commonJS({
         }
         function destroy(err) {
           stream.destroy(err);
-          return new Promise((resolve36, reject2) => {
-            if (stream._duplexState & DESTROYED) return resolve36({ value: void 0, done: true });
+          return new Promise((resolve39, reject2) => {
+            if (stream._duplexState & DESTROYED) return resolve39({ value: void 0, done: true });
             stream.once("close", function() {
               if (err) reject2(err);
-              else resolve36({ value: void 0, done: true });
+              else resolve39({ value: void 0, done: true });
             });
           });
         }
@@ -118279,8 +118664,8 @@ var require_streamx = __commonJS({
         const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0);
         if (writes === 0) return Promise.resolve(true);
         if (state.drains === null) state.drains = [];
-        return new Promise((resolve36) => {
-          state.drains.push({ writes, resolve: resolve36 });
+        return new Promise((resolve39) => {
+          state.drains.push({ writes, resolve: resolve39 });
         });
       }
       write(data) {
@@ -118385,10 +118770,10 @@ var require_streamx = __commonJS({
       cb(null);
     }
     function pipelinePromise(...streams) {
-      return new Promise((resolve36, reject2) => {
+      return new Promise((resolve39, reject2) => {
         return pipeline(...streams, (err) => {
           if (err) return reject2(err);
-          resolve36();
+          resolve39();
         });
       });
     }
@@ -119045,16 +119430,16 @@ var require_extract = __commonJS({
           entryCallback = null;
           cb(err);
         }
-        function onnext(resolve36, reject2) {
+        function onnext(resolve39, reject2) {
           if (error) {
             return reject2(error);
           }
           if (entryStream) {
-            resolve36({ value: entryStream, done: false });
+            resolve39({ value: entryStream, done: false });
             entryStream = null;
             return;
           }
-          promiseResolve = resolve36;
+          promiseResolve = resolve39;
           promiseReject = reject2;
           consumeCallback(null);
           if (extract._finished && promiseResolve) {
@@ -119082,11 +119467,11 @@ var require_extract = __commonJS({
         function destroy(err) {
           extract.destroy(err);
           consumeCallback(err);
-          return new Promise((resolve36, reject2) => {
-            if (extract.destroyed) return resolve36({ value: void 0, done: true });
+          return new Promise((resolve39, reject2) => {
+            if (extract.destroyed) return resolve39({ value: void 0, done: true });
             extract.once("close", function() {
               if (err) reject2(err);
-              else resolve36({ value: void 0, done: true });
+              else resolve39({ value: void 0, done: true });
             });
           });
         }
@@ -119857,7 +120242,7 @@ var require_archiver = __commonJS({
 
 // ../dashboard/src/routes/register-file-workspace-routes.ts
 import { access as access5 } from "node:fs/promises";
-import { createReadStream as createReadStream2 } from "node:fs";
+import { createReadStream as createReadStream3 } from "node:fs";
 function extractFileParams(req) {
   const filePath = Array.isArray(req.params.filepath) ? req.params.filepath[0] : req.params.filepath ?? "";
   const workspace = typeof req.query.workspace === "string" && req.query.workspace.length > 0 ? req.query.workspace : "project";
@@ -119908,7 +120293,7 @@ function registerFileWorkspaceRoutes(ctx) {
       if (typeof content !== "string") {
         throw badRequest("content is required and must be a string");
       }
-      const result = await writeFile12(scopedStore, req.params.id, filePath, content);
+      const result = await writeFile13(scopedStore, req.params.id, filePath, content);
       res.json(result);
     } catch (err) {
       if (err instanceof ApiError) {
@@ -120119,7 +120504,7 @@ function registerFileWorkspaceRoutes(ctx) {
       res.setHeader("Content-Disposition", `attachment; filename="${fileName}"`);
       res.setHeader("Content-Length", stats.size);
       res.setHeader("Last-Modified", stats.mtime.toUTCString());
-      const stream = createReadStream2(absolutePath);
+      const stream = createReadStream3(absolutePath);
       stream.pipe(res);
     } catch (err) {
       if (err instanceof ApiError) {
@@ -120866,8 +121251,8 @@ var init_exec_file = __esm({
 
 // ../dashboard/src/routes/register-project-routes.ts
 import * as fsPromises from "node:fs/promises";
-import { dirname as dirname12, isAbsolute as isAbsolute14, join as join39 } from "node:path";
-var access7, stat8, mkdir13, readdir9, rm2, registerProjectRoutes;
+import { dirname as dirname12, isAbsolute as isAbsolute14, join as join40 } from "node:path";
+var access7, stat8, mkdir14, readdir9, rm3, registerProjectRoutes;
 var init_register_project_routes = __esm({
   "../dashboard/src/routes/register-project-routes.ts"() {
     "use strict";
@@ -120878,9 +121263,9 @@ var init_register_project_routes = __esm({
     ({
       access: access7,
       stat: stat8,
-      mkdir: mkdir13,
+      mkdir: mkdir14,
       readdir: readdir9,
-      rm: rm2
+      rm: rm3
     } = fsPromises);
     registerProjectRoutes = (ctx) => {
       const { router, options, runtimeLogger, prioritizeProjectsForCurrentDirectory, rethrowAsApiError: rethrowAsApiError7 } = ctx;
@@ -121031,7 +121416,7 @@ var init_register_project_routes = __esm({
                 throw badRequest("Clone destination must be empty");
               }
             } else {
-              await mkdir13(normalizedPath, { recursive: false });
+              await mkdir14(normalizedPath, { recursive: false });
               destinationCreatedForClone = true;
             }
             const cloneSource = normalizedCloneUrl;
@@ -121047,7 +121432,7 @@ var init_register_project_routes = __esm({
             } catch (cloneError) {
               if (destinationCreatedForClone) {
                 try {
-                  await rm2(normalizedPath, { recursive: true, force: true });
+                  await rm3(normalizedPath, { recursive: true, force: true });
                 } catch {
                 }
               }
@@ -121057,7 +121442,7 @@ var init_register_project_routes = __esm({
             }
           }
           let hasFusionDir = false;
-          const fusionDirPath = join39(normalizedPath, ".fusion");
+          const fusionDirPath = join40(normalizedPath, ".fusion");
           try {
             await access7(fusionDirPath);
             hasFusionDir = true;
@@ -121119,18 +121504,18 @@ var init_register_project_routes = __esm({
             const entries = await readdir9(searchPath, { withFileTypes: true });
             for (const entry of entries) {
               if (!entry.isDirectory()) continue;
-              const dirPath = join39(searchPath, entry.name);
+              const dirPath = join40(searchPath, entry.name);
               let hasKbDb = false;
               let hasFusionDir = false;
               try {
-                await access7(join39(dirPath, ".fusion", "fusion.db"));
+                await access7(join40(dirPath, ".fusion", "fusion.db"));
                 hasKbDb = true;
               } catch {
                 hasKbDb = false;
               }
               if (!hasKbDb) {
                 try {
-                  await access7(join39(dirPath, ".fusion"));
+                  await access7(join40(dirPath, ".fusion"));
                   hasFusionDir = true;
                 } catch {
                   hasFusionDir = false;
@@ -124134,7 +124519,7 @@ var init_register_agent_reflection_rating_routes = __esm({
 });
 
 // ../dashboard/src/agent-generation.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 async function initPromptCatalog() {
   if (promptCatalogReady) return;
   try {
@@ -124340,7 +124725,7 @@ async function startAgentGeneration(ip, roleDescription) {
       `Rate limit exceeded. Maximum ${MAX_SESSIONS_PER_IP_PER_HOUR4} generation sessions per hour. Reset at ${resetTime?.toISOString() || "unknown"}`
     );
   }
-  const sessionId = randomUUID16();
+  const sessionId = randomUUID17();
   const session = {
     id: sessionId,
     ip,
@@ -124518,7 +124903,7 @@ You MUST respond with ONLY valid JSON (no markdown, no explanation):
 import { createWriteStream } from "node:fs";
 import * as fsPromises2 from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join40, resolve as resolve19 } from "node:path";
+import { join as join41, resolve as resolve20 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline as streamPipeline } from "node:stream/promises";
 function registerAgentImportExportRoutes(ctx) {
@@ -124555,11 +124940,11 @@ function registerAgentImportExportRoutes(ctx) {
       }
       let resolvedOutputDir;
       if (typeof outputDir === "string" && outputDir.trim().length > 0) {
-        resolvedOutputDir = resolve19(outputDir.trim());
+        resolvedOutputDir = resolve20(outputDir.trim());
       } else if (typeof outputDir === "string") {
         throw badRequest("outputDir cannot be empty");
       } else {
-        resolvedOutputDir = await mkdtemp(join40(tmpdir3(), "fusion-agent-export-"));
+        resolvedOutputDir = await mkdtemp(join41(tmpdir3(), "fusion-agent-export-"));
       }
       const result = await exportAgentsToDirectory2(agentsToExport, resolvedOutputDir, {
         companyName: typeof companyName === "string" ? companyName : void 0,
@@ -124686,7 +125071,7 @@ ${body}`;
       return result;
     }
     const safeCompanySlug = companySlug ? slugifyPathSegment2(companySlug, "unknown-company") : "unknown-company";
-    const skillsBaseDir = join40(projectRoot, "skills", "imported", safeCompanySlug);
+    const skillsBaseDir = join41(projectRoot, "skills", "imported", safeCompanySlug);
     const usedSlugs = /* @__PURE__ */ new Set();
     for (const skill of skills) {
       const name = typeof skill.name === "string" && skill.name.trim().length > 0 ? skill.name.trim() : null;
@@ -124703,8 +125088,8 @@ ${body}`;
         skillSlug = `${skillSlug}-${counter}`;
       }
       usedSlugs.add(skillSlug);
-      const skillDir = join40(skillsBaseDir, skillSlug);
-      const skillPath = join40(skillDir, "SKILL.md");
+      const skillDir = join41(skillsBaseDir, skillSlug);
+      const skillPath = join41(skillDir, "SKILL.md");
       try {
         await access8(skillPath);
         result.skipped.push(name);
@@ -124740,7 +125125,7 @@ ${body}`;
 
 <!-- Add skill instructions here. -->`;
       try {
-        await mkdir14(skillDir, { recursive: true });
+        await mkdir15(skillDir, { recursive: true });
         const content = toSkillMarkdown2(frontmatter, body);
         await fsWriteFile2(skillPath, content, "utf-8");
         result.imported.push({ name, path: `skills/imported/${safeCompanySlug}/${skillSlug}/SKILL.md` });
@@ -124790,7 +125175,7 @@ ${body}`;
           tasks: []
         };
       } else if (typeof source === "string" && source.trim()) {
-        const sourcePath = resolve19(source);
+        const sourcePath = resolve20(source);
         const isArchive = sourcePath.endsWith(".tar.gz") || sourcePath.endsWith(".tgz") || sourcePath.endsWith(".zip");
         if (isArchive) {
           try {
@@ -124874,8 +125259,8 @@ ${body}`;
         const archiveUrl = `https://github.com/${repoOwner}/${repoName}/archive/refs/heads/main.tar.gz`;
         let tempDir = null;
         try {
-          tempDir = await mkdtemp(join40(tmpdir3(), `fn-agent-import-${importCompanySlug}-`));
-          const archivePath = join40(tempDir, "archive.tar.gz");
+          tempDir = await mkdtemp(join41(tmpdir3(), `fn-agent-import-${importCompanySlug}-`));
+          const archivePath = join41(tempDir, "archive.tar.gz");
           const downloadController = new AbortController();
           const downloadTimeout = setTimeout(() => downloadController.abort(), 3e4);
           let archiveResponse;
@@ -124919,7 +125304,7 @@ ${body}`;
         } finally {
           if (tempDir) {
             try {
-              await rm3(tempDir, { recursive: true, force: true });
+              await rm4(tempDir, { recursive: true, force: true });
             } catch {
             }
           }
@@ -125127,14 +125512,14 @@ function registerAgentGenerationRoutes(ctx) {
     }
   });
 }
-var mkdtemp, access8, stat9, mkdir14, rm3, fsWriteFile2;
+var mkdtemp, access8, stat9, mkdir15, rm4, fsWriteFile2;
 var init_register_agent_import_export_generation_routes = __esm({
   "../dashboard/src/routes/register-agent-import-export-generation-routes.ts"() {
     "use strict";
     init_api_error();
     init_ai_session_diagnostics();
     init_agent_generation();
-    ({ mkdtemp, access: access8, stat: stat9, mkdir: mkdir14, rm: rm3, writeFile: fsWriteFile2 } = fsPromises2);
+    ({ mkdtemp, access: access8, stat: stat9, mkdir: mkdir15, rm: rm4, writeFile: fsWriteFile2 } = fsPromises2);
   }
 });
 
@@ -125591,9 +125976,9 @@ function registerProxyRoutes(router, deps) {
         if (req.rawBody && req.rawBody.length > 0) {
           body = req.rawBody;
         } else {
-          await new Promise((resolve36, reject2) => {
+          await new Promise((resolve39, reject2) => {
             req.on("data", (chunk) => chunks.push(chunk));
-            req.on("end", resolve36);
+            req.on("end", resolve39);
             req.on("error", reject2);
           });
           if (chunks.length > 0) {
@@ -125789,13 +126174,13 @@ import { readFile as readFile19 } from "node:fs/promises";
 import * as https from "node:https";
 import * as child_process from "node:child_process";
 function execFileAsync4(file, args, options) {
-  return new Promise((resolve36, reject2) => {
+  return new Promise((resolve39, reject2) => {
     child_process.execFile(file, args, options, (error, stdout, stderr) => {
       if (error) {
         reject2(error);
         return;
       }
-      resolve36({ stdout: String(stdout), stderr: String(stderr) });
+      resolve39({ stdout: String(stdout), stderr: String(stderr) });
     });
   });
 }
@@ -125854,7 +126239,7 @@ function formatDuration(ms) {
   return remHours > 0 ? `${days}d ${remHours}h` : `${days}d`;
 }
 function httpsRequest(url, options) {
-  return new Promise((resolve36, reject2) => {
+  return new Promise((resolve39, reject2) => {
     const parsed = new URL(url);
     const req = https.request(
       {
@@ -125874,7 +126259,7 @@ function httpsRequest(url, options) {
             if (typeof v === "string") hdrs[k.toLowerCase()] = v;
             else if (Array.isArray(v)) hdrs[k.toLowerCase()] = v.join(", ");
           }
-          resolve36({
+          resolve39({
             status: res.statusCode || 0,
             headers: hdrs,
             body: Buffer.concat(chunks).toString("utf-8")
@@ -126121,7 +126506,7 @@ async function fetchClaudeUsageViaCli() {
       env: { ...process.env, TERM: "xterm-256color" }
     };
     if (isWindows) ptyOptions.useConpty = false;
-    const output = await new Promise((resolve36, reject2) => {
+    const output = await new Promise((resolve39, reject2) => {
       let buf = "";
       let settled = false;
       let sentCommand = false;
@@ -126137,7 +126522,7 @@ async function fetchClaudeUsageViaCli() {
         }
         const clean = _stripClaudeAnsi(buf);
         if (clean.includes("Current session") || clean.includes("% left") || clean.includes("% used")) {
-          resolve36(buf);
+          resolve39(buf);
         } else {
           reject2(new Error("Claude CLI timed out after 60s \u2014 got output but no usage data. Try running `claude /usage` manually."));
         }
@@ -126188,7 +126573,7 @@ async function fetchClaudeUsageViaCli() {
                     ptyProcess.kill();
                   } catch {
                   }
-                  resolve36(buf);
+                  resolve39(buf);
                 }
               }, 2e3);
             }
@@ -126199,7 +126584,7 @@ async function fetchClaudeUsageViaCli() {
         if (settled) return;
         settled = true;
         clearTimeout(timeout2);
-        resolve36(buf);
+        resolve39(buf);
       });
     });
     const cleanOutput = _stripClaudeAnsi(output);
@@ -126867,9 +127252,9 @@ async function fetchGitHubCopilotUsage() {
   return usage;
 }
 function withTimeout(providerPromise, providerName, timeoutMs = PROVIDER_FETCH_TIMEOUT_MS) {
-  return new Promise((resolve36) => {
+  return new Promise((resolve39) => {
     const timer = setTimeout(() => {
-      resolve36({
+      resolve39({
         name: providerName,
         icon: "\u23F1\uFE0F",
         status: "error",
@@ -126879,10 +127264,10 @@ function withTimeout(providerPromise, providerName, timeoutMs = PROVIDER_FETCH_T
     }, timeoutMs);
     providerPromise.then((result) => {
       clearTimeout(timer);
-      resolve36(result);
+      resolve39(result);
     }).catch((err) => {
       clearTimeout(timer);
-      resolve36({
+      resolve39({
         name: providerName,
         icon: "\u23F1\uFE0F",
         status: "error",
@@ -126937,7 +127322,7 @@ var init_usage = __esm({
     ANTHROPIC_OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
     ANTHROPIC_OAUTH_BETA = "oauth-2025-04-20";
     CLAUDE_USAGE_USER_AGENT = "claude-code-fusion-dashboard";
-    _sleep = (ms) => new Promise((resolve36) => setTimeout(resolve36, ms));
+    _sleep = (ms) => new Promise((resolve39) => setTimeout(resolve39, ms));
     sleepFn = _sleep;
     PROVIDER_FETCH_TIMEOUT_MS = 1e4;
     CLAUDE_FETCH_TIMEOUT_MS = 75e3;
@@ -127251,8 +127636,8 @@ var init_register_auth_routes = __esm({
           loginInProgress.set(provider, abortController);
           let authResolve;
           let authReject;
-          const authUrlPromise = new Promise((resolve36, reject2) => {
-            authResolve = resolve36;
+          const authUrlPromise = new Promise((resolve39, reject2) => {
+            authResolve = resolve39;
             authReject = reject2;
           });
           const loginPromise = storage.login(provider, {
@@ -127678,7 +128063,7 @@ async function mintAgentApiKeyViaCli(opts) {
     args.push("--data-dir", opts.dataDir);
   }
   const timeoutMs = opts.cliTimeoutMs ?? 3e4;
-  return new Promise((resolve36, reject2) => {
+  return new Promise((resolve39, reject2) => {
     let child;
     try {
       child = spawn15(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
@@ -127752,7 +128137,7 @@ async function mintAgentApiKeyViaCli(opts) {
       const apiBase = (typeof r.apiBase === "string" ? r.apiBase : void 0) ?? (typeof r.api_base === "string" ? r.api_base : void 0);
       const agentId = (typeof r.agentId === "string" ? r.agentId : void 0) ?? (typeof r.id === "string" ? r.id : void 0);
       const companyId = typeof r.companyId === "string" ? r.companyId : void 0;
-      resolve36({ apiKey, apiBase, agentId, companyId, raw: parsed });
+      resolve39({ apiKey, apiBase, agentId, companyId, raw: parsed });
     });
   });
 }
@@ -127772,7 +128157,7 @@ async function spawnPaperclipCliJson(args, opts) {
   }
   const timeoutMs = opts.cliTimeoutMs ?? 15e3;
   const label = ["paperclipai", ...args].join(" ");
-  return new Promise((resolve36, reject2) => {
+  return new Promise((resolve39, reject2) => {
     let child;
     try {
       child = spawn15(bin, fullArgs, { stdio: ["ignore", "pipe", "pipe"] });
@@ -127818,7 +128203,7 @@ async function spawnPaperclipCliJson(args, opts) {
         return;
       }
       try {
-        resolve36(JSON.parse(cleaned));
+        resolve39(JSON.parse(cleaned));
       } catch {
         reject2(new Error(`${label} returned non-JSON output: ${cleaned.slice(0, 200)}`));
       }
@@ -127945,9 +128330,9 @@ var init_paperclip_client = __esm({
 });
 
 // ../../plugins/fusion-plugin-paperclip-runtime/dist/runtime-adapter.js
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 function sleep3(ms) {
-  return new Promise((resolve36) => setTimeout(resolve36, ms));
+  return new Promise((resolve39) => setTimeout(resolve39, ms));
 }
 function asString2(value) {
   return typeof value === "string" ? value : void 0;
@@ -128064,7 +128449,7 @@ var init_runtime_adapter3 = __esm({
           apiKey: effectiveApiKey,
           agentId,
           companyId,
-          sessionId: randomUUID17(),
+          sessionId: randomUUID18(),
           systemPrompt: options.systemPrompt,
           cwd: options.cwd,
           mode: normalizeMode(this.config.mode),
@@ -128590,8 +128975,8 @@ var init_register_runtime_provider_routes = __esm({
 
 // ../dashboard/src/update-check.ts
 import { readFileSync as readFileSync8 } from "node:fs";
-import { mkdir as mkdir15, rm as rm4, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join42 } from "node:path";
+import { mkdir as mkdir16, rm as rm5, writeFile as writeFile14 } from "node:fs/promises";
+import { join as join43 } from "node:path";
 function ttlForFrequency(frequency) {
   switch (frequency) {
     case "manual":
@@ -128605,7 +128990,7 @@ function ttlForFrequency(frequency) {
   }
 }
 function getCachePath(fusionDir) {
-  return join42(fusionDir, CACHE_FILENAME);
+  return join43(fusionDir, CACHE_FILENAME);
 }
 function parseVersion(version) {
   return version.split(".").slice(0, 3).map((part) => Number.parseInt(part, 10)).map((value) => Number.isFinite(value) ? value : 0);
@@ -128637,7 +129022,7 @@ function readCachedUpdateCheck(fusionDir) {
   }
 }
 async function clearUpdateCheckCache(fusionDir) {
-  await rm4(getCachePath(fusionDir), { force: true });
+  await rm5(getCachePath(fusionDir), { force: true });
 }
 async function performUpdateCheck(fusionDir, currentVersion, options = {}) {
   const now = Date.now();
@@ -128669,8 +129054,8 @@ async function performUpdateCheck(fusionDir, currentVersion, options = {}) {
       updateAvailable,
       lastChecked: now
     };
-    await mkdir15(fusionDir, { recursive: true });
-    await writeFile13(getCachePath(fusionDir), JSON.stringify(result, null, 2), "utf-8");
+    await mkdir16(fusionDir, { recursive: true });
+    await writeFile14(getCachePath(fusionDir), JSON.stringify(result, null, 2), "utf-8");
     hasRefreshedThisProcess = true;
     return result;
   } catch (error) {
@@ -128696,22 +129081,29 @@ var init_update_check = __esm({
 });
 
 // ../dashboard/src/routes/register-update-check-routes.ts
-import { readFileSync as readFileSync9 } from "node:fs";
-import { dirname as dirname13, join as join43 } from "node:path";
+import { existsSync as existsSync29, readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname13, resolve as resolve21 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-var __dirname, CLI_PACKAGE_VERSION, registerUpdateCheckRoutes;
+var CLI_PACKAGE_VERSION, registerUpdateCheckRoutes;
 var init_register_update_check_routes = __esm({
   "../dashboard/src/routes/register-update-check-routes.ts"() {
     "use strict";
     init_src();
     init_update_check();
-    __dirname = dirname13(fileURLToPath3(import.meta.url));
     CLI_PACKAGE_VERSION = (() => {
       try {
-        const packageJsonPath = join43(__dirname, "..", "..", "..", "cli", "package.json");
-        const packageJson = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
-        if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
-          return packageJson.version;
+        let cur = dirname13(fileURLToPath3(import.meta.url));
+        for (let i = 0; i < 8; i++) {
+          const pkgPath = resolve21(cur, "package.json");
+          if (existsSync29(pkgPath)) {
+            const parsed = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+            if (parsed.name === "@runfusion/fusion" && typeof parsed.version === "string" && parsed.version.length > 0) {
+              return parsed.version;
+            }
+          }
+          const parent2 = resolve21(cur, "..");
+          if (parent2 === cur) break;
+          cur = parent2;
         }
       } catch {
       }
@@ -132693,7 +133085,7 @@ var init_todo_routes = __esm({
 
 // ../dashboard/src/dev-server-detect.ts
 import { glob, readFile as readFile20 } from "node:fs/promises";
-import { dirname as dirname14, join as join44, relative as relative10, resolve as resolve20 } from "node:path";
+import { dirname as dirname14, join as join44, relative as relative10, resolve as resolve22 } from "node:path";
 async function readPackageJson(filePath) {
   try {
     const raw = await readFile20(filePath, "utf-8");
@@ -132743,7 +133135,7 @@ async function collectWorkspacePackageJsons(projectRoot) {
     try {
       for await (const match of glob(pattern, { cwd: projectRoot })) {
         if (typeof match === "string") {
-          discovered.add(resolve20(projectRoot, match));
+          discovered.add(resolve22(projectRoot, match));
         }
       }
     } catch {
@@ -132768,7 +133160,7 @@ function toSource(projectRoot, packageJsonPath) {
   return rel.length > 0 ? rel : "root";
 }
 async function detectDevServerScripts(projectRoot) {
-  const root = resolve20(projectRoot);
+  const root = resolve22(projectRoot);
   const candidates = [];
   const rootPackagePath = join44(root, "package.json");
   const rootPackage = await readPackageJson(rootPackagePath);
@@ -132836,10 +133228,10 @@ var init_dev_server_detect = __esm({
 });
 
 // ../dashboard/src/dev-server-store.ts
-import { mkdir as mkdir16, readFile as readFile21, writeFile as writeFile14 } from "node:fs/promises";
-import { dirname as dirname15, join as join45, resolve as resolve21 } from "node:path";
+import { mkdir as mkdir17, readFile as readFile21, writeFile as writeFile15 } from "node:fs/promises";
+import { dirname as dirname15, join as join45, resolve as resolve23 } from "node:path";
 function devServerFilePath(projectDir) {
-  return join45(resolve21(projectDir), ".fusion", "dev-server.json");
+  return join45(resolve23(projectDir), ".fusion", "dev-server.json");
 }
 function normalizeState(candidate) {
   const defaults = DEV_SERVER_DEFAULT_STATE();
@@ -132874,7 +133266,7 @@ function normalizeConfig(candidate) {
   };
 }
 async function loadDevServerStore(projectDir) {
-  const storeKey = resolve21(projectDir);
+  const storeKey = resolve23(projectDir);
   let store = storeInstances.get(storeKey);
   if (!store) {
     store = new DevServerStore(projectDir);
@@ -132933,7 +133325,7 @@ var init_dev_server_store = __esm({
           return error.code === "ENOENT";
         };
         try {
-          await mkdir16(dir2, { recursive: true });
+          await mkdir17(dir2, { recursive: true });
         } catch (error) {
           if (isMissingPathError(error)) {
             return;
@@ -132941,13 +133333,13 @@ var init_dev_server_store = __esm({
           throw error;
         }
         try {
-          await writeFile14(this.filePath, serializedPayload, "utf-8");
+          await writeFile15(this.filePath, serializedPayload, "utf-8");
         } catch (error) {
           if (!isMissingPathError(error)) {
             throw error;
           }
           try {
-            await mkdir16(dir2, { recursive: true });
+            await mkdir17(dir2, { recursive: true });
           } catch (retryMkdirError) {
             if (isMissingPathError(retryMkdirError)) {
               return;
@@ -132955,7 +133347,7 @@ var init_dev_server_store = __esm({
             throw retryMkdirError;
           }
           try {
-            await writeFile14(this.filePath, serializedPayload, "utf-8");
+            await writeFile15(this.filePath, serializedPayload, "utf-8");
           } catch (retryWriteError) {
             if (isMissingPathError(retryWriteError)) {
               return;
@@ -133152,7 +133544,7 @@ function detectPortFromLogLine(line) {
   return detectViteLine(cleanLine) ?? detectNextLine(cleanLine) ?? detectStorybookLine(cleanLine) ?? detectAngularLine(cleanLine) ?? detectGenericUrl(cleanLine) ?? detectGenericPortLine(cleanLine);
 }
 function probePort(host, port, timeoutMs) {
-  return new Promise((resolve36) => {
+  return new Promise((resolve39) => {
     let settled = false;
     const socket = createConnection({ host, port });
     const settle = (isOpen) => {
@@ -133166,7 +133558,7 @@ function probePort(host, port, timeoutMs) {
       } else {
         socket.destroy();
       }
-      resolve36(isOpen);
+      resolve39(isOpen);
     };
     socket.setTimeout(timeoutMs);
     socket.once("connect", () => settle(true));
@@ -133293,8 +133685,8 @@ var init_dev_server_process = __esm({
           stdio: ["pipe", "pipe", "pipe"]
         });
         this.childProcess = child;
-        this.closePromise = new Promise((resolve36) => {
-          this.resolveClosePromise = resolve36;
+        this.closePromise = new Promise((resolve39) => {
+          this.resolveClosePromise = resolve39;
         });
         const runningState = await this.store.updateState({
           pid: child.pid,
@@ -134091,7 +134483,7 @@ Your job is to refine task descriptions based on the user's selected refinement
 
 // ../dashboard/src/routes.ts
 import multer from "multer";
-import { resolve as resolve22, sep as sep6, join as join46, isAbsolute as isAbsolute15 } from "node:path";
+import { resolve as resolve24, sep as sep6, join as join46, isAbsolute as isAbsolute15 } from "node:path";
 import * as nodeFs from "node:fs";
 import os5 from "node:os";
 import v8 from "node:v8";
@@ -134123,7 +134515,7 @@ function getPiPackageManagerAgentDir() {
   return nodeFs.existsSync(fusionAgentDir) ? fusionAgentDir : legacyAgentDir;
 }
 function packageExtensionName(extensionPath, source) {
-  const base = resolve22(extensionPath).split(sep6).pop()?.replace(/\.(ts|js)$/i, "") || source;
+  const base = resolve24(extensionPath).split(sep6).pop()?.replace(/\.(ts|js)$/i, "") || source;
   if (base !== "index") {
     return base;
   }
@@ -134131,7 +134523,7 @@ function packageExtensionName(extensionPath, source) {
 }
 async function discoverDashboardPiExtensions(cwd) {
   const settings = discoverPiExtensions(cwd);
-  const disabled = new Set(settings.disabledIds.map((id) => resolve22(id)));
+  const disabled = new Set(settings.disabledIds.map((id) => resolve24(id)));
   const byPath = new Map(settings.extensions.map((entry) => [entry.id, entry]));
   try {
     const { DefaultPackageManager: DefaultPackageManager5 } = await import("@mariozechner/pi-coding-agent");
@@ -134153,7 +134545,7 @@ async function discoverDashboardPiExtensions(cwd) {
     });
     const resolved = await packageManager.resolve(async () => "skip");
     for (const extension2 of resolved.extensions) {
-      const id = resolve22(extension2.path);
+      const id = resolve24(extension2.path);
       const source = extension2.metadata?.source || "package";
       byPath.set(id, {
         id,
@@ -134543,7 +134935,8 @@ function createApiRoutes(store, options) {
   });
   registerChatRoutes(routeContext, {
     parseLastEventId: parseLastEventId2,
-    validateOptionalModelField
+    validateOptionalModelField,
+    upload
   });
   registerMessagingScriptRoutes(routeContext);
   registerGitGitHubRoutes(routeContext);
@@ -134555,8 +134948,8 @@ function createApiRoutes(store, options) {
   function isHeartbeatMonitorForProject(scopedStore) {
     if (!heartbeatMonitor?.rootDir) return true;
     try {
-      const monitorRoot = resolve22(heartbeatMonitor.rootDir);
-      const storeRoot = resolve22(scopedStore.getRootDir());
+      const monitorRoot = resolve24(heartbeatMonitor.rootDir);
+      const storeRoot = resolve24(scopedStore.getRootDir());
       return monitorRoot === storeRoot;
     } catch {
       return true;
@@ -136478,15 +136871,15 @@ Description: ${step.description}`
           return;
         }
       }
-      const { resolve: resolve36, dirname: dirname28, join: join65 } = await import("node:path");
+      const { resolve: resolve39, dirname: dirname28, join: join65 } = await import("node:path");
       const { readdir: readdir12, stat: stat12 } = await import("node:fs/promises");
       const rawPath = req.query.path || process.env.HOME || process.env.USERPROFILE || "/";
       const showHidden = req.query.showHidden === "true";
-      const resolvedPath = resolve36(rawPath);
+      const resolvedPath = resolve39(rawPath);
       if (rawPath.includes("..")) {
         throw badRequest("Path must not contain '..' traversal");
       }
-      if (resolvedPath !== resolve36(resolvedPath)) {
+      if (resolvedPath !== resolve39(resolvedPath)) {
         throw badRequest("Path must be absolute");
       }
       let pathStat;
@@ -141813,7 +142206,7 @@ var init_badge_pubsub = __esm({
 });
 
 // ../dashboard/src/terminal-websocket-diagnostics.ts
-import { basename as basename11, normalize as normalize4, sep as sep7 } from "node:path";
+import { basename as basename12, normalize as normalize4, sep as sep7 } from "node:path";
 function toSessionTag(sessionId) {
   const normalized = sessionId.trim();
   if (normalized.length <= 8) {
@@ -141860,8 +142253,8 @@ function createTerminalWebSocketDiagnostics(runtimeLogger) {
         projectId,
         sessionCwdHint: toRedactedPathHint(sessionCwd),
         scopedRootHint: toRedactedPathHint(scopedRootDir),
-        sessionCwdBase: basename11(sessionCwd),
-        scopedRootBase: basename11(scopedRootDir)
+        sessionCwdBase: basename12(sessionCwd),
+        scopedRootBase: basename12(scopedRootDir)
       });
     },
     staleReconnect({ sessionId, idleMs, staleThresholdMs }) {
@@ -142003,9 +142396,9 @@ var init_auth_middleware = __esm({
 
 // ../dashboard/src/server.ts
 import express from "express";
-import { randomUUID as randomUUID18 } from "node:crypto";
-import { join as join47, dirname as dirname16 } from "node:path";
-import { existsSync as existsSync30, readFileSync as readFileSync11 } from "node:fs";
+import { randomUUID as randomUUID19 } from "node:crypto";
+import { join as join47, dirname as dirname16, resolve as resolve25 } from "node:path";
+import { existsSync as existsSync31, readFileSync as readFileSync11 } from "node:fs";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { createSecureServer as createHttp2SecureServer } from "node:http2";
 function parseVersion2(version) {
@@ -142186,7 +142579,7 @@ function createServer(store, options) {
   getTerminalService(store.getRootDir());
   const isHeadless = options?.headless === true;
   const execDir = dirname16(process.execPath);
-  const clientDir = process.env.FUSION_CLIENT_DIR ? process.env.FUSION_CLIENT_DIR : existsSync30(join47(execDir, "client", "index.html")) ? join47(execDir, "client") : existsSync30(join47(__dirname2, "..", "dist", "client")) ? join47(__dirname2, "..", "dist", "client") : join47(__dirname2, "..", "client");
+  const clientDir = process.env.FUSION_CLIENT_DIR ? process.env.FUSION_CLIENT_DIR : existsSync31(join47(execDir, "client", "index.html")) ? join47(execDir, "client") : existsSync31(join47(__dirname, "..", "dist", "client")) ? join47(__dirname, "..", "dist", "client") : join47(__dirname, "..", "client");
   if (!isHeadless) {
     app.get("/version.json", (_req, res) => {
       res.setHeader("Cache-Control", "no-store, max-age=0");
@@ -142849,7 +143242,7 @@ function setupBadgeWebSocket(app, server, store, options) {
   const dashboardApp = app;
   const wsManager = new WebSocketManager();
   const badgeSnapshots = /* @__PURE__ */ new Map();
-  const serverId = randomUUID18();
+  const serverId = randomUUID19();
   const badgePubSub = options?.badgePubSub ?? createBadgePubSub({ sourceId: serverId });
   void badgePubSub.start();
   const scopedStores = /* @__PURE__ */ new Map();
@@ -142983,7 +143376,7 @@ function setupBadgeWebSocket(app, server, store, options) {
     const url = new URL(req.url || "", `http://${req.headers.host}`);
     const projectId = url.searchParams.get("projectId") ?? "default";
     void ensureScopedListeners(projectId);
-    wsManager.addClient(ws, randomUUID18(), projectId);
+    wsManager.addClient(ws, randomUUID19(), projectId);
   });
   server.once("close", () => {
     for (const cleanup of scopedCleanups.values()) {
@@ -143023,7 +143416,7 @@ function snapshotsEqual(a, b) {
   if (a.issueInfo?.title !== b.issueInfo?.title) return false;
   return true;
 }
-var __dirname2, PACKAGE_VERSION, CLI_PACKAGE_VERSION2, DEFAULT_AI_SESSION_TTL_MS, MIN_AI_SESSION_TTL_MS, MAX_AI_SESSION_TTL_MS, DEFAULT_AI_SESSION_CLEANUP_INTERVAL_MS, MIN_AI_SESSION_CLEANUP_INTERVAL_MS, MAX_AI_SESSION_CLEANUP_INTERVAL_MS, aiSessionCleanupIntervalHandle;
+var __dirname, PACKAGE_VERSION, CLI_PACKAGE_VERSION2, DEFAULT_AI_SESSION_TTL_MS, MIN_AI_SESSION_TTL_MS, MAX_AI_SESSION_TTL_MS, DEFAULT_AI_SESSION_CLEANUP_INTERVAL_MS, MIN_AI_SESSION_CLEANUP_INTERVAL_MS, MAX_AI_SESSION_CLEANUP_INTERVAL_MS, aiSessionCleanupIntervalHandle;
 var init_server = __esm({
   "../dashboard/src/server.ts"() {
     "use strict";
@@ -143049,10 +143442,10 @@ var init_server = __esm({
     init_dev_server_routes();
     init_auth_middleware();
     init_remote_auth();
-    __dirname2 = dirname16(fileURLToPath4(import.meta.url));
+    __dirname = dirname16(fileURLToPath4(import.meta.url));
     PACKAGE_VERSION = (() => {
       try {
-        const packageJsonPath = join47(__dirname2, "..", "package.json");
+        const packageJsonPath = join47(__dirname, "..", "package.json");
         const packageJson = JSON.parse(readFileSync11(packageJsonPath, "utf-8"));
         if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
           return packageJson.version;
@@ -143063,10 +143456,18 @@ var init_server = __esm({
     })();
     CLI_PACKAGE_VERSION2 = (() => {
       try {
-        const packageJsonPath = join47(__dirname2, "..", "..", "cli", "package.json");
-        const packageJson = JSON.parse(readFileSync11(packageJsonPath, "utf-8"));
-        if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
-          return packageJson.version;
+        let cur = __dirname;
+        for (let i = 0; i < 8; i++) {
+          const pkgPath = resolve25(cur, "package.json");
+          if (existsSync31(pkgPath)) {
+            const parsed = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+            if (parsed.name === "@runfusion/fusion" && typeof parsed.version === "string" && parsed.version.length > 0) {
+              return parsed.version;
+            }
+          }
+          const parent2 = resolve25(cur, "..");
+          if (parent2 === cur) break;
+          cur = parent2;
         }
       } catch {
       }
@@ -143085,7 +143486,7 @@ var init_server = __esm({
 });
 
 // ../dashboard/src/skills-adapter.ts
-import { access as access9, readFile as readFile22, writeFile as writeFile15, mkdir as mkdir17, readdir as readdir10, stat as stat10 } from "node:fs/promises";
+import { access as access9, readFile as readFile22, writeFile as writeFile16, mkdir as mkdir18, readdir as readdir10, stat as stat10 } from "node:fs/promises";
 import { join as join48, relative as relative11, dirname as dirname17 } from "node:path";
 async function pathExists(path5) {
   try {
@@ -143184,7 +143585,7 @@ function createSkillsAdapter(options) {
       const settingsPath = options.getSettingsPath(rootDir);
       const settingsDir = dirname17(settingsPath);
       if (!await pathExists(settingsDir)) {
-        await mkdir17(settingsDir, { recursive: true });
+        await mkdir18(settingsDir, { recursive: true });
       }
       let settings = {};
       if (await pathExists(settingsPath)) {
@@ -143213,7 +143614,7 @@ function createSkillsAdapter(options) {
         }
         skills.push(`${prefix}${skillPath}`);
         settings.skills = skills;
-        await writeFile15(settingsPath, JSON.stringify(settings, null, 2));
+        await writeFile16(settingsPath, JSON.stringify(settings, null, 2));
         return {
           settingsPath: "skills",
           pattern: `${prefix}${skillPath}`,
@@ -143250,7 +143651,7 @@ function createSkillsAdapter(options) {
         }
         pkgEntry.skills.push(`${prefix}${skillPath}`);
         settings.packages = packages;
-        await writeFile15(settingsPath, JSON.stringify(settings, null, 2));
+        await writeFile16(settingsPath, JSON.stringify(settings, null, 2));
         return {
           settingsPath: "packages[].skills",
           pattern: `${prefix}${skillPath}`,
@@ -143725,7 +144126,7 @@ var init_task_lifecycle = __esm({
 // src/commands/port-prompt.ts
 import { createInterface } from "node:readline";
 function promptForPort(defaultPort = 4040, input = process.stdin) {
-  return new Promise((resolve36, reject2) => {
+  return new Promise((resolve39, reject2) => {
     const rl = createInterface({
       input,
       output: process.stdout
@@ -143742,7 +144143,7 @@ function promptForPort(defaultPort = 4040, input = process.stdin) {
         if (trimmed === "") {
           process.removeListener("SIGINT", sigintHandler);
           rl.close();
-          resolve36(defaultPort);
+          resolve39(defaultPort);
           return;
         }
         const port = parseInt(trimmed, 10);
@@ -143758,7 +144159,7 @@ function promptForPort(defaultPort = 4040, input = process.stdin) {
         }
         process.removeListener("SIGINT", sigintHandler);
         rl.close();
-        resolve36(port);
+        resolve39(port);
       });
     };
     ask();
@@ -143771,16 +144172,16 @@ var init_port_prompt = __esm({
 });
 
 // src/commands/provider-settings.ts
-import { existsSync as existsSync31, readFileSync as readFileSync12, writeFileSync as writeFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
-import { join as join49, dirname as dirname18, basename as basename12 } from "node:path";
+import { existsSync as existsSync32, readFileSync as readFileSync12, writeFileSync as writeFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
+import { join as join49, dirname as dirname18, basename as basename13 } from "node:path";
 function siblingAgentDir2(agentDir, siblingRoot) {
-  if (basename12(agentDir) !== "agent") {
+  if (basename13(agentDir) !== "agent") {
     return void 0;
   }
   return join49(dirname18(dirname18(agentDir)), siblingRoot, "agent");
 }
 function readJsonObject4(path5) {
-  if (!existsSync31(path5)) {
+  if (!existsSync32(path5)) {
     return {};
   }
   try {
@@ -143812,7 +144213,7 @@ var init_provider_settings = __esm({
 });
 
 // src/commands/provider-auth.ts
-import { existsSync as existsSync32, readFileSync as readFileSync13 } from "node:fs";
+import { existsSync as existsSync33, readFileSync as readFileSync13 } from "node:fs";
 import { getOAuthProvider as getOAuthProvider2 } from "@mariozechner/pi-ai/oauth";
 function getProviderDisplayName(providerId) {
   const knownProviderNames = new Map(
@@ -143941,7 +144342,7 @@ function createReadOnlyAuthFileStorage(authPaths) {
   const reload = () => {
     const nextCredentials = {};
     for (const authPath of authPaths) {
-      if (!existsSync32(authPath)) {
+      if (!existsSync33(authPath)) {
         continue;
       }
       try {
@@ -143982,7 +144383,7 @@ var init_provider_auth = __esm({
 
 // src/commands/auth-paths.ts
 import { homedir as homedir7 } from "node:os";
-import { existsSync as existsSync33, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync34, readFileSync as readFileSync14 } from "node:fs";
 import { join as join50 } from "node:path";
 function getFusionAgentDir3(home = process.env.HOME || process.env.USERPROFILE || homedir7()) {
   return join50(home, ".fusion", "agent");
@@ -144010,13 +144411,13 @@ function getLegacyModelsPaths2(home = process.env.HOME || process.env.USERPROFIL
 }
 function getModelRegistryModelsPath2(home = process.env.HOME || process.env.USERPROFILE || homedir7()) {
   const fusionModelsPath = getFusionModelsPath2(home);
-  if (existsSync33(fusionModelsPath)) {
+  if (existsSync34(fusionModelsPath)) {
     return fusionModelsPath;
   }
-  return getLegacyModelsPaths2(home).find((modelsPath) => existsSync33(modelsPath)) ?? fusionModelsPath;
+  return getLegacyModelsPaths2(home).find((modelsPath) => existsSync34(modelsPath)) ?? fusionModelsPath;
 }
 function readJsonObject5(path5) {
-  if (!existsSync33(path5)) {
+  if (!existsSync34(path5)) {
     return {};
   }
   try {
@@ -144034,13 +144435,13 @@ function getPackageManagerAgentDir2(home = process.env.HOME || process.env.USERP
   const legacyAgentDir = getLegacyAgentDir(home);
   const fusionSettings = readJsonObject5(join50(fusionAgentDir, "settings.json"));
   const legacySettings = readJsonObject5(join50(legacyAgentDir, "settings.json"));
-  if (hasPackageManagerSettings3(fusionSettings) || !existsSync33(legacyAgentDir)) {
+  if (hasPackageManagerSettings3(fusionSettings) || !existsSync34(legacyAgentDir)) {
     return fusionAgentDir;
   }
   if (hasPackageManagerSettings3(legacySettings)) {
     return legacyAgentDir;
   }
-  return existsSync33(fusionAgentDir) ? fusionAgentDir : legacyAgentDir;
+  return existsSync34(fusionAgentDir) ? fusionAgentDir : legacyAgentDir;
 }
 var init_auth_paths2 = __esm({
   "src/commands/auth-paths.ts"() {
@@ -144049,8 +144450,8 @@ var init_auth_paths2 = __esm({
 });
 
 // src/project-context.ts
-import { resolve as resolve23, dirname as dirname19 } from "node:path";
-import { existsSync as existsSync34 } from "node:fs";
+import { resolve as resolve26, dirname as dirname19 } from "node:path";
+import { existsSync as existsSync35 } from "node:fs";
 async function resolveProject(projectNameFlag, cwd = process.cwd(), globalDir) {
   const central = new CentralCore(globalDir);
   await central.init();
@@ -144141,10 +144542,10 @@ async function clearDefaultProject(globalDir) {
   await globalStore.updateSettings(rest);
 }
 async function detectProjectFromCwd(cwd, central) {
-  let currentDir = resolve23(cwd);
+  let currentDir = resolve26(cwd);
   while (true) {
-    const kbPath = resolve23(currentDir, ".fusion", "fusion.db");
-    if (existsSync34(kbPath)) {
+    const kbPath = resolve26(currentDir, ".fusion", "fusion.db");
+    if (existsSync35(kbPath)) {
       const project = await central.getProjectByPath(currentDir);
       if (project) {
         return project;
@@ -144199,7 +144600,7 @@ var init_project_context = __esm({
 // src/commands/claude-skills.ts
 import {
   cpSync,
-  existsSync as existsSync35,
+  existsSync as existsSync36,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync7,
   readlinkSync,
@@ -144207,7 +144608,7 @@ import {
   symlinkSync,
   unlinkSync
 } from "node:fs";
-import { dirname as dirname20, join as join51, resolve as resolve24 } from "node:path";
+import { dirname as dirname20, join as join51, resolve as resolve27 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function isPiClaudeCliConfigured(globalSettings) {
   if (!globalSettings || typeof globalSettings !== "object") {
@@ -144227,8 +144628,8 @@ function isPiClaudeCliConfigured(globalSettings) {
 }
 function resolveFusionSkillSource() {
   const here = fileURLToPath5(import.meta.url);
-  const candidate = resolve24(dirname20(here), "..", "..", "skill", FUSION_SKILL_NAME);
-  return existsSync35(candidate) ? candidate : null;
+  const candidate = resolve27(dirname20(here), "..", "..", "skill", FUSION_SKILL_NAME);
+  return existsSync36(candidate) ? candidate : null;
 }
 function installFusionSkillIntoProject(projectPath, options = {}) {
   const target = join51(projectPath, ".claude", "skills", FUSION_SKILL_NAME);
@@ -144246,18 +144647,18 @@ function installFusionSkillIntoProject(projectPath, options = {}) {
   try {
     mkdirSync7(dirname20(target), { recursive: true });
     let replaced = false;
-    if (existsSync35(target) || isBrokenSymlink(target)) {
+    if (existsSync36(target) || isBrokenSymlink(target)) {
       const stat12 = lstatSync2(target);
       if (stat12.isSymbolicLink()) {
         const current = safeReadlink(target);
-        if (current && resolve24(dirname20(target), current) === resolve24(source)) {
+        if (current && resolve27(dirname20(target), current) === resolve27(source)) {
           return { outcome: "already-installed", target, source };
         }
         unlinkSync(target);
         replaced = true;
       } else {
         const skillMd = join51(target, "SKILL.md");
-        if (!existsSync35(skillMd)) {
+        if (!existsSync36(skillMd)) {
           return {
             outcome: "failed",
             target,
@@ -144316,7 +144717,7 @@ function isBrokenSymlink(path5) {
   try {
     const stat12 = lstatSync2(path5);
     if (!stat12.isSymbolicLink()) return false;
-    return !existsSync35(path5);
+    return !existsSync36(path5);
   } catch {
     return false;
   }
@@ -144413,16 +144814,16 @@ var init_claude_skills_runner = __esm({
 });
 
 // src/commands/claude-cli-extension.ts
-import { existsSync as existsSync36, readFileSync as readFileSync15 } from "node:fs";
+import { existsSync as existsSync37, readFileSync as readFileSync15 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname21, resolve as resolve25 } from "node:path";
+import { dirname as dirname21, resolve as resolve28 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function resolveClaudeCliExtensionFromModuleUrl(moduleUrl) {
   let pkgJsonPath;
   const here = dirname21(fileURLToPath6(moduleUrl));
   for (const rel of ["pi-claude-cli", "../pi-claude-cli", "../../pi-claude-cli"]) {
-    const candidate = resolve25(here, rel, "package.json");
-    if (existsSync36(candidate)) {
+    const candidate = resolve28(here, rel, "package.json");
+    if (existsSync37(candidate)) {
       pkgJsonPath = candidate;
       break;
     }
@@ -144457,8 +144858,8 @@ function resolveClaudeCliExtensionFromModuleUrl(moduleUrl) {
       reason: "@fusion/pi-claude-cli pi.extensions[0] is not a valid path string"
     };
   }
-  const entryPath = resolve25(dirname21(pkgJsonPath), rawEntry);
-  if (!existsSync36(entryPath)) {
+  const entryPath = resolve28(dirname21(pkgJsonPath), rawEntry);
+  if (!existsSync37(entryPath)) {
     return {
       status: "missing-entry",
       reason: `@fusion/pi-claude-cli extension file not found at ${entryPath}`
@@ -144542,17 +144943,17 @@ var init_update_cache = __esm({
 });
 
 // src/commands/self-extension.ts
-import { existsSync as existsSync37, readFileSync as readFileSync17 } from "node:fs";
-import { dirname as dirname22, resolve as resolve26 } from "node:path";
+import { existsSync as existsSync38, readFileSync as readFileSync17 } from "node:fs";
+import { dirname as dirname22, resolve as resolve29 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function resolveSelfExtension() {
   const here = dirname22(fileURLToPath7(import.meta.url));
   let pkgDir;
   let cur = here;
   for (let i = 0; i < 5; i++) {
-    if (existsSync37(resolve26(cur, "package.json"))) {
+    if (existsSync38(resolve29(cur, "package.json"))) {
       try {
-        const parsed = JSON.parse(readFileSync17(resolve26(cur, "package.json"), "utf-8"));
+        const parsed = JSON.parse(readFileSync17(resolve29(cur, "package.json"), "utf-8"));
         if (parsed.name === "@runfusion/fusion") {
           pkgDir = cur;
           break;
@@ -144560,7 +144961,7 @@ function resolveSelfExtension() {
       } catch {
       }
     }
-    const parent2 = resolve26(cur, "..");
+    const parent2 = resolve29(cur, "..");
     if (parent2 === cur) break;
     cur = parent2;
   }
@@ -144569,12 +144970,12 @@ function resolveSelfExtension() {
   }
   let pkgJson;
   try {
-    pkgJson = JSON.parse(readFileSync17(resolve26(pkgDir, "package.json"), "utf-8"));
+    pkgJson = JSON.parse(readFileSync17(resolve29(pkgDir, "package.json"), "utf-8"));
   } catch (err) {
     return { status: "missing", reason: `Failed to read @runfusion/fusion package.json: ${err instanceof Error ? err.message : String(err)}` };
   }
-  const srcEntry = resolve26(pkgDir, "src", "extension.ts");
-  if (existsSync37(srcEntry)) {
+  const srcEntry = resolve29(pkgDir, "src", "extension.ts");
+  if (existsSync38(srcEntry)) {
     return { status: "ok", path: srcEntry, packageVersion: pkgJson.version ?? "unknown" };
   }
   const extensions = pkgJson.pi?.extensions;
@@ -144585,8 +144986,8 @@ function resolveSelfExtension() {
   if (typeof rawEntry !== "string" || rawEntry.length === 0) {
     return { status: "missing", reason: "@runfusion/fusion pi.extensions[0] is not a valid path string" };
   }
-  const entryPath = resolve26(pkgDir, rawEntry);
-  if (!existsSync37(entryPath)) {
+  const entryPath = resolve29(pkgDir, rawEntry);
+  if (!existsSync38(entryPath)) {
     return { status: "missing", reason: `@runfusion/fusion extension file not found at ${entryPath}` };
   }
   return { status: "ok", path: entryPath, packageVersion: pkgJson.version ?? "unknown" };
@@ -144645,21 +145046,21 @@ var init_state = __esm({
 });
 
 // src/commands/dashboard-tui/logo.ts
-import { existsSync as existsSync38, readFileSync as readFileSync18 } from "node:fs";
-import { dirname as dirname23, resolve as resolve27 } from "node:path";
+import { existsSync as existsSync39, readFileSync as readFileSync18 } from "node:fs";
+import { dirname as dirname23, resolve as resolve30 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function readFusionVersion() {
   try {
     let cur = dirname23(fileURLToPath8(import.meta.url));
     for (let i = 0; i < 6; i++) {
-      const pkgPath = resolve27(cur, "package.json");
-      if (existsSync38(pkgPath)) {
+      const pkgPath = resolve30(cur, "package.json");
+      if (existsSync39(pkgPath)) {
         const parsed = JSON.parse(readFileSync18(pkgPath, "utf-8"));
         if (parsed.name === "@runfusion/fusion" && typeof parsed.version === "string") {
           return parsed.version;
         }
       }
-      const parent2 = resolve27(cur, "..");
+      const parent2 = resolve30(cur, "..");
       if (parent2 === cur) break;
       cur = parent2;
     }
@@ -144764,14 +145165,14 @@ async function copyToClipboard(text) {
     { cmd: "xsel", args: ["--clipboard", "--input"] }
   ];
   for (const { cmd, args } of candidates) {
-    const ok = await new Promise((resolve36) => {
+    const ok = await new Promise((resolve39) => {
       try {
         const child = spawn11(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
-        child.once("error", () => resolve36(false));
-        child.once("close", (code) => resolve36(code === 0));
+        child.once("error", () => resolve39(false));
+        child.once("close", (code) => resolve39(code === 0));
         child.stdin.end(text);
       } catch {
-        resolve36(false);
+        resolve39(false);
       }
     });
     if (ok) return true;
@@ -144932,9 +145333,9 @@ function SystemPanel({ state, isFocused }) {
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Uptime" }),
       /* @__PURE__ */ jsx(Text, { children: formatUptime(Date.now() - info.startTimeMs) })
     ] }),
-    info.authToken && /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, flexShrink: 1, children: [
+    info.authToken && /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, flexShrink: 0, children: [
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Token" }),
-      /* @__PURE__ */ jsx(Text, { wrap: "truncate-end", color: "yellow", children: info.authToken })
+      /* @__PURE__ */ jsx(Text, { color: "yellow", children: info.authToken })
     ] })
   ] }) });
 }
@@ -145275,7 +145676,7 @@ function StatusModeGrid({
   const rows = stdout?.rows ?? 24;
   const cols = stdout?.columns ?? 80;
   const middleHeight = Math.max(1, rows - 2);
-  const SYSTEM_HEIGHT = 4;
+  const SYSTEM_HEIGHT = state.systemInfo?.authToken ? 5 : 4;
   const bottomShare = Math.min(10, Math.max(6, Math.floor(middleHeight * 0.35)));
   const logsShare = Math.max(1, middleHeight - SYSTEM_HEIGHT - bottomShare);
   const logsAvailableRows = Math.max(1, logsShare - 4);
@@ -145284,7 +145685,7 @@ function StatusModeGrid({
   tuiDebug("StatusModeGrid", { cols, rows, middleHeight, logsShare, bottomShare, focused, wideLayout });
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [
     /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: [
-      /* @__PURE__ */ jsx(Box, { height: 4, flexShrink: 0, overflow: "hidden", children: /* @__PURE__ */ jsx(SystemPanel, { state, isFocused: focused === "system" }) }),
+      /* @__PURE__ */ jsx(Box, { height: SYSTEM_HEIGHT, flexShrink: 0, overflow: "hidden", children: /* @__PURE__ */ jsx(SystemPanel, { state, isFocused: focused === "system" }) }),
       wideLayout ? /* @__PURE__ */ jsxs(Fragment, { children: [
         /* @__PURE__ */ jsxs(Box, { flexGrow: 1, flexShrink: 0, flexDirection: "row", overflow: "hidden", children: [
           /* @__PURE__ */ jsx(Box, { flexDirection: "column", width: "30%", flexShrink: 0, overflow: "hidden", children: /* @__PURE__ */ jsx(StatsPanel, { state, isFocused: focused === "stats" }) }),
@@ -149904,8 +150305,8 @@ async function runDashboard(port, opts = {}) {
       try {
         const updateCheckEnabled = await Promise.race([
           isUpdateCheckEnabled(),
-          new Promise((resolve36) => {
-            setTimeout(() => resolve36(false), 3e3);
+          new Promise((resolve39) => {
+            setTimeout(() => resolve39(false), 3e3);
           })
         ]);
         if (!updateCheckEnabled) {
@@ -151300,8 +151701,8 @@ async function runServe(port, opts = {}) {
     https: loadTlsCredentialsFromEnv()
   });
   const server = app.listen(selectedPort, selectedHost);
-  await new Promise((resolve36, reject2) => {
-    server.once("listening", resolve36);
+  await new Promise((resolve39, reject2) => {
+    server.once("listening", resolve39);
     server.once("error", reject2);
   });
   const actualPort = server.address().port;
@@ -151819,8 +152220,8 @@ async function runDaemon(opts = {}) {
     https: loadTlsCredentialsFromEnv()
   });
   const server = app.listen(selectedPort, selectedHost);
-  await new Promise((resolve36, reject2) => {
-    server.once("listening", resolve36);
+  await new Promise((resolve39, reject2) => {
+    server.once("listening", resolve39);
     server.once("error", reject2);
   });
   const actualPort = server.address().port;
@@ -151934,7 +152335,7 @@ import { once as once2 } from "node:events";
 import { join as join56 } from "node:path";
 import { createRequire as createRequire5 } from "node:module";
 function runCommand(command, args, cwd) {
-  return new Promise((resolve36, reject2) => {
+  return new Promise((resolve39, reject2) => {
     const child = spawn13(command, args, {
       cwd,
       stdio: "inherit",
@@ -151943,7 +152344,7 @@ function runCommand(command, args, cwd) {
     child.on("error", (error) => reject2(error));
     child.on("exit", (code) => {
       if (code === 0) {
-        resolve36();
+        resolve39();
         return;
       }
       reject2(new Error(`${command} ${args.join(" ")} exited with code ${code ?? "unknown"}`));
@@ -151986,8 +152387,8 @@ async function startDashboardRuntime(rootDir, paused) {
   };
 }
 async function closeDashboardRuntime(runtime) {
-  await new Promise((resolve36) => {
-    runtime.server.close(() => resolve36());
+  await new Promise((resolve39) => {
+    runtime.server.close(() => resolve39());
   });
   runtime.store.close();
 }
@@ -152095,7 +152496,7 @@ __export(task_exports, {
   runTaskUpdate: () => runTaskUpdate
 });
 import { createInterface as createInterface3 } from "node:readline/promises";
-import { watchFile, unwatchFile, statSync as statSync6, existsSync as existsSync39, readFileSync as readFileSync19 } from "node:fs";
+import { watchFile, unwatchFile, statSync as statSync6, existsSync as existsSync40, readFileSync as readFileSync19 } from "node:fs";
 import { join as join57 } from "node:path";
 function asLocalProjectContext(store) {
   const cwd = process.cwd();
@@ -152216,10 +152617,10 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName,
   console.log(`    Path:   .fusion/tasks/${task.id}/`);
   if (attachFiles && attachFiles.length > 0) {
     const { readFile: readFile24 } = await import("node:fs/promises");
-    const { basename: basename16, extname: extname2, resolve: resolve36 } = await import("node:path");
+    const { basename: basename17, extname: extname2, resolve: resolve39 } = await import("node:path");
     for (const filePath of attachFiles) {
-      const resolvedPath = resolve36(filePath);
-      const filename = basename16(resolvedPath);
+      const resolvedPath = resolve39(filePath);
+      const filename = basename17(resolvedPath);
       const ext = extname2(filename).toLowerCase();
       const mimeType = MIME_TYPES[ext];
       if (!mimeType) {
@@ -152353,7 +152754,7 @@ async function runTaskLogs(id, options = {}, projectName) {
   if (options.follow) {
     const projectPath = projectContext?.projectPath ?? process.cwd();
     const logPath = join57(projectPath, ".fusion", "tasks", id, "agent.log");
-    if (!existsSync39(logPath)) {
+    if (!existsSync40(logPath)) {
       console.log(`
   Waiting for log file to be created...`);
     }
@@ -152511,10 +152912,10 @@ async function runTaskMerge(id, projectName) {
 }
 async function runTaskAttach(id, filePath, projectName) {
   const { readFile: readFile24 } = await import("node:fs/promises");
-  const { basename: basename16, extname: extname2 } = await import("node:path");
-  const { resolve: resolve36 } = await import("node:path");
-  const resolvedPath = resolve36(filePath);
-  const filename = basename16(resolvedPath);
+  const { basename: basename17, extname: extname2 } = await import("node:path");
+  const { resolve: resolve39 } = await import("node:path");
+  const resolvedPath = resolve39(filePath);
+  const filename = basename17(resolvedPath);
   const ext = extname2(filename).toLowerCase();
   const mimeType = MIME_TYPES[ext];
   if (!mimeType) {
@@ -153044,12 +153445,12 @@ async function promptText(question) {
   console.log("  (Enter your response. Type DONE on its own line when finished):\n");
   const rl = createInterface3({ input: process.stdin, output: process.stdout });
   const lines = [];
-  return new Promise((resolve36) => {
+  return new Promise((resolve39) => {
     const askLine = () => {
       rl.question("  ").then((line) => {
         if (line.trim() === "DONE") {
           rl.close();
-          resolve36(lines.join("\n"));
+          resolve39(lines.join("\n"));
         } else {
           lines.push(line);
           askLine();
@@ -153616,8 +154017,8 @@ var settings_export_exports = {};
 __export(settings_export_exports, {
   runSettingsExport: () => runSettingsExport
 });
-import { writeFile as writeFile16 } from "node:fs/promises";
-import { resolve as resolve28, join as join58 } from "node:path";
+import { writeFile as writeFile17 } from "node:fs/promises";
+import { resolve as resolve31, join as join58 } from "node:path";
 async function runSettingsExport(options = {}) {
   const scope = options.scope ?? "both";
   const project = options.projectName ? await resolveProject(options.projectName) : void 0;
@@ -153628,13 +154029,13 @@ async function runSettingsExport(options = {}) {
     const exportData = await exportSettings(store, { scope });
     let targetPath;
     if (outputPath) {
-      targetPath = resolve28(outputPath);
+      targetPath = resolve31(outputPath);
     } else {
       const filename = generateExportFilename();
       targetPath = join58(process.cwd(), filename);
     }
     const jsonContent = JSON.stringify(exportData, null, 2);
-    await writeFile16(targetPath, jsonContent);
+    await writeFile17(targetPath, jsonContent);
     console.log();
     console.log(`  \u2713 Settings exported to ${targetPath}`);
     const parts = [];
@@ -153677,8 +154078,8 @@ var settings_import_exports = {};
 __export(settings_import_exports, {
   runSettingsImport: () => runSettingsImport
 });
-import { existsSync as existsSync40 } from "node:fs";
-import { resolve as resolve29 } from "node:path";
+import { existsSync as existsSync41 } from "node:fs";
+import { resolve as resolve32 } from "node:path";
 async function runSettingsImport(filePath, options = {}) {
   const scope = options.scope ?? "both";
   const project = options.projectName ? await resolveProject(options.projectName) : void 0;
@@ -153687,8 +154088,8 @@ async function runSettingsImport(filePath, options = {}) {
   const merge = options.merge ?? true;
   const skipConfirm = options.yes ?? false;
   try {
-    const resolvedPath = resolve29(filePath);
-    if (!existsSync40(resolvedPath)) {
+    const resolvedPath = resolve32(filePath);
+    if (!existsSync41(resolvedPath)) {
       console.error(`Error: File not found: ${filePath}`);
       process.exit(1);
     }
@@ -154161,8 +154562,8 @@ var init_backup2 = __esm({
 });
 
 // src/project-resolver.ts
-import { existsSync as existsSync41, statSync as statSync7 } from "node:fs";
-import { dirname as dirname24, resolve as resolve30, normalize as normalize5 } from "node:path";
+import { existsSync as existsSync42, statSync as statSync7 } from "node:fs";
+import { dirname as dirname24, resolve as resolve33, normalize as normalize5 } from "node:path";
 import { createInterface as createInterface5 } from "node:readline/promises";
 async function getCentralCore() {
   if (!centralCoreInstance) {
@@ -154179,10 +154580,10 @@ async function getProjectManager() {
   return projectManagerInstance;
 }
 function findKbDir(startPath) {
-  let current = resolve30(startPath);
+  let current = resolve33(startPath);
   for (let i = 0; i < 100; i++) {
-    const kbPath = resolve30(current, ".fusion");
-    if (existsSync41(kbPath) && statSync7(kbPath).isDirectory()) {
+    const kbPath = resolve33(current, ".fusion");
+    if (existsSync42(kbPath) && statSync7(kbPath).isDirectory()) {
       return current;
     }
     const parent2 = dirname24(current);
@@ -154237,7 +154638,7 @@ async function resolveProject2(options = {}) {
         { searchedName: options.project, availableProjects: projects.map((p) => p.name) }
       );
     }
-    if (!existsSync41(match.path)) {
+    if (!existsSync42(match.path)) {
       throw new ProjectResolutionError(
         `Project "${match.name}" is registered but the directory no longer exists: ${match.path}
 
@@ -154248,14 +154649,14 @@ Run \`fn project remove ` + match.name + "` to clean up the registry entry.",
     }
     return createResolvedProject(match);
   }
-  const cwd = options.cwd ? resolve30(options.cwd) : process.cwd();
+  const cwd = options.cwd ? resolve33(options.cwd) : process.cwd();
   const fusionDir = findKbDir(cwd);
   if (fusionDir) {
     const allProjects2 = await central.listProjects();
     const normalizedKbDir = normalize5(fusionDir);
     const match = allProjects2.find((p) => normalize5(p.path) === normalizedKbDir);
     if (match) {
-      if (!existsSync41(match.path)) {
+      if (!existsSync42(match.path)) {
         throw new ProjectResolutionError(
           `Project "${match.name}" is registered but the directory no longer exists: ${match.path}
 
@@ -154320,7 +154721,7 @@ Run \`fn project add ` + fusionDir + "` to register it, or use --project <name>.
   }
   if (allProjects.length === 1) {
     const project = allProjects[0];
-    if (!existsSync41(project.path)) {
+    if (!existsSync42(project.path)) {
       throw new ProjectResolutionError(
         `The only registered project "${project.name}" has a missing directory: ${project.path}
 
@@ -154760,15 +155161,15 @@ __export(project_exports, {
   runProjectSetDefault: () => runProjectSetDefault,
   runProjectShow: () => runProjectShow
 });
-import { resolve as resolve31, isAbsolute as isAbsolute16, relative as relative12, basename as basename13 } from "node:path";
-import { existsSync as existsSync42, statSync as statSync8 } from "node:fs";
+import { resolve as resolve34, isAbsolute as isAbsolute16, relative as relative12, basename as basename14 } from "node:path";
+import { existsSync as existsSync43, statSync as statSync8 } from "node:fs";
 import { createInterface as createInterface7 } from "node:readline/promises";
 function formatDisplayPath(projectPath) {
   const rel = relative12(process.cwd(), projectPath);
   if (rel && !rel.startsWith("..") && rel !== "") {
     return rel;
   }
-  return basename13(projectPath) || ".";
+  return basename14(projectPath) || ".";
 }
 function formatLastActivity2(timestamp) {
   if (!timestamp) return "never";
@@ -154889,8 +155290,8 @@ async function runProjectAdd(name, path5, options = {}) {
         const pathInput = await rl.question(`  Project path [${defaultPath}]: `);
         projectPath = pathInput.trim() || defaultPath;
       }
-      const absolutePath2 = isAbsolute16(projectPath) ? projectPath : resolve31(process.cwd(), projectPath);
-      if (!existsSync42(absolutePath2)) {
+      const absolutePath2 = isAbsolute16(projectPath) ? projectPath : resolve34(process.cwd(), projectPath);
+      if (!existsSync43(absolutePath2)) {
         console.error(`
   \u2717 Path does not exist: ${projectPath}`);
         rl.close();
@@ -154902,8 +155303,8 @@ async function runProjectAdd(name, path5, options = {}) {
         rl.close();
         process.exit(1);
       }
-      const kbDbPath2 = resolve31(absolutePath2, ".fusion", "fusion.db");
-      if (!existsSync42(kbDbPath2) && !options.force) {
+      const kbDbPath2 = resolve34(absolutePath2, ".fusion", "fusion.db");
+      if (!existsSync43(kbDbPath2) && !options.force) {
         console.log(`
   No fn project found at ${formatDisplayPath(absolutePath2)}`);
         const init = await rl.question("  Initialize fn here first? [Y/n] ");
@@ -154918,7 +155319,7 @@ async function runProjectAdd(name, path5, options = {}) {
         }
       }
       if (!projectName) {
-        const suggested = basename13(absolutePath2);
+        const suggested = basename14(absolutePath2);
         projectName = await rl.question(`  Project name [${suggested}]: `);
         projectName = projectName.trim() || suggested;
       }
@@ -154934,8 +155335,8 @@ async function runProjectAdd(name, path5, options = {}) {
       console.error("  Name must be 1-64 characters and contain only: a-z, A-Z, 0-9, _, -\n");
       process.exit(1);
     }
-    const absolutePath = isAbsolute16(projectPath) ? projectPath : resolve31(process.cwd(), projectPath);
-    if (!existsSync42(absolutePath)) {
+    const absolutePath = isAbsolute16(projectPath) ? projectPath : resolve34(process.cwd(), projectPath);
+    if (!existsSync43(absolutePath)) {
       console.error(`
   \u2717 Path does not exist: ${projectPath}
 `);
@@ -154947,8 +155348,8 @@ async function runProjectAdd(name, path5, options = {}) {
 `);
       process.exit(1);
     }
-    const kbDbPath = resolve31(absolutePath, ".fusion", "fusion.db");
-    if (!existsSync42(kbDbPath) && !options.force) {
+    const kbDbPath = resolve34(absolutePath, ".fusion", "fusion.db");
+    if (!existsSync43(kbDbPath) && !options.force) {
       console.error(`
   \u2717 No fn project found at ${formatDisplayPath(absolutePath)}`);
       console.error("  Run `fn init` first to initialize the project.\n");
@@ -155204,9 +155605,9 @@ var init_project = __esm({
 });
 
 // src/commands/skill-installation.ts
-import { cpSync as cpSync2, existsSync as existsSync43, mkdirSync as mkdirSync8 } from "node:fs";
+import { cpSync as cpSync2, existsSync as existsSync44, mkdirSync as mkdirSync8 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname25, join as join59, resolve as resolve32 } from "node:path";
+import { dirname as dirname25, join as join59, resolve as resolve35 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 function getSupportedSkillInstallTargets(homeDir = process.env.HOME || process.env.USERPROFILE || homedir8()) {
   return [
@@ -155217,8 +155618,8 @@ function getSupportedSkillInstallTargets(homeDir = process.env.HOME || process.e
 }
 function resolveBundledFusionSkillSource() {
   const here = fileURLToPath9(import.meta.url);
-  const source = resolve32(dirname25(here), "..", "..", "skill", FUSION_SKILL_NAME2);
-  return existsSync43(source) ? source : null;
+  const source = resolve35(dirname25(here), "..", "..", "skill", FUSION_SKILL_NAME2);
+  return existsSync44(source) ? source : null;
 }
 function installBundledFusionSkill(options = {}) {
   const sourceDir = options.sourceDir ?? resolveBundledFusionSkillSource();
@@ -155236,7 +155637,7 @@ function installBundledFusionSkill(options = {}) {
   }
   const results = targets.map((target) => {
     try {
-      if (existsSync43(target.targetDir)) {
+      if (existsSync44(target.targetDir)) {
         return {
           client: target.client,
           targetDir: target.targetDir,
@@ -155275,15 +155676,15 @@ var init_exports = {};
 __export(init_exports, {
   runInit: () => runInit
 });
-import { existsSync as existsSync44, mkdirSync as mkdirSync9, writeFileSync as writeFileSync3, readFileSync as readFileSync20 } from "node:fs";
-import { join as join60, resolve as resolve33, basename as basename14 } from "node:path";
+import { existsSync as existsSync45, mkdirSync as mkdirSync9, writeFileSync as writeFileSync3, readFileSync as readFileSync20 } from "node:fs";
+import { join as join60, resolve as resolve36, basename as basename15 } from "node:path";
 import { exec as exec11 } from "node:child_process";
 import { promisify as promisify16 } from "node:util";
 async function runInit(options = {}) {
-  const cwd = options.path ? resolve33(options.path) : process.cwd();
+  const cwd = options.path ? resolve36(options.path) : process.cwd();
   const fusionDir = join60(cwd, ".fusion");
   const dbPath = join60(fusionDir, "fusion.db");
-  if (existsSync44(fusionDir) && existsSync44(dbPath)) {
+  if (existsSync45(fusionDir) && existsSync45(dbPath)) {
     const central2 = new CentralCore();
     await central2.init();
     const existing = await central2.getProjectByPath(cwd);
@@ -155308,7 +155709,7 @@ async function runInit(options = {}) {
   const projectName = options.name ?? await detectProjectName(cwd);
   console.log(`Initializing fn project: "${projectName}"`);
   console.log(`  Path: ${cwd}`);
-  if (!existsSync44(fusionDir)) {
+  if (!existsSync45(fusionDir)) {
     mkdirSync9(fusionDir, { recursive: true });
     console.log(`  \u2713 Created .fusion/ directory`);
   }
@@ -155321,7 +155722,7 @@ async function runInit(options = {}) {
   }
   await addLocalStorageToGitignore(cwd);
   await warnIfQmdMissing();
-  if (!existsSync44(dbPath)) {
+  if (!existsSync45(dbPath)) {
     const sqliteHeader = Buffer.from([
       83,
       81,
@@ -155389,8 +155790,8 @@ async function runInit(options = {}) {
   }
 }
 async function detectProjectName(dir2) {
-  if (!existsSync44(join60(dir2, ".git"))) {
-    return basename14(dir2) || "my-project";
+  if (!existsSync45(join60(dir2, ".git"))) {
+    return basename15(dir2) || "my-project";
   }
   try {
     const { stdout: remoteUrl } = await execAsync11("git remote get-url origin", {
@@ -155406,12 +155807,12 @@ async function detectProjectName(dir2) {
     }
   } catch {
   }
-  return basename14(dir2) || "my-project";
+  return basename15(dir2) || "my-project";
 }
 async function addLocalStorageToGitignore(cwd) {
   const gitignorePath = join60(cwd, ".gitignore");
   let content = "";
-  if (existsSync44(gitignorePath)) {
+  if (existsSync45(gitignorePath)) {
     try {
       content = readFileSync20(gitignorePath, "utf-8");
     } catch {
@@ -155453,7 +155854,7 @@ async function initializeGitRepo(cwd) {
   await ensureGitConfig(cwd, "user.name", "Fusion");
   await ensureGitConfig(cwd, "user.email", "noreply@runfusion.ai");
   const gitkeepPath = join60(cwd, ".gitkeep");
-  if (!existsSync44(gitkeepPath)) {
+  if (!existsSync45(gitkeepPath)) {
     writeFileSync3(gitkeepPath, "\n");
   }
   await execAsync11("git add .gitkeep", { cwd, timeout: 1e4 });
@@ -155591,8 +155992,8 @@ var agent_import_exports = {};
 __export(agent_import_exports, {
   runAgentImport: () => runAgentImport
 });
-import { existsSync as existsSync45, mkdirSync as mkdirSync10, readFileSync as readFileSync21, statSync as statSync9, writeFileSync as writeFileSync4 } from "node:fs";
-import { resolve as resolve34 } from "node:path";
+import { existsSync as existsSync46, mkdirSync as mkdirSync10, readFileSync as readFileSync21, statSync as statSync9, writeFileSync as writeFileSync4 } from "node:fs";
+import { resolve as resolve37 } from "node:path";
 function slugifyPathSegment(input) {
   if (!input || typeof input !== "string") {
     return "unnamed";
@@ -155641,16 +156042,16 @@ async function importSkillsToProject(projectPath, skills, companySlug, dryRun) {
     errors: []
   };
   const companyDir = slugifyPathSegment(companySlug ?? "unknown-company");
-  const baseSkillsDir = resolve34(projectPath, "skills", "imported", companyDir);
+  const baseSkillsDir = resolve37(projectPath, "skills", "imported", companyDir);
   for (const skill of skills) {
     if (!skill.name || typeof skill.name !== "string" || skill.name.trim().length === 0) {
       result.errors.push({ name: "(unnamed)", error: "Skill is missing required 'name' field" });
       continue;
     }
     const skillSlug = slugifyPathSegment(skill.name);
-    const skillDir = resolve34(baseSkillsDir, skillSlug);
-    const skillPath = resolve34(skillDir, "SKILL.md");
-    if (existsSync45(skillPath)) {
+    const skillDir = resolve37(baseSkillsDir, skillSlug);
+    const skillPath = resolve37(skillDir, "SKILL.md");
+    if (existsSync46(skillPath)) {
       result.skipped.push(skill.name);
       continue;
     }
@@ -155722,8 +156123,8 @@ function isArchivePath(path5) {
 async function runAgentImport(source, options) {
   const dryRun = options?.dryRun ?? false;
   const skipExisting = options?.skipExisting ?? false;
-  const sourcePath = resolve34(source);
-  if (!existsSync45(sourcePath)) {
+  const sourcePath = resolve37(source);
+  if (!existsSync46(sourcePath)) {
     console.error(`Path not found: ${sourcePath}`);
     process.exit(1);
   }
@@ -155861,7 +156262,7 @@ var agent_export_exports = {};
 __export(agent_export_exports, {
   runAgentExport: () => runAgentExport
 });
-import { resolve as resolve35 } from "node:path";
+import { resolve as resolve38 } from "node:path";
 async function getProjectPath4(projectName) {
   if (projectName) {
     const context = await resolveProject(projectName);
@@ -155899,7 +156300,7 @@ async function runAgentExport(outputDir, options) {
     console.error("No agents found to export");
     process.exit(1);
   }
-  const result = await exportAgentsToDirectory(agents, resolve35(outputDir), {
+  const result = await exportAgentsToDirectory(agents, resolve38(outputDir), {
     companyName: options?.companyName,
     companySlug: options?.companySlug
   });
@@ -156118,7 +156519,7 @@ __export(plugin_exports, {
   runPluginList: () => runPluginList,
   runPluginUninstall: () => runPluginUninstall
 });
-import { existsSync as existsSync46 } from "node:fs";
+import { existsSync as existsSync47 } from "node:fs";
 import { join as join61 } from "node:path";
 import { readFile as readFile23 } from "node:fs/promises";
 import * as readline from "node:readline";
@@ -156158,7 +156559,7 @@ async function createPluginLoader(pluginStore, projectName) {
 }
 async function loadManifestFromPath(pluginPath) {
   const manifestPath = join61(pluginPath, "manifest.json");
-  if (!existsSync46(manifestPath)) {
+  if (!existsSync47(manifestPath)) {
     throw new Error(`Plugin manifest not found at: ${manifestPath}`);
   }
   const content = await readFile23(manifestPath, "utf-8");
@@ -156216,7 +156617,7 @@ async function runPluginInstall(source, options) {
     console.error("Please provide a local path to the plugin directory.");
     process.exit(1);
   }
-  if (!existsSync46(source)) {
+  if (!existsSync47(source)) {
     console.error(`Plugin path does not exist: ${source}`);
     process.exit(1);
   }
@@ -156261,14 +156662,14 @@ async function runPluginUninstall(id, options) {
     console.log(`  Uninstall "${plugin4.name}"?`);
     console.log(`  This will stop and remove the plugin.`);
     console.log();
-    const response = await new Promise((resolve36) => {
+    const response = await new Promise((resolve39) => {
       const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout
       });
       rl.question("  Continue? [y/N] ", (answer) => {
         rl.close();
-        resolve36(answer.toLowerCase());
+        resolve39(answer.toLowerCase());
       });
     });
     if (response !== "y" && response !== "yes") {
@@ -156348,7 +156749,7 @@ var plugin_scaffold_exports = {};
 __export(plugin_scaffold_exports, {
   runPluginCreate: () => runPluginCreate
 });
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync5, existsSync as existsSync47 } from "node:fs";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync5, existsSync as existsSync48 } from "node:fs";
 import { join as join62 } from "node:path";
 function toTitleCase(str) {
   return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
@@ -156483,7 +156884,7 @@ async function runPluginCreate(name, options) {
   }
   const targetDir = options?.output ?? name;
   const targetPath = join62(process.cwd(), targetDir);
-  if (existsSync47(targetPath)) {
+  if (existsSync48(targetPath)) {
     console.error(`Error: Directory '${targetDir}' already exists.`);
     console.error("Please choose a different name or remove the existing directory.");
     process.exit(1);
@@ -156616,9 +157017,9 @@ async function runSkillsInstall(args, options) {
     stdio: "inherit",
     shell: true
   });
-  const exitCode = await new Promise((resolve36, reject2) => {
+  const exitCode = await new Promise((resolve39, reject2) => {
     child.on("exit", (code) => {
-      resolve36(code ?? 1);
+      resolve39(code ?? 1);
     });
     child.on("error", (err) => {
       reject2(err);
@@ -156649,8 +157050,8 @@ __export(native_patch_exports, {
   isTerminalAvailable: () => isTerminalAvailable,
   setupNativeResolution: () => setupNativeResolution
 });
-import { join as join63, basename as basename15, dirname as dirname26 } from "node:path";
-import { existsSync as existsSync48, copyFileSync, mkdirSync as mkdirSync12, symlinkSync as symlinkSync2, rmSync as rmSync5, lstatSync as lstatSync3, readlinkSync as readlinkSync2 } from "node:fs";
+import { join as join63, basename as basename16, dirname as dirname26 } from "node:path";
+import { existsSync as existsSync49, copyFileSync, mkdirSync as mkdirSync12, symlinkSync as symlinkSync2, rmSync as rmSync5, lstatSync as lstatSync3, readlinkSync as readlinkSync2 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 function findStagedNativeDir2() {
   const platform3 = process.platform === "darwin" ? "darwin" : process.platform === "linux" ? "linux" : process.platform === "win32" ? "win32" : "unknown";
@@ -156658,12 +157059,12 @@ function findStagedNativeDir2() {
   const prebuildName = `${platform3}-${arch}`;
   const execDir = dirname26(process.execPath);
   const nextToBinary = join63(execDir, "runtime", prebuildName);
-  if (existsSync48(join63(nextToBinary, "pty.node"))) {
+  if (existsSync49(join63(nextToBinary, "pty.node"))) {
     return nextToBinary;
   }
   if (process.env.FUSION_RUNTIME_DIR) {
     const envPath = join63(process.env.FUSION_RUNTIME_DIR, prebuildName);
-    if (existsSync48(join63(envPath, "pty.node"))) {
+    if (existsSync49(join63(envPath, "pty.node"))) {
       return envPath;
     }
   }
@@ -156673,11 +157074,11 @@ function cleanupStaleBunfsLinks() {
   if (process.platform === "win32") return;
   const bunfsRoot = "/$bunfs/root";
   try {
-    if (existsSync48(bunfsRoot)) {
+    if (existsSync49(bunfsRoot)) {
       const stats = lstatSync3(bunfsRoot);
       if (stats.isSymbolicLink()) {
         const target = readlinkSync2(bunfsRoot);
-        if (target.includes("fn-bunfs-") && !existsSync48(target)) {
+        if (target.includes("fn-bunfs-") && !existsSync49(target)) {
           rmSync5(bunfsRoot);
           console.log("[fn-native-patch] Cleaned up stale /$bunfs/root symlink");
         }
@@ -156699,20 +157100,20 @@ function setupNativeResolution() {
   const tmpRoot = join63(tmpdir4(), `fn-bunfs-${process.pid}`);
   const fnDir = join63(tmpRoot, "fn");
   const prebuildsDir = join63(fnDir, "prebuilds");
-  const platformDir = join63(prebuildsDir, basename15(nativeDir));
+  const platformDir = join63(prebuildsDir, basename16(nativeDir));
   try {
     cleanupStaleBunfsLinks();
     mkdirSync12(platformDir, { recursive: true });
     const ptyNodeDest = join63(platformDir, "pty.node");
     copyFileSync(join63(nativeDir, "pty.node"), ptyNodeDest);
-    if (existsSync48(join63(nativeDir, "spawn-helper"))) {
+    if (existsSync49(join63(nativeDir, "spawn-helper"))) {
       copyFileSync(join63(nativeDir, "spawn-helper"), join63(platformDir, "spawn-helper"));
     }
     process.env.FUSION_FAKE_BUNFS_ROOT = tmpRoot;
     if (process.platform !== "win32") {
       const bunfsRoot = "/$bunfs/root";
       try {
-        if (existsSync48(bunfsRoot)) {
+        if (existsSync49(bunfsRoot)) {
           const stats = lstatSync3(bunfsRoot);
           if (stats.isSymbolicLink()) {
             rmSync5(bunfsRoot);
@@ -156735,7 +157136,7 @@ function setupNativeResolution() {
 function cleanupNativeResolution() {
   if (bunfsSymlinkPath && process.platform !== "win32") {
     try {
-      if (existsSync48(bunfsSymlinkPath)) {
+      if (existsSync49(bunfsSymlinkPath)) {
         const stats = lstatSync3(bunfsSymlinkPath);
         if (stats.isSymbolicLink()) {
           rmSync5(bunfsSymlinkPath);
@@ -156781,7 +157182,7 @@ var init_native_patch = __esm({
 });
 
 // src/bin.ts
-import { existsSync as existsSync49, mkdtempSync as mkdtempSync2, readFileSync as readFileSync22, symlinkSync as symlinkSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync50, mkdtempSync as mkdtempSync2, readFileSync as readFileSync22, symlinkSync as symlinkSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
 import { join as join64, dirname as dirname27 } from "node:path";
 import { tmpdir as tmpdir5 } from "node:os";
@@ -156804,7 +157205,7 @@ function configurePiPackage() {
     packageJson = JSON.parse(readFileSync22(piPackagePath, "utf-8"));
     for (const entry of ["dist", "docs", "examples", "README.md", "CHANGELOG.md"]) {
       const source = join64(piPackageDir, entry);
-      if (existsSync49(source)) {
+      if (existsSync50(source)) {
         symlinkSync3(source, join64(tmp, entry));
       }
     }
@@ -156823,7 +157224,7 @@ setInterval(() => {
   performance3.clearMarks();
 }, 3e4).unref();
 function loadEnvFile(path5) {
-  if (!existsSync49(path5)) return;
+  if (!existsSync50(path5)) return;
   const contents = readFileSync22(path5, "utf-8");
   for (const rawLine of contents.split(/\r?\n/)) {
     const line = rawLine.trim();
@@ -157076,9 +157477,6 @@ Options:
 
 Columns: triage, todo, in-progress, in-review, done, archived
 Supported file types: png, jpg, gif, webp, txt, log, json, yaml, yml, toml, csv, xml
-
-The AI engine uses pi (github.com/badlogic/pi-mono) for agent sessions.
-Requires configured API keys \u2014 run "pi" first to set up authentication.
 `.trim();
 function extractGlobalProjectFlag(argv) {
   const cleanedArgs = [];
@@ -157126,10 +157524,8 @@ async function main() {
     console.log(HELP);
     process.exit(0);
   }
-  if (args.length === 0) {
-    const { runDashboard: runDashboard3 } = await Promise.resolve().then(() => (init_dashboard(), dashboard_exports));
-    await runDashboard3(4040);
-    return;
+  if (args.length === 0 || args[0].startsWith("-")) {
+    args.unshift("dashboard");
   }
   const command = args[0];
   const {