@runfusion/fusion 0.9.4 → 0.10.0

package/dist/bin.js

@@ -1384,6 +1384,26 @@ var init_agent_prompts = __esm({
 
 You are working in a git worktree isolated from the main branch. Your job is to implement the task described in the PROMPT.md specification you're given.
 
+## Turn-ending rules \u2014 read carefully
+
+You MUST end every turn by either:
+- (a) calling another tool to make progress, OR
+- (b) calling \`fn_task_done\` if the entire task is complete, OR
+- (c) calling \`fn_task_done\` with a summary explaining what is blocked, if you cannot make progress for any reason
+
+You MUST NOT end a turn by writing prose that asks the user a question, summarizes progress, or requests permission to continue. The following are FORBIDDEN turn-endings:
+- "If you want, I can continue with..."
+- "Should I proceed with...?"
+- "Let me know if you'd like me to..."
+- "Ready to move on to step N. Want me to continue?"
+- Any markdown progress summary at the end of a turn instead of a tool call
+
+If you have just finished a step's work, immediately call \`fn_task_update\` to mark the step done and continue with the next pending step in the SAME turn. Do not pause to summarize.
+
+The user is not watching this conversation in real-time. They will read the final result. Asking permission wastes a full retry cycle and may orphan committed work.
+
+If you genuinely cannot proceed (blocked on a dependency, missing information, or an unresolvable error), call \`fn_task_done\` with a clear explanation of what is blocked and what is needed to unblock it. Never write the question as plain prose.
+
 ## How to work
 1. Read the PROMPT.md carefully \u2014 it contains your mission, steps, file scope, and acceptance criteria
 2. Work through each step in order
@@ -1529,7 +1549,17 @@ Lint, tests, and typecheck are also hard quality gates:
 - Keep fixing failures until lint, the configured/full test suite, and typecheck all pass
 - If the repository exposes a typecheck command, run it and keep fixing failures until it passes
 - Do not stop at "out of scope" if additional fixes are required to restore green lint, tests, build, or typecheck
-- **CRITICAL: Resolve ALL lint failures and test failures before completing the task, even if they appear unrelated or pre-existing.** Unrelated failures left unfixed accumulate technical debt and block future integrations. Investigate and fix or suppress them \u2014 do not defer them to a separate task.`;
+- **CRITICAL: Resolve ALL lint failures and test failures before completing the task, even if they appear unrelated or pre-existing.** Unrelated failures left unfixed accumulate technical debt and block future integrations. Investigate and fix or suppress them \u2014 do not defer them to a separate task.
+
+## Verification commands \u2014 use fn_run_verification
+
+For ALL test/lint/build/typecheck verification, use the \`fn_run_verification\` tool, NOT raw bash.
+The tool prevents your session from being killed by the inactivity watchdog during long compiles.
+
+- Prefer **package-scoped** verification first: e.g. \`pnpm --filter @fusion/<pkg> test\` with \`scope: "package"\`. This is faster and isolated.
+- Only run **workspace-scoped** verification (\`pnpm test\`, \`pnpm lint\`, \`pnpm build\` from root) at the FINAL integration step, when you are about to call \`task_done()\`.
+- If you need to run \`pnpm install\` (e.g. you added a new package), use \`fn_run_verification\` with \`scope: "workspace"\` and \`timeoutSec: 600\`.
+- If a verification command times out, do NOT blindly retry \u2014 investigate. Check for hung subprocesses, infinite test loops, or tests waiting on missing dependencies. Use \`node_modules/.modules.yaml\` presence to confirm bootstrap.`;
     TRIAGE_PROMPT_TEXT = `You are a task specification agent for "fn", an AI-orchestrated task board.
 
 Your job: take a rough task description and produce a fully specified PROMPT.md that another AI agent can execute autonomously in a fresh context with zero memory of this conversation.
@@ -18110,10 +18140,10 @@ var init_central_core = __esm({
        */
       async generateProjectName(projectPath) {
         try {
-          const { execFile: execFile8 } = await import("node:child_process");
+          const { execFile: execFile9 } = await import("node:child_process");
           const { promisify: promisify18 } = await import("node:util");
-          const execFileAsync6 = promisify18(execFile8);
-          const { stdout } = await execFileAsync6(
+          const execFileAsync7 = promisify18(execFile9);
+          const { stdout } = await execFileAsync7(
             "git",
             ["remote", "get-url", "origin"],
             { cwd: projectPath, timeout: 5e3 }
@@ -18623,7 +18653,7 @@ __export(migration_exports, {
   MigrationCoordinator: () => MigrationCoordinator,
   ProjectRequiredError: () => ProjectRequiredError
 });
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir2, tmpdir } from "node:os";
 import { isAbsolute as isAbsolute3, join as join12, resolve as resolve5, basename as basename3, dirname as dirname4 } from "node:path";
 function getHomeDir2() {
@@ -18760,10 +18790,10 @@ var init_migration = __esm({
           return basename3(projectPath);
         }
         try {
-          const { execFile: execFile8 } = await import("node:child_process");
+          const { execFile: execFile9 } = await import("node:child_process");
           const { promisify: promisify18 } = await import("node:util");
-          const execFileAsync6 = promisify18(execFile8);
-          const { stdout } = await execFileAsync6(
+          const execFileAsync7 = promisify18(execFile9);
+          const { stdout } = await execFileAsync7(
             "git",
             ["remote", "get-url", "origin"],
             { cwd: projectPath, timeout: 1e3 }
@@ -18775,8 +18805,26 @@ var init_migration = __esm({
           }
         } catch {
         }
+        const remoteFromConfig = this.readOriginRemoteFromGitConfig(projectPath);
+        if (remoteFromConfig) {
+          const name = this.extractRepoName(remoteFromConfig);
+          if (name) return name;
+        }
         return basename3(projectPath);
       }
+      readOriginRemoteFromGitConfig(projectPath) {
+        try {
+          const gitConfig = readFileSync2(join12(projectPath, ".git", "config"), "utf8");
+          const originSectionMatch = gitConfig.match(/\[remote\s+"origin"\]([\s\S]*?)(?:\n\[|$)/);
+          if (!originSectionMatch) {
+            return null;
+          }
+          const urlMatch = originSectionMatch[1]?.match(/^\s*url\s*=\s*(.+)$/m);
+          return urlMatch?.[1]?.trim() || null;
+        } catch {
+          return null;
+        }
+      }
       /**
        * Extract repository name from git remote URL.
        *
@@ -28229,8 +28277,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static parseFileSync(filePath) {
-        const { readFileSync: readFileSync23 } = __require("fs");
-        const data = readFileSync23(filePath, "utf8");
+        const { readFileSync: readFileSync24 } = __require("fs");
+        const data = readFileSync24(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -29493,13 +29541,13 @@ async function searchWithQmd(rootDir, options) {
   const command = "qmd";
   const limit = Math.max(1, Math.min(options.limit ?? 5, 20));
   try {
-    const { execFile: execFile8 } = await import("node:child_process");
+    const { execFile: execFile9 } = await import("node:child_process");
     const { promisify: promisify18 } = await import("node:util");
-    const execFileAsync6 = promisify18(execFile8);
-    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync6);
+    const execFileAsync7 = promisify18(execFile9);
+    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync7);
     scheduleQmdProjectMemoryRefresh(rootDir);
     const args = buildQmdSearchArgs(rootDir, options);
-    const { stdout } = await execFileAsync6(command, args, {
+    const { stdout } = await execFileAsync7(command, args, {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 1024 * 1024
@@ -29524,12 +29572,12 @@ async function searchWithQmd(rootDir, options) {
     return [];
   }
 }
-async function ensureQmdProjectMemoryCollection(rootDir, execFileAsync6) {
+async function ensureQmdProjectMemoryCollection(rootDir, execFileAsync7) {
   const collectionName = qmdMemoryCollectionName(rootDir);
   const memoryDir = memoryWorkspacePath(rootDir);
   await mkdir6(memoryDir, { recursive: true });
   try {
-    await execFileAsync6("qmd", buildQmdCollectionAddArgs(rootDir), {
+    await execFileAsync7("qmd", buildQmdCollectionAddArgs(rootDir), {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 512 * 1024
@@ -29545,9 +29593,9 @@ ${stderr}`)) {
   return collectionName;
 }
 async function getDefaultExecFileAsync() {
-  const { execFile: execFile8 } = await import("node:child_process");
+  const { execFile: execFile9 } = await import("node:child_process");
   const { promisify: promisify18 } = await import("node:util");
-  return promisify18(execFile8);
+  return promisify18(execFile9);
 }
 async function refreshQmdProjectMemoryIndex(rootDir, options) {
   const key = resolve6(rootDir);
@@ -29562,14 +29610,14 @@ async function refreshQmdProjectMemoryIndex(rootDir, options) {
     }
   }
   const promise = (async () => {
-    const execFileAsync6 = options?.execFileAsync ?? await getDefaultExecFileAsync();
-    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync6);
-    await execFileAsync6("qmd", ["update"], {
+    const execFileAsync7 = options?.execFileAsync ?? await getDefaultExecFileAsync();
+    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync7);
+    await execFileAsync7("qmd", ["update"], {
       cwd: rootDir,
       timeout: 3e4,
       maxBuffer: 1024 * 1024
     });
-    await execFileAsync6("qmd", ["embed"], {
+    await execFileAsync7("qmd", ["embed"], {
       cwd: rootDir,
       timeout: 12e4,
       maxBuffer: 1024 * 1024
@@ -29594,8 +29642,8 @@ function scheduleQmdProjectMemoryRefresh(rootDir) {
 }
 async function isQmdAvailable() {
   try {
-    const execFileAsync6 = await getDefaultExecFileAsync();
-    await execFileAsync6("qmd", ["--help"], {
+    const execFileAsync7 = await getDefaultExecFileAsync();
+    await execFileAsync7("qmd", ["--help"], {
       timeout: 3e3,
       maxBuffer: 128 * 1024
     });
@@ -29605,12 +29653,12 @@ async function isQmdAvailable() {
   }
 }
 async function installQmd(options) {
-  const execFileAsync6 = options?.execFileAsync ?? await getDefaultExecFileAsync();
+  const execFileAsync7 = options?.execFileAsync ?? await getDefaultExecFileAsync();
   const [command, ...args] = QMD_INSTALL_COMMAND.split(" ");
   if (!command || args.length === 0) {
     throw new MemoryBackendError("BACKEND_UNAVAILABLE", "qmd install command is not configured", "qmd");
   }
-  await execFileAsync6(command, args, {
+  await execFileAsync7(command, args, {
     timeout: 12e4,
     maxBuffer: 1024 * 1024
   });
@@ -30405,8 +30453,8 @@ function assertSafeGitBranchName(name) {
   }
 }
 function assertSafeAbsolutePath(path5) {
-  const isAbsolute19 = path5.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path5);
-  if (!path5 || path5.length > 4096 || !isAbsolute19 || path5.startsWith("-") || // Reject shell metacharacters, quotes, control chars, and NULs.
+  const isAbsolute20 = path5.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path5);
+  if (!path5 || path5.length > 4096 || !isAbsolute20 || path5.startsWith("-") || // Reject shell metacharacters, quotes, control chars, and NULs.
   /["'`$\n\r\t;&|<>()*?[\]{}\\\0]/.test(
     path5.replace(/^[A-Za-z]:/, "")
     // ignore the drive-letter colon on Windows
@@ -32531,7 +32579,7 @@ ${newTask.description}
           return dependency?.column === "done" || dependency?.column === "archived";
         });
       }
-      async moveTask(id, toColumn) {
+      async moveTask(id, toColumn, options) {
         return this.withTaskLock(id, async () => {
           const dir2 = this.taskDir(id);
           let task;
@@ -32582,12 +32630,16 @@ ${newTask.description}
           if (isReopenToTodoOrTriage) {
             task.status = void 0;
             task.error = void 0;
-            task.worktree = void 0;
             task.blockedBy = void 0;
-            task.executionStartedAt = void 0;
-            task.executionCompletedAt = void 0;
-            this.resetAllStepsToPending(task);
-            await this.resetPromptCheckboxes(dir2);
+            if (!options?.preserveResumeState) {
+              task.worktree = void 0;
+              task.executionStartedAt = void 0;
+              task.executionCompletedAt = void 0;
+              this.resetAllStepsToPending(task);
+              await this.resetPromptCheckboxes(dir2);
+            } else {
+              task.executionCompletedAt = void 0;
+            }
           }
           if (toColumn === "in-review") {
             task.recoveryRetryCount = void 0;
@@ -32986,6 +33038,19 @@ ${task.description}
               `Step ${stepIndex} out of range (task has ${task.steps.length} steps)`
             );
           }
+          const currentStatus = task.steps[stepIndex].status;
+          if (status === "in-progress" && (currentStatus === "done" || currentStatus === "skipped")) {
+            const ts = (/* @__PURE__ */ new Date()).toISOString();
+            task.updatedAt = ts;
+            task.log.push({
+              timestamp: ts,
+              action: `Ignored ${currentStatus}\u2192in-progress regression for step ${stepIndex} (${task.steps[stepIndex].name})`
+            });
+            await this.atomicWriteTaskJson(dir2, task);
+            if (this.isWatching) this.taskCache.set(id, { ...task });
+            this.emit("task:updated", task);
+            return task;
+          }
           task.steps[stepIndex].status = status;
           task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
           if (status === "done") {
@@ -35400,7 +35465,7 @@ var init_daemon_token = __esm({
 });
 
 // ../core/src/pi-extensions.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync5, readdirSync, readFileSync as readFileSync2, statSync as statSync3, writeFileSync } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync5, readdirSync, readFileSync as readFileSync3, statSync as statSync3, writeFileSync } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { basename as basename5, isAbsolute as isAbsolute5, join as join17, relative as relative2, resolve as resolve7, sep as sep4, win32 } from "node:path";
 function getHomeDir3(home) {
@@ -35445,7 +35510,7 @@ function extensionName(extensionPath) {
 }
 function readPiManifest(packageJsonPath) {
   try {
-    const parsed = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
     if (parsed.pi && Array.isArray(parsed.pi.extensions)) {
       return { extensions: parsed.pi.extensions.filter((entry) => typeof entry === "string") };
     }
@@ -35525,7 +35590,7 @@ function getPiExtensionDiscoveryDirs(cwd, home) {
 }
 function readFusionDisabledExtensions(settingsPath) {
   try {
-    const parsed = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync3(settingsPath, "utf-8"));
     const disabled = parsed[FUSION_DISABLED_EXTENSIONS_KEY];
     return Array.isArray(disabled) ? disabled.filter((entry) => typeof entry === "string").map((entry) => resolve7(entry)) : [];
   } catch {
@@ -35555,7 +35620,7 @@ function updatePiExtensionDisabledIds(cwd, disabledIds, home, extraKnownIds = []
   const settingsPath = getFusionAgentSettingsPath(home);
   const existing = (() => {
     try {
-      return JSON.parse(readFileSync2(settingsPath, "utf-8"));
+      return JSON.parse(readFileSync3(settingsPath, "utf-8"));
     } catch {
       return {};
     }
@@ -43692,8 +43757,8 @@ var require_YAMLMap = __commonJS({
        * @param {Class} Type - If set, forces the returned collection type
        * @returns Instance of Type, Map, or Object
        */
-      toJSON(_2, ctx, Type7) {
-        const map2 = Type7 ? new Type7() : ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {};
+      toJSON(_2, ctx, Type8) {
+        const map2 = Type8 ? new Type8() : ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {};
         if (ctx?.onCreate)
           ctx.onCreate(map2);
         for (const item of this.items)
@@ -48916,7 +48981,7 @@ var require_dist3 = __commonJS({
 });
 
 // ../core/src/agent-companies-parser.ts
-import { existsSync as existsSync17, mkdtempSync, readdirSync as readdirSync2, readFileSync as readFileSync3, rmSync, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync17, mkdtempSync, readdirSync as readdirSync2, readFileSync as readFileSync4, rmSync, statSync as statSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join20, resolve as resolve9 } from "node:path";
 function slugifyAgentReference(value) {
@@ -49134,7 +49199,7 @@ function parseSkillManifest(content) {
 }
 function parseManifestFile(filePath, parser) {
   try {
-    return parser(readFileSync3(filePath, "utf-8"));
+    return parser(readFileSync4(filePath, "utf-8"));
   } catch (error) {
     if (error instanceof AgentCompaniesParseError) {
       throw new AgentCompaniesParseError(`${filePath}: ${error.message}`);
@@ -49231,12 +49296,12 @@ function resolveExtractionRoot(tempDir) {
   return tempDir;
 }
 async function extractTarArchive(archivePath, outputDir) {
-  const [{ execFile: execFile8 }, { promisify: promisify18 }] = await Promise.all([
+  const [{ execFile: execFile9 }, { promisify: promisify18 }] = await Promise.all([
     import("node:child_process"),
     import("node:util")
   ]);
-  const execFileAsync6 = promisify18(execFile8);
-  await execFileAsync6("tar", ["xzf", archivePath, "-C", outputDir]);
+  const execFileAsync7 = promisify18(execFile9);
+  await execFileAsync7("tar", ["xzf", archivePath, "-C", outputDir]);
 }
 async function parseCompanyArchive(archivePath) {
   const resolvedArchivePath = resolve9(archivePath);
@@ -50453,7 +50518,7 @@ var init_src = __esm({
 
 // ../dashboard/src/github-webhooks.ts
 import { createHmac, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
 function getGitHubAppConfig() {
   const appId = process.env.FUSION_GITHUB_APP_ID;
   const webhookSecret = process.env.FUSION_GITHUB_WEBHOOK_SECRET;
@@ -50463,7 +50528,7 @@ function getGitHubAppConfig() {
   } else if (process.env.FUSION_GITHUB_APP_PRIVATE_KEY_PATH) {
     if (cachedPrivateKey === void 0) {
       try {
-        cachedPrivateKey = readFileSync4(process.env.FUSION_GITHUB_APP_PRIVATE_KEY_PATH, "utf-8");
+        cachedPrivateKey = readFileSync5(process.env.FUSION_GITHUB_APP_PRIVATE_KEY_PATH, "utf-8");
       } catch {
         cachedPrivateKey = null;
       }
@@ -51541,11 +51606,11 @@ async function refreshAgentMemoryQmdIndex(rootDir, agentMemory) {
     return;
   }
   const promise = (async () => {
-    const { execFile: execFile8 } = await import("node:child_process");
+    const { execFile: execFile9 } = await import("node:child_process");
     const { promisify: promisify18 } = await import("node:util");
-    const execFileAsync6 = promisify18(execFile8);
+    const execFileAsync7 = promisify18(execFile9);
     try {
-      await execFileAsync6("qmd", buildQmdAgentMemoryCollectionAddArgs(rootDir, agentMemory.agentId), {
+      await execFileAsync7("qmd", buildQmdAgentMemoryCollectionAddArgs(rootDir, agentMemory.agentId), {
         cwd: rootDir,
         timeout: 4e3,
         maxBuffer: 512 * 1024
@@ -51558,8 +51623,8 @@ ${stderr}`)) {
         throw error;
       }
     }
-    await execFileAsync6("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
-    await execFileAsync6("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync7("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync7("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
   })();
   agentQmdRefreshState.set(key, { lastStartedAt: now, inFlight: promise });
   try {
@@ -51580,10 +51645,10 @@ async function searchAgentMemoryWithQmd(rootDir, agentMemory, query, limit) {
   }
   try {
     await refreshAgentMemoryQmdIndex(rootDir, agentMemory);
-    const { execFile: execFile8 } = await import("node:child_process");
+    const { execFile: execFile9 } = await import("node:child_process");
     const { promisify: promisify18 } = await import("node:util");
-    const execFileAsync6 = promisify18(execFile8);
-    const { stdout } = await execFileAsync6("qmd", buildQmdAgentMemorySearchArgs(rootDir, agentMemory.agentId, query, limit), {
+    const execFileAsync7 = promisify18(execFile9);
+    const { stdout } = await execFileAsync7("qmd", buildQmdAgentMemorySearchArgs(rootDir, agentMemory.agentId, query, limit), {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 1024 * 1024
@@ -52397,14 +52462,14 @@ var init_concurrency = __esm({
 });
 
 // ../engine/src/skill-resolver.ts
-import { existsSync as existsSync19, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync6 } from "node:fs";
 import { join as join23 } from "node:path";
 function readJsonObject(path5) {
   if (!existsSync19(path5)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync5(path5, "utf-8"));
+    const parsed = JSON.parse(readFileSync6(path5, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -52633,7 +52698,7 @@ var init_context_limit_detector = __esm({
 });
 
 // ../engine/src/auth-storage.ts
-import { existsSync as existsSync20, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { join as join24 } from "node:path";
 import { AuthStorage } from "@mariozechner/pi-coding-agent";
@@ -52673,7 +52738,7 @@ function readLegacyCredentials(authPaths = getLegacyAuthPaths()) {
       continue;
     }
     try {
-      const parsed = JSON.parse(readFileSync6(authPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync7(authPath, "utf-8"));
       for (const [provider, credential] of Object.entries(parsed)) {
         credentials[provider] ??= credential;
       }
@@ -52745,13 +52810,13 @@ var init_auth_storage = __esm({
 });
 
 // ../engine/src/custom-providers.ts
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync8 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { join as join25 } from "node:path";
 function readCustomProviders() {
   try {
     const settingsPath = join25(homedir5(), ".fusion", "settings.json");
-    const raw = readFileSync7(settingsPath, "utf-8");
+    const raw = readFileSync8(settingsPath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.customProviders) ? parsed.customProviders : [];
   } catch {
@@ -52765,7 +52830,7 @@ var init_custom_providers = __esm({
 });
 
 // ../engine/src/pi.ts
-import { existsSync as existsSync21, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync9 } from "node:fs";
 import { exec } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 import { createRequire as createRequire2 } from "node:module";
@@ -53027,7 +53092,7 @@ function readJsonObject2(path5) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path5, "utf-8"));
+    const parsed = JSON.parse(readFileSync9(path5, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -53199,7 +53264,7 @@ function resolveVendoredClaudeCliEntry() {
   try {
     const require_2 = createRequire2(import.meta.url);
     const pkgJsonPath = require_2.resolve("@fusion/pi-claude-cli/package.json");
-    const pkgJson = JSON.parse(readFileSync8(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(readFileSync9(pkgJsonPath, "utf-8"));
     const extensions = pkgJson.pi?.extensions;
     if (!Array.isArray(extensions) || extensions.length === 0) return null;
     const entry = extensions[0];
@@ -55022,9 +55087,9 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
     return { attachmentContents, imageContents };
   }
   const { readFile: readFile24 } = await import("node:fs/promises");
-  const { join: join68 } = await import("node:path");
+  const { join: join69 } = await import("node:path");
   for (const att of attachments) {
-    const filePath = join68(
+    const filePath = join69(
       rootDir,
       ".fusion",
       "tasks",
@@ -56562,9 +56627,9 @@ Remove or replace these ids and call fn_task_create again.`
             }
             try {
               const { readFile: readFile24 } = await import("node:fs/promises");
-              const { join: join68 } = await import("node:path");
+              const { join: join69 } = await import("node:path");
               const promptContent = await readFile24(
-                join68(rootDir, promptPath),
+                join69(rootDir, promptPath),
                 "utf-8"
               ).catch((err) => {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -60774,6 +60839,14 @@ import { exec as exec3 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 import { existsSync as existsSync24, lstatSync, readdirSync as readdirSync4, rmSync as rmSync2 } from "node:fs";
 import { join as join30, relative as relative5, resolve as resolve13, isAbsolute as isAbsolute9 } from "node:path";
+function getExecStdout(result) {
+  if (typeof result === "string") return result;
+  if (result && typeof result === "object" && "stdout" in result) {
+    const stdout = result.stdout;
+    return typeof stdout === "string" ? stdout : String(stdout ?? "");
+  }
+  return "";
+}
 async function isGitRepository(dir2) {
   try {
     await execAsync3("git rev-parse --git-dir", {
@@ -60789,10 +60862,11 @@ async function isGitRepository(dir2) {
 }
 async function getRegisteredWorktreePaths(rootDir) {
   try {
-    const { stdout } = await execAsync3("git worktree list --porcelain", {
+    const result = await execAsync3("git worktree list --porcelain", {
       cwd: rootDir,
       encoding: "utf-8"
     });
+    const stdout = getExecStdout(result);
     const paths = /* @__PURE__ */ new Set();
     for (const line of stdout.split("\n")) {
       if (line.startsWith("worktree ")) {
@@ -60944,10 +61018,11 @@ async function reapOrphanWorktrees(projectRoot) {
 async function scanOrphanedBranches(rootDir, store) {
   let allBranches;
   try {
-    const { stdout } = await execAsync3("git branch --list 'fusion/*'", {
+    const result = await execAsync3("git branch --list 'fusion/*'", {
       cwd: rootDir,
       encoding: "utf-8"
     });
+    const stdout = getExecStdout(result);
     allBranches = stdout.split("\n").map((line) => line.trim().replace(/^\*?\s*/, "")).filter((line) => line.startsWith("fusion/"));
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
@@ -62083,13 +62158,304 @@ var init_task_completion = __esm({
   }
 });
 
+// ../engine/src/run-verification-tool.ts
+import { spawn as spawn3 } from "node:child_process";
+import { existsSync as existsSync26 } from "node:fs";
+import { isAbsolute as isAbsolute10, join as join33 } from "node:path";
+import { Type as Type4 } from "@mariozechner/pi-ai";
+function appendToBuffer(buf, chunk) {
+  const chunkBytes = Buffer.byteLength(chunk, "utf8");
+  buf.totalBytes += chunkBytes;
+  if (buf.totalBytes <= MAX_OUTPUT_BYTES) {
+    buf.head += chunk;
+    return;
+  }
+  const tailCap = MAX_OUTPUT_BYTES / 2;
+  buf.tail += chunk;
+  if (Buffer.byteLength(buf.tail, "utf8") > tailCap) {
+    const bytes = Buffer.from(buf.tail, "utf8");
+    buf.tail = bytes.subarray(bytes.length - tailCap).toString("utf8");
+  }
+}
+function flattenBuffer(buf) {
+  if (buf.tail.length === 0) return buf.head;
+  return buf.head + `
+
+[... output truncated \u2014 ${buf.totalBytes} bytes total, showing head + tail ...]
+
+` + buf.tail;
+}
+async function runVerificationCommand2(opts) {
+  const { command, cwd, timeoutMs, expectFailure = false, onHeartbeat, onLine } = opts;
+  const startMs = Date.now();
+  const warnings = [];
+  const stdoutBuf = { head: "", tail: "", totalBytes: 0 };
+  const stderrBuf = { head: "", tail: "", totalBytes: 0 };
+  return new Promise((resolve39) => {
+    const child = spawn3(command, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env },
+      shell: true
+    });
+    let timedOut = false;
+    let killed = false;
+    let settled = false;
+    let lastLineMs = Date.now();
+    const quietTimer = setInterval(() => {
+      const silenceMs = Date.now() - lastLineMs;
+      if (silenceMs >= QUIET_HEARTBEAT_INTERVAL_MS) {
+        executorLog.log(
+          `[fn_run_verification] command quiet for ${Math.round(silenceMs / 1e3)}s, still running... (${command})`
+        );
+        onHeartbeat();
+      }
+    }, QUIET_HEARTBEAT_INTERVAL_MS);
+    const hardTimer = setTimeout(() => {
+      if (settled) return;
+      timedOut = true;
+      executorLog.warn(
+        `[fn_run_verification] hard timeout (${timeoutMs / 1e3}s) \u2014 sending SIGTERM to: ${command}`
+      );
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!settled) {
+          executorLog.warn(
+            `[fn_run_verification] SIGTERM ignored \u2014 sending SIGKILL to: ${command}`
+          );
+          child.kill("SIGKILL");
+          killed = true;
+        }
+      }, SIGKILL_GRACE_MS);
+    }, timeoutMs);
+    let stdoutRemainder = "";
+    child.stdout.on("data", (chunk) => {
+      const text = stdoutRemainder + chunk.toString("utf8");
+      const lines = text.split("\n");
+      stdoutRemainder = lines.pop() ?? "";
+      for (const line of lines) {
+        const lineWithNewline = line + "\n";
+        appendToBuffer(stdoutBuf, lineWithNewline);
+        lastLineMs = Date.now();
+        onHeartbeat();
+        onLine?.(lineWithNewline);
+      }
+    });
+    let stderrRemainder = "";
+    child.stderr.on("data", (chunk) => {
+      const text = stderrRemainder + chunk.toString("utf8");
+      const lines = text.split("\n");
+      stderrRemainder = lines.pop() ?? "";
+      for (const line of lines) {
+        const lineWithNewline = line + "\n";
+        appendToBuffer(stderrBuf, lineWithNewline);
+        lastLineMs = Date.now();
+        onHeartbeat();
+        onLine?.(lineWithNewline);
+      }
+    });
+    child.on("close", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      clearInterval(quietTimer);
+      clearTimeout(hardTimer);
+      if (stdoutRemainder) appendToBuffer(stdoutBuf, stdoutRemainder);
+      if (stderrRemainder) appendToBuffer(stderrBuf, stderrRemainder);
+      const exitCode = code ?? null;
+      const durationMs = Date.now() - startMs;
+      const zeroExit = exitCode === 0;
+      const success = expectFailure ? true : zeroExit;
+      if (!success && !timedOut) {
+        executorLog.warn(
+          `[fn_run_verification] command failed (exit=${exitCode}, signal=${signal ?? "none"}): ${command}`
+        );
+      }
+      resolve39({
+        success,
+        exitCode,
+        durationMs,
+        stdout: flattenBuffer(stdoutBuf),
+        stderr: flattenBuffer(stderrBuf),
+        timedOut,
+        killed,
+        command,
+        cwd,
+        warnings
+      });
+    });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearInterval(quietTimer);
+      clearTimeout(hardTimer);
+      const durationMs = Date.now() - startMs;
+      warnings.push(`Spawn error: ${err.message}`);
+      resolve39({
+        success: false,
+        exitCode: null,
+        durationMs,
+        stdout: flattenBuffer(stdoutBuf),
+        stderr: flattenBuffer(stderrBuf) + `
+Spawn error: ${err.message}`,
+        timedOut: false,
+        killed: false,
+        command,
+        cwd,
+        warnings
+      });
+    });
+  });
+}
+function createRunVerificationTool(opts) {
+  const { worktreePath, rootDir, taskId, recordActivity, log: log18 } = opts;
+  return {
+    name: "fn_run_verification",
+    label: "Run Verification",
+    description: "Run a verification command (tests, lint, build, typecheck) with timeout and progress heartbeat protection. Use this instead of bash for any pnpm/npm test/lint/build commands. Prevents the inactivity watchdog from killing your session during long compiles.",
+    parameters: runVerificationParams,
+    execute: async (_toolCallId, params) => {
+      const { command, scope, expectFailure = false } = params;
+      const warnings = [];
+      if (scope === "workspace" && command.trimStart().startsWith("pnpm --filter")) {
+        const msg = 'scope is "workspace" but command starts with "pnpm --filter" \u2014 consider using scope="package" for scoped commands.';
+        warnings.push(msg);
+        log18.warn(`[fn_run_verification] ${taskId}: ${msg}`);
+      }
+      let resolvedCwd;
+      if (params.cwd && isAbsolute10(params.cwd)) {
+        resolvedCwd = params.cwd;
+      } else if (params.cwd) {
+        resolvedCwd = join33(worktreePath, params.cwd);
+      } else {
+        resolvedCwd = worktreePath;
+      }
+      const defaultTimeoutSec = scope === "package" ? DEFAULT_TIMEOUT_PACKAGE_SEC : DEFAULT_TIMEOUT_WORKSPACE_SEC;
+      const rawTimeoutSec = params.timeoutSec ?? defaultTimeoutSec;
+      const timeoutSec = Math.min(rawTimeoutSec, MAX_TIMEOUT_SEC);
+      const timeoutMs = timeoutSec * 1e3;
+      if (rawTimeoutSec > MAX_TIMEOUT_SEC) {
+        const msg = `timeoutSec ${rawTimeoutSec} exceeds hard cap of ${MAX_TIMEOUT_SEC}s \u2014 clamped.`;
+        warnings.push(msg);
+        log18.warn(`[fn_run_verification] ${taskId}: ${msg}`);
+      }
+      let effectiveCommand = command;
+      if (command.trimStart().startsWith("pnpm --filter")) {
+        const modulesYaml = join33(rootDir, "node_modules", ".modules.yaml");
+        if (!existsSync26(modulesYaml)) {
+          const installCmd = "pnpm install --prefer-offline";
+          const msg = `node_modules/.modules.yaml not found in workspace root \u2014 auto-prepending \`${installCmd}\` before running the command.`;
+          warnings.push(msg);
+          log18.warn(`[fn_run_verification] ${taskId}: ${msg}`);
+          effectiveCommand = `${installCmd} && ${command}`;
+        }
+      }
+      log18.info(
+        `[fn_run_verification] ${taskId}: scope=${scope} timeout=${timeoutSec}s cwd=${resolvedCwd} cmd=${effectiveCommand}`
+      );
+      const result = await runVerificationCommand2({
+        command: effectiveCommand,
+        cwd: resolvedCwd,
+        timeoutMs,
+        expectFailure,
+        onHeartbeat: recordActivity
+      });
+      const allWarnings = [...warnings, ...result.warnings];
+      const lines = [];
+      if (allWarnings.length > 0) {
+        lines.push(`Warnings:
+${allWarnings.map((w) => `  - ${w}`).join("\n")}
+`);
+      }
+      if (result.timedOut) {
+        lines.push(
+          `Command timed out after ${timeoutSec}s and was ${result.killed ? "killed (SIGKILL)" : "terminated (SIGTERM)"}.
+`
+        );
+      }
+      lines.push(`Exit code: ${result.exitCode ?? "null (signal)"}`);
+      lines.push(`Duration: ${(result.durationMs / 1e3).toFixed(1)}s`);
+      lines.push(`Success: ${result.success}`);
+      if (result.stdout.length > 0) {
+        lines.push(`
+--- stdout ---
+${result.stdout}`);
+      }
+      if (result.stderr.length > 0) {
+        lines.push(`
+--- stderr ---
+${result.stderr}`);
+      }
+      if (result.timedOut) {
+        lines.push(
+          "\nDo NOT blindly retry \u2014 investigate whether subprocesses are hung, test loops are infinite, or dependencies are missing."
+        );
+      }
+      const text = lines.join("\n");
+      log18.info(
+        `[fn_run_verification] ${taskId}: done exit=${result.exitCode} duration=${result.durationMs}ms success=${result.success}`
+      );
+      return {
+        content: [{ type: "text", text }],
+        details: {
+          success: result.success,
+          exitCode: result.exitCode,
+          durationMs: result.durationMs,
+          timedOut: result.timedOut,
+          killed: result.killed,
+          command: result.command,
+          cwd: result.cwd
+        }
+      };
+    }
+  };
+}
+var MAX_OUTPUT_BYTES, QUIET_HEARTBEAT_INTERVAL_MS, SIGKILL_GRACE_MS, DEFAULT_TIMEOUT_PACKAGE_SEC, DEFAULT_TIMEOUT_WORKSPACE_SEC, MAX_TIMEOUT_SEC, runVerificationParams;
+var init_run_verification_tool = __esm({
+  "../engine/src/run-verification-tool.ts"() {
+    "use strict";
+    init_logger2();
+    MAX_OUTPUT_BYTES = 200 * 1024;
+    QUIET_HEARTBEAT_INTERVAL_MS = 6e4;
+    SIGKILL_GRACE_MS = 1e4;
+    DEFAULT_TIMEOUT_PACKAGE_SEC = 300;
+    DEFAULT_TIMEOUT_WORKSPACE_SEC = 900;
+    MAX_TIMEOUT_SEC = 1800;
+    runVerificationParams = Type4.Object({
+      command: Type4.String({
+        description: 'The shell command to run, e.g. "pnpm --filter @fusion/droid-cli test", "pnpm lint", "pnpm build"'
+      }),
+      cwd: Type4.Optional(
+        Type4.String({
+          description: "Working directory for the command. Defaults to the task worktree root if omitted or relative."
+        })
+      ),
+      scope: Type4.Union(
+        [Type4.Literal("package"), Type4.Literal("workspace")],
+        {
+          description: '"package" for scoped commands like `pnpm --filter <pkg>`, "workspace" for root-level commands like `pnpm test`.'
+        }
+      ),
+      timeoutSec: Type4.Optional(
+        Type4.Number({
+          description: "Override the default timeout in seconds. Default: 300 for package scope, 900 for workspace scope. Hard cap: 1800."
+        })
+      ),
+      expectFailure: Type4.Optional(
+        Type4.Boolean({
+          description: "If true, a non-zero exit code is reported but not flagged as an error. Default: false."
+        })
+      )
+    });
+  }
+});
+
 // ../engine/src/executor.ts
 import { exec as exec5 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
-import { isAbsolute as isAbsolute10, join as join33, relative as relative6, resolve as resolvePath } from "node:path";
-import { existsSync as existsSync26 } from "node:fs";
+import { isAbsolute as isAbsolute11, join as join34, relative as relative6, resolve as resolvePath } from "node:path";
+import { existsSync as existsSync27 } from "node:fs";
 import { readFile as readFile14, writeFile as writeFile12 } from "node:fs/promises";
-import { Type as Type4 } from "@mariozechner/pi-ai";
+import { Type as Type5 } from "@mariozechner/pi-ai";
 import { ModelRegistry as ModelRegistry2, SessionManager as SessionManager2 } from "@mariozechner/pi-coding-agent";
 function truncateWorkflowScriptOutput2(output) {
   if (output.length <= WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2) return output;
@@ -62322,6 +62688,46 @@ ${comment.text}
 
 Please adjust your approach based on this feedback.`;
 }
+function detectPseudoPause(lastText) {
+  if (!lastText || lastText.trim().length === 0) {
+    return { kind: "none" };
+  }
+  const regexPatterns = [
+    /\bif you (?:want|wish|need|like|prefer|'?d like)\b/i,
+    /\bshould I (?:continue|proceed|go ahead|move on|start|begin)\b/i,
+    /\blet me know\b/i,
+    /\b(?:want|would you like) me to (?:continue|proceed|finish|complete|do)\b/i,
+    /\bready to (?:proceed|continue|move on|begin)\b/i,
+    /\bshall I\b/i,
+    /\b(?:awaiting|waiting for) (?:your )?(?:approval|confirmation|go-ahead|response)\b/i
+  ];
+  for (const pattern of regexPatterns) {
+    const match = pattern.exec(lastText);
+    if (match) {
+      const start = Math.max(0, match.index - 40);
+      const end = Math.min(lastText.length, match.index + match[0].length + 80);
+      const snippet = lastText.slice(start, end).replace(/\n+/g, " ").trim();
+      return { kind: "regex", matched: snippet };
+    }
+  }
+  const trimmed = lastText.trimEnd();
+  if (trimmed.length > 200) {
+    if (trimmed.endsWith("?")) {
+      const lastLine = trimmed.split("\n").at(-1) ?? trimmed;
+      return { kind: "structural", matched: lastLine.trim() };
+    }
+    const nextStepsPattern = /(?:^|\n)#+\s*(?:notes?|next steps?|summary|what'?s? next)\s*:?\s*$/i;
+    if (nextStepsPattern.test(trimmed)) {
+      const lastLine = trimmed.split("\n").at(-1) ?? trimmed;
+      return { kind: "structural", matched: lastLine.trim() };
+    }
+    if (/next steps?\s*:?\s*$/i.test(trimmed)) {
+      const lastLine = trimmed.split("\n").at(-1) ?? trimmed;
+      return { kind: "structural", matched: lastLine.trim() };
+    }
+  }
+  return { kind: "none" };
+}
 function detectReviewHandoffIntent(commentText) {
   const text = commentText.toLowerCase();
   const handoffPhrases = [
@@ -62364,6 +62770,7 @@ var init_executor = __esm({
     init_agent_tools();
     init_task_completion();
     init_auth_storage();
+    init_run_verification_tool();
     init_agent_logger();
     init_agent_tools();
     execAsync5 = promisify6(exec5);
@@ -62376,38 +62783,38 @@ var init_executor = __esm({
     WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2 = 4e3;
     NonRetryableWorktreeError = class extends Error {
     };
-    taskUpdateParams = Type4.Object({
-      step: Type4.Number({ description: "Step number (0-indexed)" }),
-      status: Type4.Union(
-        STEP_STATUSES.map((s) => Type4.Literal(s)),
+    taskUpdateParams = Type5.Object({
+      step: Type5.Number({ description: "Step number (0-indexed)" }),
+      status: Type5.Union(
+        STEP_STATUSES.map((s) => Type5.Literal(s)),
         { description: "New status: pending, in-progress, done, or skipped" }
       )
     });
-    taskAddDepParams = Type4.Object({
-      task_id: Type4.String({ description: 'The ID of the task to depend on (e.g. "KB-001")' }),
-      confirm: Type4.Optional(Type4.Boolean({ description: "Set to true to confirm adding the dependency. Required because adding a dep to an in-progress task will stop execution and discard current work." }))
+    taskAddDepParams = Type5.Object({
+      task_id: Type5.String({ description: 'The ID of the task to depend on (e.g. "KB-001")' }),
+      confirm: Type5.Optional(Type5.Boolean({ description: "Set to true to confirm adding the dependency. Required because adding a dep to an in-progress task will stop execution and discard current work." }))
     });
-    spawnAgentParams = Type4.Object({
-      name: Type4.String({ description: "Name for the child agent" }),
-      role: Type4.Union([
-        Type4.Literal("triage"),
-        Type4.Literal("executor"),
-        Type4.Literal("reviewer"),
-        Type4.Literal("merger"),
-        Type4.Literal("engineer"),
-        Type4.Literal("custom")
+    spawnAgentParams = Type5.Object({
+      name: Type5.String({ description: "Name for the child agent" }),
+      role: Type5.Union([
+        Type5.Literal("triage"),
+        Type5.Literal("executor"),
+        Type5.Literal("reviewer"),
+        Type5.Literal("merger"),
+        Type5.Literal("engineer"),
+        Type5.Literal("custom")
       ], { description: "Role for the child agent" }),
-      task: Type4.String({ description: "Task description for the child agent to execute" })
+      task: Type5.String({ description: "Task description for the child agent to execute" })
     });
-    reviewStepParams = Type4.Object({
-      step: Type4.Number({ description: "Step number to review" }),
-      type: Type4.Union(
-        [Type4.Literal("plan"), Type4.Literal("code")],
+    reviewStepParams = Type5.Object({
+      step: Type5.Number({ description: "Step number to review" }),
+      type: Type5.Union(
+        [Type5.Literal("plan"), Type5.Literal("code")],
         { description: 'Review type: "plan" or "code"' }
       ),
-      step_name: Type4.String({ description: "Name of the step being reviewed" }),
-      baseline: Type4.Optional(
-        Type4.String({
+      step_name: Type5.String({ description: "Name of the step being reviewed" }),
+      baseline: Type5.Optional(
+        Type5.String({
           description: "Git commit SHA for code review diff baseline. Capture HEAD before starting a step and pass it here."
         })
       )
@@ -62420,6 +62827,26 @@ You are working in a git worktree isolated from the main branch. Your job is to
 You are the primary implementation agent in Fusion.
 You execute task specs in isolated worktrees, produce production-quality changes, and hand off work that can pass independent review and merge.
 
+## Turn-ending rules \u2014 read carefully
+
+You MUST end every turn by either:
+- (a) calling another tool to make progress, OR
+- (b) calling \`fn_task_done\` if the entire task is complete, OR
+- (c) calling \`fn_task_done\` with a summary explaining what is blocked, if you cannot make progress for any reason
+
+You MUST NOT end a turn by writing prose that asks the user a question, summarizes progress, or requests permission to continue. The following are FORBIDDEN turn-endings:
+- "If you want, I can continue with..."
+- "Should I proceed with...?"
+- "Let me know if you'd like me to..."
+- "Ready to move on to step N. Want me to continue?"
+- Any markdown progress summary at the end of a turn instead of a tool call
+
+If you have just finished a step's work, immediately call \`fn_task_update\` to mark the step done and continue with the next pending step in the SAME turn. Do not pause to summarize.
+
+The user is not watching this conversation in real-time. They will read the final result. Asking permission wastes a full retry cycle and may orphan committed work.
+
+If you genuinely cannot proceed (blocked on a dependency, missing information, or an unresolvable error), call \`fn_task_done\` with a clear explanation of what is blocked and what is needed to unblock it. Never write the question as plain prose.
+
 ## How to work
 1. Read the PROMPT.md carefully \u2014 it contains your mission, steps, file scope, acceptance criteria, and Do NOT constraints
 2. Before touching code, read all files listed in "Context to Read First" and understand the full step outcome
@@ -62585,6 +63012,16 @@ Lint, tests, and typecheck are also hard quality gates:
 - Update tests when intended behavior changed; fix implementation when behavior regressed unintentionally
 - **CRITICAL: Resolve ALL lint failures and test failures before completing the task, even if they appear unrelated or pre-existing.** Unrelated failures left unfixed accumulate technical debt and block future integrations. Investigate and fix or suppress them \u2014 do not defer them to a separate task.
 
+## Verification commands \u2014 use fn_run_verification
+
+For ALL test/lint/build/typecheck verification, use the \`fn_run_verification\` tool, NOT raw bash.
+The tool prevents your session from being killed by the inactivity watchdog during long compiles.
+
+- Prefer **package-scoped** verification first: e.g. \`pnpm --filter @fusion/<pkg> test\` with \`scope: "package"\`. This is faster and isolated.
+- Only run **workspace-scoped** verification (\`pnpm test\`, \`pnpm lint\`, \`pnpm build\` from root) at the FINAL integration step, when you are about to call \`fn_task_done\`.
+- If you need to run \`pnpm install\` (e.g. you added a new package), use \`fn_run_verification\` with \`scope: "workspace"\` and \`timeoutSec: 600\`.
+- If a verification command times out, do NOT blindly retry \u2014 investigate. Check for hung subprocesses, infinite test loops, or tests waiting on missing dependencies. Use \`node_modules/.modules.yaml\` presence to confirm bootstrap.
+
 ## Common Pitfalls
 - Editing files outside the assigned worktree (except allowed memory/attachment paths)
 - Skipping or partially running required quality gates
@@ -63041,7 +63478,7 @@ Lint, tests, and typecheck are also hard quality gates:
        *   this as a successful retry, since the original bounce may itself be
        *   stuck.
        */
-      async performWorkflowRerunBounce(taskId, worktreePath) {
+      async performWorkflowRerunBounce(taskId, worktreePath, preserveResumeState = true) {
         if (this.workflowRerunPending.has(taskId)) {
           executorLog.warn(`${taskId}: workflow rerun bounce already in flight \u2014 skipping re-entry`);
           return "skipped-pending";
@@ -63054,7 +63491,11 @@ Lint, tests, and typecheck are also hard quality gates:
           }
           if (latestTask.column === "in-progress") {
             const originalExecutionStartedAt = latestTask.executionStartedAt;
-            await this.store.moveTask(taskId, "todo");
+            if (preserveResumeState) {
+              await this.store.moveTask(taskId, "todo", { preserveResumeState: true });
+            } else {
+              await this.store.moveTask(taskId, "todo");
+            }
             await this.store.updateTask(taskId, {
               worktree: worktreePath,
               executionStartedAt: originalExecutionStartedAt ?? null
@@ -63072,11 +63513,11 @@ Lint, tests, and typecheck are also hard quality gates:
           this.workflowRerunPending.delete(taskId);
         }
       }
-      scheduleWorkflowRerun(taskId, worktreePath, successMessage) {
+      scheduleWorkflowRerun(taskId, worktreePath, successMessage, preserveResumeState = true) {
         this.clearWorkflowRerunWatchdog(taskId);
         setTimeout(async () => {
           try {
-            const outcome = await this.performWorkflowRerunBounce(taskId, worktreePath);
+            const outcome = await this.performWorkflowRerunBounce(taskId, worktreePath, preserveResumeState);
             if (outcome === "bounced") {
               executorLog.log(successMessage);
             } else {
@@ -63108,7 +63549,7 @@ Lint, tests, and typecheck are also hard quality gates:
             `Watchdog: workflow rerun handoff stalled for ${WORKFLOW_RERUN_WATCHDOG_MS / 1e3}s (still ${currentTask.column}) \u2014 retrying once`
           ).catch(() => void 0);
           try {
-            const outcome = await this.performWorkflowRerunBounce(taskId, worktreePath);
+            const outcome = await this.performWorkflowRerunBounce(taskId, worktreePath, preserveResumeState);
             if (outcome === "bounced") {
               executorLog.warn(`${taskId}: workflow rerun watchdog retry succeeded`);
             } else {
@@ -63246,7 +63687,7 @@ Lint, tests, and typecheck are also hard quality gates:
             return false;
           }
           const settings = await this.store.getSettings();
-          if (task.worktree && existsSync26(task.worktree)) {
+          if (task.worktree && existsSync27(task.worktree)) {
             const modifiedFiles = await this.captureModifiedFiles(task.worktree, task.baseCommitSha);
             if (modifiedFiles.length > 0) {
               await this.store.updateTask(task.id, { modifiedFiles });
@@ -63255,7 +63696,7 @@ Lint, tests, and typecheck are also hard quality gates:
             if (task.executionMode !== "fast") {
               const workflowResult = await this.runWorkflowSteps(task, task.worktree, settings);
               if (!workflowResult.allPassed) {
-                await this.sendTaskBackForFix(task, task.worktree, workflowResult.feedback, workflowResult.stepName || "Unknown", "Workflow step failed during recovery");
+                await this.sendTaskBackForFix(task, task.worktree, workflowResult.feedback, workflowResult.stepName || "Unknown", "Workflow step failed during recovery", false);
                 return true;
               }
             } else {
@@ -63407,7 +63848,7 @@ Lint, tests, and typecheck are also hard quality gates:
         if (task.dependencies.length === 0) return null;
         for (const depId of task.dependencies) {
           const dep = allTasks.find((t) => t.id === depId);
-          if (dep && dep.worktree && (dep.column === "done" || dep.column === "in-review") && existsSync26(dep.worktree)) {
+          if (dep && dep.worktree && (dep.column === "done" || dep.column === "in-review") && existsSync27(dep.worktree)) {
             return dep.worktree;
           }
         }
@@ -63458,7 +63899,7 @@ Lint, tests, and typecheck are also hard quality gates:
         const activeMergeStatuses = /* @__PURE__ */ new Set(["merging", "merging-pr"]);
         const isActiveTask = activeColumns.has(task.column) || activeMergeStatuses.has(task.status ?? "");
         if (!isActiveTask) {
-          const tasksDir = join33(this.store.getFusionDir(), "tasks");
+          const tasksDir = join34(this.store.getFusionDir(), "tasks");
           const promptPath = getPromptPath(tasksDir, task.id);
           const staleness = await evaluateSpecStaleness({ settings, promptPath });
           if (staleness.isStale) {
@@ -63505,7 +63946,7 @@ Lint, tests, and typecheck are also hard quality gates:
               worktreeName = generateWorktreeName(this.rootDir);
               break;
           }
-          worktreePath = join33(this.rootDir, ".worktrees", worktreeName);
+          worktreePath = join34(this.rootDir, ".worktrees", worktreeName);
         }
         let stuckRequeue = null;
         let taskDone = false;
@@ -63528,8 +63969,8 @@ Lint, tests, and typecheck are also hard quality gates:
               "Project directory is not a Git repository. Fusion requires a Git repository for worktree creation. Initialize with 'git init' or run from a Git project directory."
             );
           }
-          const branchName = `fusion/${task.id.toLowerCase()}`;
-          let isResume = existsSync26(worktreePath);
+          const branchName = task.branch || `fusion/${task.id.toLowerCase()}`;
+          let isResume = existsSync27(worktreePath);
           let acquiredFromPool = false;
           const baseBranch = task.baseBranch || null;
           if (task.worktree && isResume && !await isUsableTaskWorktree(this.rootDir, worktreePath)) {
@@ -63542,8 +63983,8 @@ Lint, tests, and typecheck are also hard quality gates:
               this.currentRunContext
             );
             await this.store.updateTask(task.id, { worktree: null, branch: null });
-            worktreePath = join33(this.rootDir, ".worktrees", generateWorktreeName(this.rootDir));
-            isResume = existsSync26(worktreePath);
+            worktreePath = join34(this.rootDir, ".worktrees", generateWorktreeName(this.rootDir));
+            isResume = existsSync27(worktreePath);
           }
           if (!isResume) {
             if (this.options.pool && settings.recycleWorktrees) {
@@ -63665,6 +64106,9 @@ Lint, tests, and typecheck are also hard quality gates:
               await this.store.updateStep(task.id, 0, "pending");
             }
           }
+          if (isResume && task.branch && detail.steps.length > 0) {
+            await this.reconcileStepsFromGitHistory(task.id, detail, worktreePath);
+          }
           const skillContext = await buildSessionSkillContext({
             agentStore: this.options.agentStore,
             task: detail,
@@ -63735,7 +64179,7 @@ Lint, tests, and typecheck are also hard quality gates:
               if (this.pausedAborted.has(task.id)) {
                 this.pausedAborted.delete(task.id);
                 await this.store.logEntry(task.id, "Execution paused \u2014 step sessions terminated, moved to todo", void 0, this.currentRunContext);
-                await this.store.moveTask(task.id, "todo");
+                await this.store.moveTask(task.id, "todo", { preserveResumeState: true });
                 return;
               }
               if (this.stuckAborted.has(task.id)) {
@@ -63819,7 +64263,7 @@ Lint, tests, and typecheck are also hard quality gates:
               } else if (this.pausedAborted.has(task.id)) {
                 this.pausedAborted.delete(task.id);
                 await this.store.logEntry(task.id, "Execution paused during step-session", void 0, this.currentRunContext);
-                await this.store.moveTask(task.id, "todo");
+                await this.store.moveTask(task.id, "todo", { preserveResumeState: true });
               } else if (this.stuckAborted.has(task.id)) {
                 stuckRequeue = this.stuckAborted.get(task.id) ?? true;
                 this.stuckAborted.delete(task.id);
@@ -63837,7 +64281,7 @@ Lint, tests, and typecheck are also hard quality gates:
                     executorLog.warn(`\u26A1 ${task.id} transient error \u2014 retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay2}: ${errorMessage}`);
                     await this.store.logEntry(task.id, `Transient error (retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay2}): ${errorMessage}`, void 0, this.currentRunContext);
                   }
-                  if (worktreePath && existsSync26(worktreePath)) {
+                  if (worktreePath && existsSync27(worktreePath)) {
                     try {
                       await execAsync5(`git worktree remove "${worktreePath}" --force`, { cwd: this.rootDir });
                       await audit.git({ type: "worktree:remove", target: worktreePath });
@@ -63896,7 +64340,7 @@ Lint, tests, and typecheck are also hard quality gates:
                 try {
                   const latestTask = await this.store.getTask(task.id);
                   await this.resetStepsIfWorkLost(latestTask);
-                  if (worktreePath && existsSync26(worktreePath)) {
+                  if (worktreePath && existsSync27(worktreePath)) {
                     try {
                       await execAsync5(`git worktree remove "${worktreePath}" --force`, { cwd: this.rootDir });
                     } catch (wtErr) {
@@ -63938,6 +64382,17 @@ Lint, tests, and typecheck are also hard quality gates:
             this.createTaskDoneTool(task.id, () => {
               taskDone = true;
             }),
+            createRunVerificationTool({
+              worktreePath,
+              rootDir: this.rootDir,
+              taskId: task.id,
+              recordActivity: () => stuckDetector?.recordActivity(task.id),
+              log: {
+                info: (s) => executorLog.log(s),
+                warn: (s) => executorLog.warn(s),
+                error: (s) => executorLog.warn(s)
+              }
+            }),
             // Skip fn_review_step tool in fast mode — fast mode bypasses automated review gates
             ...executionMode !== "fast" ? [
               this.createReviewStepTool(task.id, worktreePath, detail.prompt, codeReviewVerdicts, sessionRef, stepCheckpoints, detail, stuckDetector)
@@ -63967,11 +64422,13 @@ Lint, tests, and typecheck are also hard quality gates:
             // Add plugin tools from PluginRunner
             ...this.options.pluginRunner?.getPluginTools() ?? []
           ];
+          let lastAssistantText = "";
           const agentLogger = new AgentLogger({
             store: this.store,
             taskId: task.id,
             agent: "executor",
             onAgentText: (taskId, delta) => {
+              lastAssistantText += delta;
               stuckDetector?.recordActivity(taskId);
               this.options.onAgentText?.(taskId, delta);
             },
@@ -63989,7 +64446,7 @@ Lint, tests, and typecheck are also hard quality gates:
             const executorFallbackProvider = settings.fallbackProvider;
             const executorFallbackModelId = settings.fallbackModelId;
             const executorThinkingLevel = detail.thinkingLevel ?? settings.defaultThinkingLevel;
-            const isResuming = !!task.sessionFile && existsSync26(task.sessionFile);
+            const isResuming = !!task.sessionFile && existsSync27(task.sessionFile);
             const sessionManager = isResuming ? SessionManager2.open(task.sessionFile) : SessionManager2.create(worktreePath);
             executorLog.log(`${task.id}: creating agent session (provider=${executorProvider ?? "default"}, model=${executorModelId ?? "default"}, resuming=${isResuming})`);
             const executorInstructions = await this.resolveInstructionsForRole("executor");
@@ -64124,7 +64581,7 @@ Lint, tests, and typecheck are also hard quality gates:
                 } else {
                   executorLog.log(`${task.id} paused (graceful session exit) \u2014 moving to todo`);
                   await this.store.logEntry(task.id, "Execution paused \u2014 session preserved for resume, moved to todo");
-                  await this.store.moveTask(task.id, "todo");
+                  await this.store.moveTask(task.id, "todo", { preserveResumeState: true });
                 }
                 return;
               }
@@ -64188,6 +64645,19 @@ Lint, tests, and typecheck are also hard quality gates:
                     void 0,
                     this.currentRunContext
                   );
+                  const previousSessionText = lastAssistantText;
+                  const pseudoPause = detectPseudoPause(previousSessionText);
+                  if (pseudoPause.kind !== "none") {
+                    const shortMatch = (pseudoPause.matched ?? "").slice(0, 120);
+                    await this.store.logEntry(
+                      task.id,
+                      `Pseudo-pause detected (kind=${pseudoPause.kind}, matched='${shortMatch}')`,
+                      void 0,
+                      this.currentRunContext
+                    );
+                    executorLog.log(`${task.id} pseudo-pause detected (kind=${pseudoPause.kind}): ${shortMatch}`);
+                  }
+                  lastAssistantText = "";
                   this.activeSessions.delete(task.id);
                   this.tokenUsageBaselines.delete(task.id);
                   session.dispose();
@@ -64227,15 +64697,38 @@ Lint, tests, and typecheck are also hard quality gates:
                     lastModelId: detail.modelId
                   });
                   stuckDetector?.trackTask(task.id, retrySession2);
-                  const retryPrompt = [
-                    "Your previous session ended without calling the fn_task_done tool.",
-                    "The task may already be complete \u2014 review the current state of the worktree and either:",
-                    "1. If the work is done, call fn_task_done with a summary of what was accomplished.",
-                    "2. If there is remaining work, finish it and then call fn_task_done.",
-                    "",
-                    "Original task:",
-                    buildExecutionPrompt(detail, this.rootDir, settings, worktreePath)
-                  ].join("\n");
+                  let retryPrompt;
+                  if (pseudoPause.kind !== "none") {
+                    const shortMatch = (pseudoPause.matched ?? "").slice(0, 120);
+                    retryPrompt = [
+                      `Your previous turn ended with a pseudo-pause: "${shortMatch}". This is forbidden.`,
+                      "",
+                      "Turn-ending rules you violated:",
+                      "- You MUST NOT end a turn by asking the user a question, summarizing progress, or requesting permission to continue.",
+                      "- Phrases like 'If you want, I can continue', 'Should I proceed?', 'Let me know if...' are FORBIDDEN turn-endings.",
+                      "- The user is not watching this conversation. Questions written as prose are ignored.",
+                      "- If you genuinely cannot proceed, call fn_task_done with a clear explanation \u2014 never write the blocker as plain prose.",
+                      "",
+                      "What you must do now:",
+                      "1. Review the PROMPT.md steps and identify the next pending step.",
+                      "2. Do the work for that step immediately \u2014 call fn_task_update, write code, run tests.",
+                      "3. Continue until all steps are done, then call fn_task_done.",
+                      "Do NOT ask for permission. Do NOT write a summary. Just call a tool and keep working.",
+                      "",
+                      "Original task:",
+                      buildExecutionPrompt(detail, this.rootDir, settings, worktreePath)
+                    ].join("\n");
+                  } else {
+                    retryPrompt = [
+                      "Your previous session ended without calling the fn_task_done tool.",
+                      "The task may already be complete \u2014 review the current state of the worktree and either:",
+                      "1. If the work is done, call fn_task_done with a summary of what was accomplished.",
+                      "2. If there is remaining work, finish it and then call fn_task_done.",
+                      "",
+                      "Original task:",
+                      buildExecutionPrompt(detail, this.rootDir, settings, worktreePath)
+                    ].join("\n");
+                  }
                   stuckDetector?.recordActivity(task.id);
                   await promptWithFallback(retrySession2, retryPrompt);
                   checkSessionError(retrySession2);
@@ -64372,7 +64865,7 @@ Lint, tests, and typecheck are also hard quality gates:
               this.options.onComplete?.(task);
             } else {
               executorLog.log(`${task.id} paused \u2014 moving to todo`);
-              if (worktreePath && existsSync26(worktreePath)) {
+              if (worktreePath && existsSync27(worktreePath)) {
                 try {
                   await execAsync5(`git worktree remove "${worktreePath}" --force`, { cwd: this.rootDir });
                   executorLog.log(`Removed old worktree for paused task: ${worktreePath}`);
@@ -64442,9 +64935,10 @@ Lint, tests, and typecheck are also hard quality gates:
                 await this.store.logEntry(task.id, `Context-overflow fresh-session requeue (${attempt}/${MAX_RECOVERY_RETRIES} in ${delay2}): ${errorMessage}`, void 0, this.currentRunContext);
                 await this.store.updateTask(task.id, {
                   recoveryRetryCount: decision.nextState.recoveryRetryCount,
-                  nextRecoveryAt: decision.nextState.nextRecoveryAt
+                  nextRecoveryAt: decision.nextState.nextRecoveryAt,
+                  sessionFile: null
                 });
-                await this.store.moveTask(task.id, "todo");
+                await this.store.moveTask(task.id, "todo", { preserveResumeState: true });
                 return;
               }
               executorLog.error(`\u2717 ${task.id} context-overflow requeue budget exhausted (${MAX_RECOVERY_RETRIES} attempts): ${errorMessage}`);
@@ -64467,7 +64961,7 @@ Lint, tests, and typecheck are also hard quality gates:
                   executorLog.warn(`\u26A1 ${task.id} transient error \u2014 retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay2}: ${errorMessage}`);
                   await this.store.logEntry(task.id, `Transient error (retry ${attempt}/${MAX_RECOVERY_RETRIES} in ${delay2}): ${errorMessage}`, void 0, this.currentRunContext);
                 }
-                if (worktreePath && existsSync26(worktreePath)) {
+                if (worktreePath && existsSync27(worktreePath)) {
                   try {
                     await execAsync5(`git worktree remove "${worktreePath}" --force`, { cwd: this.rootDir });
                     executorLog.log(`Removed old worktree for transient retry: ${worktreePath}`);
@@ -64522,7 +65016,7 @@ Lint, tests, and typecheck are also hard quality gates:
             try {
               const latestTask = await this.store.getTask(task.id);
               await this.resetStepsIfWorkLost(latestTask);
-              if (worktreePath && existsSync26(worktreePath)) {
+              if (worktreePath && existsSync27(worktreePath)) {
                 try {
                   await execAsync5(`git worktree remove "${worktreePath}" --force`, { cwd: this.rootDir });
                   executorLog.log(`Removed old worktree for stuck-killed retry: ${worktreePath}`);
@@ -64569,19 +65063,39 @@ Lint, tests, and typecheck are also hard quality gates:
                 details: {}
               };
             }
-            if (status === "in-progress" && sessionRef.current) {
+            const stepIndex = step - 1;
+            if (!Number.isInteger(stepIndex) || stepIndex < 0) {
+              return {
+                content: [{
+                  type: "text",
+                  text: `Invalid step number: ${step}. Steps are 1-indexed.`
+                }],
+                details: {}
+              };
+            }
+            const task = await store.updateStep(taskId, stepIndex, status);
+            const stepInfo = task.steps[stepIndex];
+            const persistedStatus = stepInfo.status;
+            const progress = task.steps.filter((s) => s.status === "done").length;
+            if (status === "in-progress" && persistedStatus === "in-progress" && sessionRef.current) {
               const leafId = sessionRef.current.sessionManager.getLeafId();
               if (leafId) {
                 stepCheckpoints.set(step, leafId);
               }
             }
-            const task = await store.updateStep(taskId, step, status);
-            const stepInfo = task.steps[step];
-            const progress = task.steps.filter((s) => s.status === "done").length;
+            if (persistedStatus !== status) {
+              return {
+                content: [{
+                  type: "text",
+                  text: `Step ${step} (${stepInfo.name}) is already ${persistedStatus} \u2014 ${status} request ignored to preserve completed work. Progress: ${progress}/${task.steps.length} done.`
+                }],
+                details: {}
+              };
+            }
             return {
               content: [{
                 type: "text",
-                text: `Step ${step} (${stepInfo.name}) \u2192 ${status}. Progress: ${progress}/${task.steps.length} done.`
+                text: `Step ${step} (${stepInfo.name}) \u2192 ${persistedStatus}. Progress: ${progress}/${task.steps.length} done.`
               }],
               details: {}
             };
@@ -64676,8 +65190,8 @@ Lint, tests, and typecheck are also hard quality gates:
           name: "fn_task_done",
           label: "Mark Task Done",
           description: "Signal that all steps are complete, tests pass, and documentation is updated. Call this as the final action after finishing all work. Automatically marks all remaining steps as done. Optionally provide a summary of what was changed/fixed.",
-          parameters: Type4.Object({
-            summary: Type4.Optional(Type4.String({
+          parameters: Type5.Object({
+            summary: Type5.Optional(Type5.String({
               description: "Optional summary of what was changed/fixed and what was verified (2-4 sentences)"
             }))
           }),
@@ -64983,7 +65497,7 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
        * The section is replaced entirely to avoid accumulation of old feedback.
        */
       async injectWorkflowRevisionInstructions(task, feedback) {
-        const promptPath = join33(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
+        const promptPath = join34(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
         let content;
         try {
           content = await readFile14(promptPath, "utf-8");
@@ -65069,7 +65583,7 @@ ${feedback}
        * Injects failure feedback into PROMPT.md, resets steps, clears session,
        * and schedules a move to todo → in-progress after the executing guard clears.
        */
-      async sendTaskBackForFix(task, worktreePath, failureFeedback, stepName, reason) {
+      async sendTaskBackForFix(task, worktreePath, failureFeedback, stepName, reason, preserveResumeState = true) {
         const taskId = task.id;
         this.clearCompletedTaskWatchdog(taskId);
         await this.store.addTaskComment(
@@ -65096,7 +65610,8 @@ Please fix the issues so the verification can pass on the next attempt.`,
         this.scheduleWorkflowRerun(
           taskId,
           worktreePath,
-          `${taskId}: sent back to in-progress for remediation`
+          `${taskId}: sent back to in-progress for remediation`,
+          preserveResumeState
         );
       }
       /**
@@ -65105,7 +65620,7 @@ Please fix the issues so the verification can pass on the next attempt.`,
        * The section is replaced entirely to avoid accumulation of old feedback.
        */
       async injectWorkflowStepFailureInstructions(task, failureFeedback, stepName, retryCount) {
-        const promptPath = join33(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
+        const promptPath = join34(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
         let content;
         try {
           content = await readFile14(promptPath, "utf-8");
@@ -65889,7 +66404,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
        * rather than fail the task permanently.
        */
       async resolveWorktreeStartPoint(startPoint, taskId) {
-        const command = isAbsolute10(startPoint) && existsSync26(startPoint) ? `git -C "${startPoint}" rev-parse --verify HEAD^{commit}` : `git rev-parse --verify "${startPoint}^{commit}"`;
+        const command = isAbsolute11(startPoint) && existsSync27(startPoint) ? `git -C "${startPoint}" rev-parse --verify HEAD^{commit}` : `git rev-parse --verify "${startPoint}^{commit}"`;
         try {
           const { stdout } = await execAsync5(command, { cwd: this.rootDir });
           return stdout.trim() || startPoint;
@@ -65909,7 +66424,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
        */
       async tryCreateWorktree(branch, path5, taskId, startPoint, attemptNumber = 0, recoveryDepth = 0) {
         await this.assertWorktreePathNotNested(path5, taskId);
-        if (existsSync26(path5)) {
+        if (existsSync27(path5)) {
           const isRegistered = await this.isRegisteredWorktree(path5);
           if (!isRegistered) {
             await this.store.logEntry(
@@ -66059,7 +66574,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
           taskId
         );
         if (shouldGenerateNewName) {
-          const newPath = join33(this.rootDir, ".worktrees", generateWorktreeName(this.rootDir));
+          const newPath = join34(this.rootDir, ".worktrees", generateWorktreeName(this.rootDir));
           for (let suffix = 2; suffix <= 6; suffix++) {
             const suffixedBranch = `${branch}-${suffix}`;
             try {
@@ -66107,7 +66622,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
           if (wt === rootResolved) continue;
           if (wt === target) continue;
           const rel = relative6(wt, target);
-          if (rel && !rel.startsWith("..") && !isAbsolute10(rel)) {
+          if (rel && !rel.startsWith("..") && !isAbsolute11(rel)) {
             await this.store.logEntry(
               taskId,
               `Refusing to create nested worktree`,
@@ -66351,6 +66866,69 @@ Review the work done in this worktree and evaluate it against the criteria in yo
           executorLog.log(`${taskId}: recovered ${recovered} approved step(s) on resume`);
         }
       }
+      /**
+       * On resume (task already has a branch from a prior run), walk git history
+       * and mark steps as done when a commit matching the step-completion convention
+       * is found. This prevents the agent from redoing already-committed work after
+       * an auto-requeue.
+       *
+       * Commit message convention (case-insensitive):
+       *   feat|chore|fix(FN-XXXX): complete Step N
+       *
+       * Called after the worktree is acquired and before the agent session starts.
+       */
+      async reconcileStepsFromGitHistory(taskId, detail, worktreePath) {
+        const baseCommitSha = detail.baseCommitSha;
+        if (!baseCommitSha) return;
+        const pendingOrInProgressSteps = detail.steps.filter(
+          (s, i) => (s.status === "pending" || s.status === "in-progress") && i > 0
+        );
+        if (pendingOrInProgressSteps.length === 0) return;
+        let logOutput;
+        try {
+          const { stdout } = await execAsync5(
+            `git log "${baseCommitSha}..HEAD" --oneline`,
+            { cwd: worktreePath }
+          );
+          logOutput = stdout;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          executorLog.warn(`${taskId}: reconcileStepsFromGitHistory \u2014 git log failed: ${msg}`);
+          return;
+        }
+        if (!logOutput.trim()) return;
+        const stepCommitRegex = /^(?:feat|chore|fix)\([Ff][Nn]-\d+\)(?:!)?:\s*complete\s+step\s+(\d+)/i;
+        const reconciledStepIndices = /* @__PURE__ */ new Set();
+        for (const line of logOutput.split("\n")) {
+          const message = line.replace(/^[0-9a-f]+ /, "").trim();
+          const match = message.match(stepCommitRegex);
+          if (!match) continue;
+          const stepIndex = parseInt(match[1], 10);
+          if (Number.isNaN(stepIndex) || stepIndex < 0 || stepIndex >= detail.steps.length) continue;
+          const step = detail.steps[stepIndex];
+          if (step.status === "pending" || step.status === "in-progress") {
+            reconciledStepIndices.add(stepIndex);
+          }
+        }
+        for (const stepIndex of reconciledStepIndices) {
+          await this.store.updateStep(taskId, stepIndex, "done");
+          await this.store.logEntry(
+            taskId,
+            `Reconciled Step ${stepIndex} as done from git history (resume)`,
+            void 0,
+            this.currentRunContext
+          );
+          executorLog.log(`${taskId}: reconciled Step ${stepIndex} as done from git history`);
+        }
+        if (reconciledStepIndices.size > 0) {
+          const updated = await this.store.getTask(taskId);
+          const lowestPending = updated.steps.findIndex((s) => s.status === "pending" || s.status === "in-progress");
+          if (lowestPending >= 0 && lowestPending !== updated.currentStep) {
+            await this.store.updateTask(taskId, { currentStep: lowestPending });
+            executorLog.log(`${taskId}: set currentStep to ${lowestPending} after step reconciliation`);
+          }
+        }
+      }
       /**
        * Check whether the task's branch has any unique commits compared to main.
        * If the branch has no unique commits and the task has steps marked done,
@@ -66596,7 +67174,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
                 metadata: { type: "spawned", parentTaskId: taskId }
               });
               const childWorktreeName = generateWorktreeName(this.rootDir);
-              const childWorktreePath = join33(this.rootDir, ".worktrees", childWorktreeName);
+              const childWorktreePath = join34(this.rootDir, ".worktrees", childWorktreeName);
               const childBranch = `fusion/spawn-${agent.id}`;
               await this.createWorktree(childBranch, childWorktreePath, taskId, worktreePath);
               await this.options.agentStore.updateAgentState(agent.id, "active");
@@ -66784,9 +67362,9 @@ var init_node_routing_policy = __esm({
 });
 
 // ../engine/src/scheduler.ts
-import { existsSync as existsSync27 } from "node:fs";
+import { existsSync as existsSync28 } from "node:fs";
 import { readFile as readFile15 } from "node:fs/promises";
-import { basename as basename8, join as join34 } from "node:path";
+import { basename as basename8, join as join35 } from "node:path";
 function pathsOverlap2(a, b) {
   for (const pa of a) {
     const prefixA = pa.endsWith("/*") ? pa.slice(0, -1) : null;
@@ -66956,12 +67534,12 @@ var init_scheduler = __esm({
        * @returns Object with `valid: true` if checks pass, or `valid: false` with a `reason` string if they fail
        */
       async validateTaskFilesystem(id) {
-        const taskDir = join34(this.store.getTasksDir(), id);
-        if (!existsSync27(taskDir)) {
+        const taskDir = join35(this.store.getTasksDir(), id);
+        if (!existsSync28(taskDir)) {
           return { valid: false, reason: "missing directory" };
         }
-        const promptPath = join34(taskDir, "PROMPT.md");
-        if (!existsSync27(promptPath)) {
+        const promptPath = join35(taskDir, "PROMPT.md");
+        if (!existsSync28(promptPath)) {
           return { valid: false, reason: "missing or empty PROMPT.md" };
         }
         try {
@@ -67083,7 +67661,7 @@ var init_scheduler = __esm({
             break;
         }
         reservedNames.add(worktreeName);
-        return join34(this.store.getRootDir(), ".worktrees", worktreeName);
+        return join35(this.store.getRootDir(), ".worktrees", worktreeName);
       }
       /**
        * Run one scheduling pass.
@@ -69038,7 +69616,7 @@ __export(agent_reflection_exports, {
   AgentReflectionService: () => AgentReflectionService
 });
 import { readFile as readFile16 } from "node:fs/promises";
-import { isAbsolute as isAbsolute11, resolve as resolve14 } from "node:path";
+import { isAbsolute as isAbsolute12, resolve as resolve14 } from "node:path";
 var reflectionLog, REFLECTION_SYSTEM_PROMPT, DEFAULT_OUTCOME_LIMIT, AgentReflectionService;
 var init_agent_reflection = __esm({
   "../engine/src/agent-reflection.ts"() {
@@ -69349,7 +69927,7 @@ Rules:
           pieces.push(agent.instructionsText.trim());
         }
         if (agent.instructionsPath?.trim()) {
-          const resolvedPath = isAbsolute11(agent.instructionsPath) ? agent.instructionsPath : resolve14(this.rootDir, agent.instructionsPath);
+          const resolvedPath = isAbsolute12(agent.instructionsPath) ? agent.instructionsPath : resolve14(this.rootDir, agent.instructionsPath);
           try {
             const content = await readFile16(resolvedPath, "utf-8");
             if (content.trim()) {
@@ -69388,7 +69966,7 @@ Rules:
 });
 
 // ../engine/src/agent-heartbeat.ts
-import { Type as Type5 } from "@mariozechner/pi-ai";
+import { Type as Type6 } from "@mariozechner/pi-ai";
 function isBlockedStateDuplicate(current, previous) {
   return current.blockedBy === previous.blockedBy && current.contextHash === previous.contextHash;
 }
@@ -69592,8 +70170,8 @@ When sending messages:
 Critical: a heartbeat without observable progress (a log, a document write, a
 status change, a comment, a delegation, or an explicit "no-op with reason") is
 a bug. Do not loop on the same plan across heartbeats without recording why.`;
-    heartbeatDoneParams = Type5.Object({
-      summary: Type5.Optional(Type5.String({ description: "Summary of what was accomplished this heartbeat" }))
+    heartbeatDoneParams = Type6.Object({
+      summary: Type6.Optional(Type6.String({ description: "Summary of what was accomplished this heartbeat" }))
     });
     HeartbeatMonitor = class {
       store;
@@ -72258,7 +72836,7 @@ ${source.content ?? ""}`;
 
 // ../engine/src/research/providers/local-docs-provider.ts
 import { promises as fs } from "node:fs";
-import { extname as extname2, join as join35, relative as relative7, resolve as resolve15 } from "node:path";
+import { extname as extname2, join as join36, relative as relative7, resolve as resolve15 } from "node:path";
 function buildExcerpt(content, terms) {
   const lower = content.toLowerCase();
   const first = terms.find((term) => lower.includes(term));
@@ -72387,7 +72965,7 @@ var init_local_docs_provider = __esm({
         const rootEntries = await fs.readdir(this.projectRoot, { withFileTypes: true });
         for (const entry of rootEntries) {
           if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
-            files.push(join35(this.projectRoot, entry.name));
+            files.push(join36(this.projectRoot, entry.name));
           }
         }
         return [...new Set(files)];
@@ -72397,7 +72975,7 @@ var init_local_docs_provider = __esm({
         const entries = await fs.readdir(dir2, { withFileTypes: true });
         for (const entry of entries) {
           this.throwIfAborted(signal);
-          const fullPath = join35(dir2, entry.name);
+          const fullPath = join36(dir2, entry.name);
           const relPath = relative7(this.projectRoot, fullPath).replace(/\\/g, "/");
           if (matchesGitignore(relPath, ignorePatterns)) continue;
           if (entry.isDirectory()) {
@@ -72422,7 +73000,7 @@ var init_local_docs_provider = __esm({
       }
       async readGitignore() {
         try {
-          const content = await fs.readFile(join35(this.projectRoot, ".gitignore"), "utf-8");
+          const content = await fs.readFile(join36(this.projectRoot, ".gitignore"), "utf-8");
           return content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
         } catch {
           return [];
@@ -73938,7 +74516,22 @@ var init_shell_utils = __esm({
 
 // ../engine/src/cron-runner.ts
 import { exec as exec6 } from "node:child_process";
-import { promisify as promisify7 } from "node:util";
+function execCommand(command, options) {
+  return new Promise((resolve39, reject2) => {
+    exec6(command, options, (error, stdout, stderr) => {
+      const stdoutText = typeof stdout === "string" ? stdout : String(stdout ?? "");
+      const stderrText = typeof stderr === "string" ? stderr : String(stderr ?? "");
+      if (error) {
+        const errWithOutput = error;
+        errWithOutput.stdout = stdoutText;
+        errWithOutput.stderr = stderrText;
+        reject2(errWithOutput);
+        return;
+      }
+      resolve39({ stdout: stdoutText, stderr: stderrText });
+    });
+  });
+}
 async function createAiPromptExecutor(cwd) {
   const disposeLog = createLogger2("cron-runner");
   return async (prompt, modelProvider, modelId) => {
@@ -73966,17 +74559,19 @@ async function createAiPromptExecutor(cwd) {
   };
 }
 function truncateOutput(stdout, stderr) {
-  let combined = stdout;
-  if (stderr) {
-    combined += stdout ? "\n--- stderr ---\n" : "";
-    combined += stderr;
+  const out = stdout ?? "";
+  const err = stderr ?? "";
+  let combined = out;
+  if (err) {
+    combined += out ? "\n--- stderr ---\n" : "";
+    combined += err;
   }
   if (combined.length > MAX_OUTPUT_LENGTH) {
     combined = combined.slice(0, MAX_OUTPUT_LENGTH) + "\n[output truncated]";
   }
   return combined;
 }
-var execAsync6, log14, DEFAULT_TIMEOUT_MS6, MAX_BUFFER, MAX_OUTPUT_LENGTH, DEFAULT_POLL_INTERVAL_MS, MIN_POLL_INTERVAL_MS, CronRunner, AI_AUTOMATION_SYSTEM_PROMPT;
+var log14, DEFAULT_TIMEOUT_MS6, MAX_BUFFER, MAX_OUTPUT_LENGTH, DEFAULT_POLL_INTERVAL_MS, MIN_POLL_INTERVAL_MS, CronRunner, AI_AUTOMATION_SYSTEM_PROMPT;
 var init_cron_runner = __esm({
   "../engine/src/cron-runner.ts"() {
     "use strict";
@@ -73984,7 +74579,6 @@ var init_cron_runner = __esm({
     init_logger2();
     init_shell_utils();
     init_pi();
-    execAsync6 = promisify7(exec6);
     log14 = createLogger2("cron-runner");
     DEFAULT_TIMEOUT_MS6 = 5 * 60 * 1e3;
     MAX_BUFFER = 1024 * 1024;
@@ -74128,7 +74722,7 @@ var init_cron_runner = __esm({
         log14.log(`Executing ${schedule.name} (${schedule.id}): ${schedule.command}`);
         try {
           const timeoutMs = schedule.timeoutMs ?? DEFAULT_TIMEOUT_MS6;
-          const { stdout, stderr } = await execAsync6(schedule.command, {
+          const { stdout, stderr } = await execCommand(schedule.command, {
             timeout: timeoutMs,
             maxBuffer: MAX_BUFFER,
             shell: defaultShell
@@ -74245,7 +74839,7 @@ var init_cron_runner = __esm({
           };
         }
         try {
-          const { stdout, stderr } = await execAsync6(step.command, {
+          const { stdout, stderr } = await execCommand(step.command, {
             timeout: timeoutMs,
             maxBuffer: MAX_BUFFER,
             shell: defaultShell
@@ -74318,8 +74912,9 @@ var init_cron_runner = __esm({
             setTimeout(() => reject2(new Error(`AI prompt step timed out after ${timeoutMs / 1e3}s`)), timeoutMs);
           });
           const response = await Promise.race([resultPromise, timeoutPromise]);
-          const output = response.length > MAX_OUTPUT_LENGTH ? response.slice(0, MAX_OUTPUT_LENGTH) + "\n[output truncated]" : response;
-          log14.log(`    \u2713 AI prompt step "${step.name}" completed (${response.length} chars)`);
+          const responseText = String(response ?? "");
+          const output = responseText.length > MAX_OUTPUT_LENGTH ? responseText.slice(0, MAX_OUTPUT_LENGTH) + "\n[output truncated]" : responseText;
+          log14.log(`    \u2713 AI prompt step "${step.name}" completed (${responseText.length} chars)`);
           return {
             stepId: step.id,
             stepName: step.name,
@@ -74416,7 +75011,7 @@ var init_cron_runner = __esm({
 
 // ../engine/src/routine-runner.ts
 import { exec as exec7 } from "node:child_process";
-import { promisify as promisify8 } from "node:util";
+import { promisify as promisify7 } from "node:util";
 function truncateOutput2(stdout, stderr) {
   let output = stdout;
   if (stderr) {
@@ -74429,7 +75024,7 @@ function truncateOutput2(stdout, stderr) {
   }
   return output;
 }
-var import_cron_parser4, log15, execAsync7, DEFAULT_TIMEOUT_MS7, MAX_BUFFER2, MAX_OUTPUT_LENGTH2, MAX_CATCH_UP_INTERVALS, RoutineRunner;
+var import_cron_parser4, log15, execAsync6, DEFAULT_TIMEOUT_MS7, MAX_BUFFER2, MAX_OUTPUT_LENGTH2, MAX_CATCH_UP_INTERVALS, RoutineRunner;
 var init_routine_runner = __esm({
   "../engine/src/routine-runner.ts"() {
     "use strict";
@@ -74437,7 +75032,7 @@ var init_routine_runner = __esm({
     init_logger2();
     init_shell_utils();
     log15 = createLogger2("routine-runner");
-    execAsync7 = promisify8(exec7);
+    execAsync6 = promisify7(exec7);
     DEFAULT_TIMEOUT_MS7 = 5 * 60 * 1e3;
     MAX_BUFFER2 = 1024 * 1024;
     MAX_OUTPUT_LENGTH2 = 10 * 1024;
@@ -74592,7 +75187,7 @@ var init_routine_runner = __esm({
       }
       async executeCommand(command, timeoutMs, startedAt) {
         try {
-          const { stdout, stderr } = await execAsync7(command, {
+          const { stdout, stderr } = await execAsync6(command, {
             timeout: timeoutMs ?? DEFAULT_TIMEOUT_MS7,
             maxBuffer: MAX_BUFFER2,
             shell: defaultShell
@@ -75291,9 +75886,9 @@ var init_stuck_task_detector = __esm({
 
 // ../engine/src/self-healing.ts
 import { exec as exec8 } from "node:child_process";
-import { promisify as promisify9 } from "node:util";
-import { existsSync as existsSync28, readdirSync as readdirSync5, rmSync as rmSync3, statSync as statSync5 } from "node:fs";
-import { isAbsolute as isAbsolute12, join as join36, relative as relative8, resolve as resolve16 } from "node:path";
+import { promisify as promisify8 } from "node:util";
+import { existsSync as existsSync29, readdirSync as readdirSync5, rmSync as rmSync3, statSync as statSync5 } from "node:fs";
+import { isAbsolute as isAbsolute13, join as join37, relative as relative8, resolve as resolve16 } from "node:path";
 function shellQuote(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
@@ -75327,7 +75922,7 @@ function isNoTaskDoneFailure(task) {
 function hasStepProgress(task) {
   return task.steps.some((step) => step.status !== "pending");
 }
-var log16, execAsync8, APPROVED_TRIAGE_RECOVERY_GRACE_MS, ORPHANED_EXECUTION_RECOVERY_GRACE_MS, ACTIVE_MERGE_STATUSES, NON_TERMINAL_STEP_STATUSES2, GHOST_REVIEW_PRESERVED_STATUSES, ORPHANED_WITH_WORKTREE_GRACE_MS, MAX_TASK_DONE_RETRIES, SelfHealingManager;
+var log16, execAsync7, APPROVED_TRIAGE_RECOVERY_GRACE_MS, ORPHANED_EXECUTION_RECOVERY_GRACE_MS, ACTIVE_MERGE_STATUSES, NON_TERMINAL_STEP_STATUSES2, GHOST_REVIEW_PRESERVED_STATUSES, ORPHANED_WITH_WORKTREE_GRACE_MS, MAX_TASK_DONE_RETRIES, SelfHealingManager;
 var init_self_healing = __esm({
   "../engine/src/self-healing.ts"() {
     "use strict";
@@ -75335,7 +75930,7 @@ var init_self_healing = __esm({
     init_logger2();
     init_worktree_pool();
     log16 = createLogger2("self-healing");
-    execAsync8 = promisify9(exec8);
+    execAsync7 = promisify8(exec8);
     APPROVED_TRIAGE_RECOVERY_GRACE_MS = 6e4;
     ORPHANED_EXECUTION_RECOVERY_GRACE_MS = 6e4;
     ACTIVE_MERGE_STATUSES = /* @__PURE__ */ new Set(["merging", "merging-pr"]);
@@ -75540,12 +76135,12 @@ var init_self_healing = __esm({
         if (completedSteps.length === 0) return;
         const branchName = task.branch || `fusion/${task.id.toLowerCase()}`;
         try {
-          const { stdout: mergeBaseOut } = await execAsync8(
+          const { stdout: mergeBaseOut } = await execAsync7(
             `git merge-base "${branchName}" HEAD`,
             { cwd: this.options.rootDir, encoding: "utf-8", timeout: 3e4 }
           );
           const mergeBase = mergeBaseOut.trim();
-          const { stdout: branchHeadOut } = await execAsync8(
+          const { stdout: branchHeadOut } = await execAsync7(
             `git rev-parse "${branchName}"`,
             { cwd: this.options.rootDir, encoding: "utf-8", timeout: 3e4 }
           );
@@ -75593,11 +76188,11 @@ var init_self_healing = __esm({
         const storedSha = task.mergeDetails?.commitSha;
         if (storedSha) {
           try {
-            await execAsync8(
+            await execAsync7(
               `git merge-base --is-ancestor ${shellQuote(storedSha)} HEAD`,
               { cwd: this.options.rootDir }
             );
-            const { stdout: stdout2 } = await execAsync8(
+            const { stdout: stdout2 } = await execAsync7(
               `git log -1 --format=%H%x1f%s ${shellQuote(storedSha)}`,
               { cwd: this.options.rootDir, maxBuffer: 1024 * 1024 }
             );
@@ -75605,7 +76200,7 @@ var init_self_healing = __esm({
             if (sha2) {
               const commit2 = { sha: sha2, subject: subject2 };
               try {
-                const stats = await execAsync8(`git show --shortstat --format= ${shellQuote(sha2)}`, {
+                const stats = await execAsync7(`git show --shortstat --format= ${shellQuote(sha2)}`, {
                   cwd: this.options.rootDir,
                   maxBuffer: 1024 * 1024
                 });
@@ -75626,7 +76221,7 @@ var init_self_healing = __esm({
             `--grep=${grepArg}`,
             shellQuote(range2)
           ].join(" ");
-          return execAsync8(command, {
+          return execAsync7(command, {
             cwd: this.options.rootDir,
             maxBuffer: 1024 * 1024
           });
@@ -75666,7 +76261,7 @@ var init_self_healing = __esm({
         if (!sha) return null;
         const commit = { sha, subject };
         try {
-          const stats = await execAsync8(`git show --shortstat --format= ${shellQuote(sha)}`, {
+          const stats = await execAsync7(`git show --shortstat --format= ${shellQuote(sha)}`, {
             cwd: this.options.rootDir,
             maxBuffer: 1024 * 1024
           });
@@ -75680,9 +76275,9 @@ var init_self_healing = __esm({
         return commit;
       }
       async cleanupInterruptedMergeArtifacts(task) {
-        if (task.worktree && existsSync28(task.worktree)) {
+        if (task.worktree && existsSync29(task.worktree)) {
           try {
-            await execAsync8(`git worktree remove ${shellQuote(task.worktree)} --force`, {
+            await execAsync7(`git worktree remove ${shellQuote(task.worktree)} --force`, {
               cwd: this.options.rootDir,
               timeout: 12e4
             });
@@ -75695,7 +76290,7 @@ var init_self_healing = __esm({
         }
         const branch = task.branch || `fusion/${task.id.toLowerCase()}`;
         try {
-          await execAsync8(`git branch -D ${shellQuote(branch)}`, {
+          await execAsync7(`git branch -D ${shellQuote(branch)}`, {
             cwd: this.options.rootDir,
             timeout: 12e4
           });
@@ -76290,7 +76885,7 @@ var init_self_healing = __esm({
               return false;
             }
             const staleness = now - new Date(t.updatedAt).getTime();
-            const hasWorktree = t.worktree && existsSync28(t.worktree);
+            const hasWorktree = t.worktree && existsSync29(t.worktree);
             const graceMs = hasWorktree ? ORPHANED_WITH_WORKTREE_GRACE_MS : ORPHANED_EXECUTION_RECOVERY_GRACE_MS;
             return staleness >= graceMs;
           });
@@ -76299,7 +76894,7 @@ var init_self_healing = __esm({
           let recovered = 0;
           for (const task of orphaned) {
             try {
-              const hadWorktree = task.worktree && existsSync28(task.worktree);
+              const hadWorktree = task.worktree && existsSync29(task.worktree);
               const reason = hadWorktree ? "worktree exists but no active session" : "missing worktree/session";
               await this.resetStepsIfWorkLost(task);
               await this.store.updateTask(task.id, {
@@ -76445,9 +77040,9 @@ var init_self_healing = __esm({
         }
       }
       async hasRecoverableGitWork(task) {
-        if (task.worktree && existsSync28(task.worktree)) {
+        if (task.worktree && existsSync29(task.worktree)) {
           try {
-            const { stdout: status } = await execAsync8("git status --porcelain", {
+            const { stdout: status } = await execAsync7("git status --porcelain", {
               cwd: task.worktree,
               timeout: 3e4
             });
@@ -76462,7 +77057,7 @@ var init_self_healing = __esm({
         }
         const branchName = task.branch || `fusion/${task.id.toLowerCase()}`;
         try {
-          await execAsync8(`git rev-parse --verify "${branchName}"`, {
+          await execAsync7(`git rev-parse --verify "${branchName}"`, {
             cwd: this.options.rootDir,
             timeout: 3e4
           });
@@ -76470,7 +77065,7 @@ var init_self_healing = __esm({
           return false;
         }
         try {
-          const { stdout: uniqueCommits } = await execAsync8(
+          const { stdout: uniqueCommits } = await execAsync7(
             `git rev-list --count HEAD.."${branchName}"`,
             { cwd: this.options.rootDir, timeout: 3e4 }
           );
@@ -76570,7 +77165,7 @@ var init_self_healing = __esm({
       /** Run `git worktree prune` to clean stale metadata. */
       async pruneWorktrees() {
         try {
-          await execAsync8("git worktree prune", {
+          await execAsync7("git worktree prune", {
             cwd: this.options.rootDir,
             timeout: 3e4
           });
@@ -76603,7 +77198,7 @@ var init_self_healing = __esm({
           let cleaned = 0;
           for (const worktreePath of orphaned) {
             try {
-              await execAsync8(`git worktree remove "${worktreePath}" --force`, {
+              await execAsync7(`git worktree remove "${worktreePath}" --force`, {
                 cwd: this.options.rootDir,
                 timeout: 3e4
               });
@@ -76630,11 +77225,11 @@ var init_self_healing = __esm({
        * tracks registered idle worktrees, never these orphans.
        */
       async reapUnregisteredOrphans() {
-        const worktreesDir = join36(this.options.rootDir, ".worktrees");
-        if (!existsSync28(worktreesDir)) return 0;
+        const worktreesDir = join37(this.options.rootDir, ".worktrees");
+        if (!existsSync29(worktreesDir)) return 0;
         let dirs;
         try {
-          dirs = readdirSync5(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join36(worktreesDir, e.name));
+          dirs = readdirSync5(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join37(worktreesDir, e.name));
         } catch (err) {
           log16.warn(`Failed to read .worktrees/ for unregistered orphan reap: ${err instanceof Error ? err.message : String(err)}`);
           return 0;
@@ -76645,7 +77240,7 @@ var init_self_healing = __esm({
         let cleaned = 0;
         for (const path5 of unregistered) {
           const rel = relative8(worktreesDir, path5);
-          if (rel === "" || rel.startsWith("..") || isAbsolute12(rel)) {
+          if (rel === "" || rel.startsWith("..") || isAbsolute13(rel)) {
             log16.warn(`Refusing to remove path outside .worktrees: ${path5}`);
             continue;
           }
@@ -76683,7 +77278,7 @@ var init_self_healing = __esm({
           const deletedBranches = [];
           for (const branch of orphaned) {
             try {
-              await execAsync8(`git branch -d "${branch}"`, {
+              await execAsync7(`git branch -d "${branch}"`, {
                 cwd: this.options.rootDir,
                 timeout: 3e4
               });
@@ -76696,7 +77291,7 @@ var init_self_healing = __esm({
                 `Safe delete failed for orphaned branch ${branch}: ${errorMessage} \u2014 attempting force delete`
               );
               try {
-                await execAsync8(`git branch -D "${branch}"`, {
+                await execAsync7(`git branch -D "${branch}"`, {
                   cwd: this.options.rootDir,
                   timeout: 3e4
                 });
@@ -76739,8 +77334,8 @@ var init_self_healing = __esm({
       }
       /** Remove oldest idle worktrees if total count exceeds 2× maxWorktrees. */
       async enforceWorktreeCap() {
-        const worktreesDir = join36(this.options.rootDir, ".worktrees");
-        if (!existsSync28(worktreesDir)) return;
+        const worktreesDir = join37(this.options.rootDir, ".worktrees");
+        if (!existsSync29(worktreesDir)) return;
         try {
           const settings = await this.store.getSettings();
           const cap = (settings.maxWorktrees ?? 4) * 2;
@@ -76764,7 +77359,7 @@ var init_self_healing = __esm({
           for (const { path: worktreePath } of withMtime) {
             if (removed >= excess) break;
             try {
-              await execAsync8(`git worktree remove "${worktreePath}" --force`, {
+              await execAsync7(`git worktree remove "${worktreePath}" --force`, {
                 cwd: this.options.rootDir,
                 timeout: 3e4
               });
@@ -76787,7 +77382,7 @@ var init_self_healing = __esm({
 });
 
 // ../engine/src/plugin-runner.ts
-import { Type as Type6 } from "@mariozechner/pi-ai";
+import { Type as Type7 } from "@mariozechner/pi-ai";
 var DEFAULT_HOOK_TIMEOUT_MS, PluginRunner;
 var init_plugin_runner = __esm({
   "../engine/src/plugin-runner.ts"() {
@@ -77102,7 +77697,7 @@ var init_plugin_runner = __esm({
               };
             }
           };
-          const anySchema = Type6.Any();
+          const anySchema = Type7.Any();
           return {
             name: `plugin_${pluginTool.name}`,
             label: pluginTool.name,
@@ -78401,7 +78996,7 @@ var init_ipc_host = __esm({
 import { EventEmitter as EventEmitter21 } from "node:events";
 import { fork } from "node:child_process";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { dirname as dirname10, join as join37 } from "node:path";
+import { dirname as dirname10, join as join38 } from "node:path";
 var HealthMonitor, ChildProcessRuntime;
 var init_child_process_runtime = __esm({
   "../engine/src/runtimes/child-process-runtime.ts"() {
@@ -78563,7 +79158,7 @@ var init_child_process_runtime = __esm({
         const isCompiled = !import.meta.url.endsWith(".ts");
         const currentDir = dirname10(fileURLToPath3(import.meta.url));
         const workerFile = isCompiled ? "child-process-worker.js" : "child-process-worker.ts";
-        return join37(currentDir, workerFile);
+        return join38(currentDir, workerFile);
       }
       /**
        * Set up event forwarding from IPC host to runtime listeners.
@@ -80034,7 +80629,8 @@ var init_provider_adapters = __esm({
 
 // ../engine/src/remote-access/tunnel-process-manager.ts
 import { EventEmitter as EventEmitter24 } from "node:events";
-import { spawn as spawn3 } from "node:child_process";
+import { exec as exec9, execFile as execFile3, spawn as spawn4 } from "node:child_process";
+import { promisify as promisify9 } from "node:util";
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -80074,7 +80670,7 @@ function toStateError(code, err) {
     at: nowIso()
   };
 }
-var DEFAULT_MAX_LOG_ENTRIES, DEFAULT_STOP_TIMEOUT_MS2, LineBuffer, TunnelProcessManager;
+var DEFAULT_MAX_LOG_ENTRIES, DEFAULT_STOP_TIMEOUT_MS2, execFileAsync, execAsync8, LineBuffer, TunnelProcessManager;
 var init_tunnel_process_manager = __esm({
   "../engine/src/remote-access/tunnel-process-manager.ts"() {
     "use strict";
@@ -80082,6 +80678,8 @@ var init_tunnel_process_manager = __esm({
     init_provider_adapters();
     DEFAULT_MAX_LOG_ENTRIES = 400;
     DEFAULT_STOP_TIMEOUT_MS2 = 5e3;
+    execFileAsync = promisify9(execFile3);
+    execAsync8 = promisify9(exec9);
     LineBuffer = class {
       pending = "";
       push(chunk) {
@@ -80122,7 +80720,7 @@ var init_tunnel_process_manager = __esm({
         super();
         this.maxLogEntries = options.maxLogEntries ?? DEFAULT_MAX_LOG_ENTRIES;
         this.defaultStopTimeoutMs = options.stopTimeoutMs ?? DEFAULT_STOP_TIMEOUT_MS2;
-        this.spawnImpl = options.spawnImpl ?? spawn3;
+        this.spawnImpl = options.spawnImpl ?? spawn4;
       }
       getStatus() {
         return { ...this.status, lastError: this.status.lastError ? { ...this.status.lastError } : null };
@@ -80153,6 +80751,51 @@ var init_tunnel_process_manager = __esm({
           await this.stopInternal();
         });
       }
+      async detectExternalFunnel() {
+        if (this.processHandle || this.status.state === "starting" || this.status.state === "running") {
+          return null;
+        }
+        try {
+          const { stdout } = await execFileAsync("tailscale", ["status", "--json"], { timeout: 3e3 });
+          const data = JSON.parse(String(stdout));
+          const dnsName = data.Self?.DNSName?.replace(/\.$/, "");
+          if (!dnsName) {
+            return null;
+          }
+          return {
+            provider: "tailscale",
+            url: `https://${dnsName}/`,
+            pid: null
+          };
+        } catch {
+          return null;
+        }
+      }
+      async killExternalFunnel() {
+        const resetCommands = [
+          { command: "tailscale", args: ["serve", "reset"] },
+          { command: "tailscale", args: ["funnel", "reset"] },
+          { command: "tailscale", args: ["funnel", "off"] }
+        ];
+        for (const resetCommand of resetCommands) {
+          try {
+            await execFileAsync(resetCommand.command, resetCommand.args, { timeout: 5e3 });
+            return;
+          } catch {
+          }
+        }
+        try {
+          const { stdout } = await execAsync8('pgrep -f "tailscale funnel"', { timeout: 5e3 });
+          const pids = stdout.split(/\s+/).map((value) => Number(value.trim())).filter((value) => Number.isInteger(value) && value > 0);
+          await Promise.all(pids.map(async (pid) => {
+            try {
+              process.kill(pid, "SIGTERM");
+            } catch {
+            }
+          }));
+        } catch {
+        }
+      }
       async switchProvider(target, config) {
         return this.runExclusive(async () => {
           const previousProvider = this.status.provider;
@@ -80435,7 +81078,7 @@ var init_tunnel_process_manager = __esm({
 });
 
 // ../engine/src/project-engine.ts
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify10 } from "node:util";
 function formatErrorDetails(error) {
   if (error instanceof Error) {
@@ -80447,7 +81090,7 @@ function formatErrorDetails(error) {
   const detail = String(error);
   return { message: detail, detail };
 }
-var execFileAsync, MERGE_HANDOFF_GRACE_MS, isRemoteActive, ProjectEngine;
+var execFileAsync2, MERGE_HANDOFF_GRACE_MS, isRemoteActive, ProjectEngine;
 var init_project_engine = __esm({
   "../engine/src/project-engine.ts"() {
     "use strict";
@@ -80464,7 +81107,7 @@ var init_project_engine = __esm({
     init_research_orchestrator();
     init_research_step_runner();
     init_tunnel_process_manager();
-    execFileAsync = promisify10(execFile3);
+    execFileAsync2 = promisify10(execFile4);
     MERGE_HANDOFF_GRACE_MS = 300;
     isRemoteActive = (ra) => ra?.activeProvider != null && (ra.providers[ra.activeProvider]?.enabled ?? false);
     ProjectEngine = class _ProjectEngine {
@@ -80868,6 +81511,30 @@ ${detail}`
         }
         return manager.getStatus();
       }
+      async detectExternalTunnel() {
+        const manager = this.remoteTunnelManager;
+        if (!manager) {
+          return null;
+        }
+        const settings = await this.runtime.getTaskStore().getSettings();
+        const provider = settings.remoteAccess?.activeProvider ?? null;
+        if (provider !== "tailscale") {
+          return null;
+        }
+        return manager.detectExternalFunnel();
+      }
+      async killExternalTunnel() {
+        const manager = this.remoteTunnelManager;
+        if (!manager) {
+          return;
+        }
+        const settings = await this.runtime.getTaskStore().getSettings();
+        const provider = settings.remoteAccess?.activeProvider ?? null;
+        if (provider !== "tailscale") {
+          return;
+        }
+        await manager.killExternalFunnel();
+      }
       /** Get the RoutineRunner (if initialized). */
       getRoutineRunner() {
         return this.runtime.getRoutineRunner();
@@ -81077,7 +81744,7 @@ ${detail}`
       async checkExecutableAvailable(command) {
         const checker = process.platform === "win32" ? "where" : "which";
         try {
-          await execFileAsync(checker, [command]);
+          await execFileAsync2(checker, [command]);
           return { available: true };
         } catch {
           return {
@@ -84723,6 +85390,7 @@ __export(mission_interview_exports, {
   RateLimitError: () => RateLimitError3,
   SessionNotFoundError: () => SessionNotFoundError3,
   __getMissionInterviewDiagnostics: () => __getMissionInterviewDiagnostics,
+  __registerMissionInterviewSessionForTest: () => __registerMissionInterviewSessionForTest,
   __resetMissionInterviewState: () => __resetMissionInterviewState,
   __setMissionInterviewDiagnostics: () => __setMissionInterviewDiagnostics,
   cancelMissionInterviewSession: () => cancelMissionInterviewSession,
@@ -85483,6 +86151,19 @@ function cleanupMissionInterviewSession(sessionId) {
   cleanupInMemoryMissionSession(sessionId);
   unpersistMissionSession(sessionId);
 }
+function __registerMissionInterviewSessionForTest(sessionId, missionTitle = "Test Mission") {
+  sessions3.set(sessionId, {
+    id: sessionId,
+    ip: "127.0.0.1",
+    missionId: "",
+    missionTitle,
+    history: [],
+    thinkingOutput: "",
+    lastGeneratedThinking: "",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date()
+  });
+}
 function __resetMissionInterviewState() {
   for (const [id] of sessions3) {
     cleanupInMemoryMissionSession(id);
@@ -86746,7 +87427,7 @@ var init_api_error = __esm({
 // ../dashboard/src/plugin-routes.ts
 import { Router } from "express";
 import { access as access5, stat as stat6, readFile as readFile17 } from "node:fs/promises";
-import { join as join38, isAbsolute as isAbsolute13, dirname as dirname11, basename as basename9 } from "node:path";
+import { join as join39, isAbsolute as isAbsolute14, dirname as dirname11, basename as basename9 } from "node:path";
 async function resolvePluginManifest(sourcePath) {
   try {
     await access5(sourcePath);
@@ -86762,7 +87443,7 @@ async function resolvePluginManifest(sourcePath) {
   if (!sourceStat.isDirectory()) {
     throw badRequest(`Path is not a directory: ${sourcePath}`);
   }
-  const directManifestPath = join38(sourcePath, "manifest.json");
+  const directManifestPath = join39(sourcePath, "manifest.json");
   try {
     await access5(directManifestPath);
     const manifest = await readAndValidateManifest(directManifestPath);
@@ -86773,7 +87454,7 @@ async function resolvePluginManifest(sourcePath) {
   const dirName = basename9(sourcePath).toLowerCase();
   if (DIST_DIR_NAMES.has(dirName)) {
     const parentDir = dirname11(sourcePath);
-    const parentManifestPath = join38(parentDir, "manifest.json");
+    const parentManifestPath = join39(parentDir, "manifest.json");
     try {
       await access5(parentManifestPath);
       const manifest = await readAndValidateManifest(parentManifestPath);
@@ -86827,7 +87508,7 @@ var init_src3 = __esm({
 });
 
 // ../../plugins/fusion-plugin-hermes-runtime/dist/cli-spawn.js
-import { spawn as spawn4, spawnSync } from "node:child_process";
+import { spawn as spawn5, spawnSync } from "node:child_process";
 import os2 from "node:os";
 import path, { sep as PATH_SEP } from "node:path";
 function resolveBinaryForSpawn(binary) {
@@ -86891,7 +87572,7 @@ async function listHermesProfiles(opts) {
   const timeoutMs = opts?.timeoutMs ?? 5e3;
   return new Promise((resolve39, reject2) => {
     let settled = false;
-    const child = spawn4(binary, ["profile", "list"], {
+    const child = spawn5(binary, ["profile", "list"], {
       stdio: ["ignore", "pipe", "pipe"],
       env: { ...process.env }
     });
@@ -87015,7 +87696,7 @@ async function invokeHermesCli(prompt, settings, resumeSessionId, signal) {
     if (settings.profile) {
       spawnEnv.HERMES_HOME = hermesProfileHome(settings.profile);
     }
-    const child = spawn4(binary, args, {
+    const child = spawn5(binary, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: spawnEnv
     });
@@ -87170,7 +87851,7 @@ var init_runtime_adapter = __esm({
 });
 
 // ../../plugins/fusion-plugin-hermes-runtime/dist/probe.js
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 async function probeHermesBinary(opts) {
   const startedAt = Date.now();
   const binary = typeof opts?.binaryPath === "string" && opts.binaryPath.trim().length > 0 ? opts.binaryPath.trim() : "hermes";
@@ -87181,7 +87862,7 @@ async function probeHermesBinary(opts) {
       resolvePromise({ ...result, probeDurationMs: Date.now() - startedAt });
     };
     let settled = false;
-    const child = spawn5(resolvedPath ?? binary, ["--version"], {
+    const child = spawn6(resolvedPath ?? binary, ["--version"], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const timer = setTimeout(() => {
@@ -87242,7 +87923,7 @@ async function probeHermesBinary(opts) {
 async function tryResolveBinaryPath(binary) {
   return new Promise((resolvePromise) => {
     const which = process.platform === "win32" ? "where" : "which";
-    const child = spawn5(which, [binary], { stdio: ["ignore", "pipe", "ignore"] });
+    const child = spawn6(which, [binary], { stdio: ["ignore", "pipe", "ignore"] });
     let out = "";
     child.stdout?.on("data", (chunk) => {
       out += chunk.toString("utf-8");
@@ -87320,7 +88001,7 @@ var init_dist = __esm({
 });
 
 // ../../plugins/fusion-plugin-openclaw-runtime/dist/pi-module.js
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { randomUUID as randomUUID15 } from "node:crypto";
 function asString(v) {
   return typeof v === "string" && v.trim() !== "" ? v.trim() : void 0;
@@ -87397,7 +88078,7 @@ async function promptCli(session, message, config, callbacks, signal) {
   cb.onToolStart?.("openclaw.agent", { sessionId: session.sessionId });
   return new Promise((resolve39, reject2) => {
     let settled = false;
-    const child = spawn6(config.binaryPath, args, {
+    const child = spawn7(config.binaryPath, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const hardKill = setTimeout(() => {
@@ -87548,7 +88229,7 @@ var init_runtime_adapter2 = __esm({
 });
 
 // ../../plugins/fusion-plugin-openclaw-runtime/dist/probe.js
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 async function probeOpenClawBinary(opts = {}) {
   const startedAt = Date.now();
   const binary = opts.binaryPath ?? "openclaw";
@@ -87559,7 +88240,7 @@ async function probeOpenClawBinary(opts = {}) {
       resolvePromise({ ...partial, probeDurationMs: Date.now() - startedAt });
     };
     let settled = false;
-    const child = spawn7(resolvedPath ?? binary, ["--version"], {
+    const child = spawn8(resolvedPath ?? binary, ["--version"], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const timer = setTimeout(() => {
@@ -87620,7 +88301,7 @@ async function probeOpenClawBinary(opts = {}) {
 async function tryResolveBinaryPath2(binary) {
   return new Promise((resolvePromise) => {
     const which = process.platform === "win32" ? "where" : "which";
-    const child = spawn7(which, [binary], { stdio: ["ignore", "pipe", "ignore"] });
+    const child = spawn8(which, [binary], { stdio: ["ignore", "pipe", "ignore"] });
     let out = "";
     child.stdout?.on("data", (chunk) => {
       out += chunk.toString("utf-8");
@@ -88234,8 +88915,8 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       });
       if (retrySpecification) {
         const { rm: rm6 } = await import("node:fs/promises");
-        const { join: join68 } = await import("node:path");
-        const promptPath = join68(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+        const { join: join69 } = await import("node:path");
+        const promptPath = join69(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
         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);
@@ -88275,6 +88956,49 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       rethrowAsApiError8(err);
     }
   });
+  router.post("/tasks/:id/reset", async (req, res) => {
+    try {
+      const { store: scopedStore } = await getProjectContext3(req);
+      const { confirm: confirmed } = req.body ?? {};
+      if (!confirmed) {
+        throw badRequest(
+          'This operation is destructive and will erase all task progress. Pass { "confirm": true } in the request body to proceed.'
+        );
+      }
+      const task = await scopedStore.getTask(req.params.id);
+      for (let i = 0; i < task.steps.length; i++) {
+        if (task.steps[i].status !== "pending") {
+          await scopedStore.updateStep(req.params.id, i, "pending");
+        }
+      }
+      await scopedStore.updateTask(req.params.id, {
+        worktree: null,
+        branch: null,
+        currentStep: 0,
+        status: null,
+        error: null,
+        stuckKillCount: 0,
+        taskDoneRetryCount: null,
+        workflowStepRetries: void 0,
+        recoveryRetryCount: null,
+        nextRecoveryAt: null,
+        postReviewFixCount: 0,
+        verificationFailureCount: 0,
+        mergeConflictBounceCount: 0
+      });
+      await scopedStore.logEntry(
+        req.params.id,
+        "Task reset by user \u2014 all progress cleared, fresh worktree and branch will be allocated"
+      );
+      const updated = await scopedStore.moveTask(req.params.id, "todo");
+      res.json(updated);
+    } catch (err) {
+      if (err instanceof ApiError) {
+        throw err;
+      }
+      rethrowAsApiError8(err);
+    }
+  });
   router.post("/tasks/:id/duplicate", async (req, res) => {
     try {
       const { store: scopedStore } = await getProjectContext3(req);
@@ -88657,8 +89381,8 @@ 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: rm6 } = await import("node:fs/promises");
-      const { join: join68 } = await import("node:path");
-      const promptPath = join68(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+      const { join: join69 } = await import("node:path");
+      const promptPath = join69(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
       await rm6(promptPath, { force: true });
       const updated = await scopedStore.getTask(task.id);
       res.json(updated);
@@ -88928,8 +89652,8 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       if (task.column === "triage") {
         await scopedStore.logEntry(task.id, "AI spec revision requested", feedback);
         const { rm: rm7 } = await import("node:fs/promises");
-        const { join: join69 } = await import("node:path");
-        const promptPath2 = join69(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+        const { join: join70 } = await import("node:path");
+        const promptPath2 = join70(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
         await rm7(promptPath2, { force: true });
         await scopedStore.updateTask(task.id, { status: "needs-replan" });
         const updated2 = await scopedStore.getTask(task.id);
@@ -88945,8 +89669,8 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       await scopedStore.logEntry(task.id, "AI spec revision requested", feedback);
       const updated = await scopedStore.moveTask(task.id, "triage");
       const { rm: rm6 } = await import("node:fs/promises");
-      const { join: join68 } = await import("node:path");
-      const promptPath = join68(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+      const { join: join69 } = await import("node:path");
+      const promptPath = join69(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
       await rm6(promptPath, { force: true });
       await scopedStore.updateTask(task.id, { status: "needs-replan" });
       res.json(updated);
@@ -88966,8 +89690,8 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       if (task.column === "triage") {
         await scopedStore.logEntry(task.id, "Specification rebuild requested by user");
         const { rm: rm7 } = await import("node:fs/promises");
-        const { join: join69 } = await import("node:path");
-        const promptPath2 = join69(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+        const { join: join70 } = await import("node:path");
+        const promptPath2 = join70(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
         await rm7(promptPath2, { force: true });
         await scopedStore.updateTask(task.id, { status: "needs-replan" });
         const updated2 = await scopedStore.getTask(task.id);
@@ -88981,8 +89705,8 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       await scopedStore.logEntry(task.id, "Specification rebuild requested by user");
       const updated = await scopedStore.moveTask(task.id, "triage");
       const { rm: rm6 } = await import("node:fs/promises");
-      const { join: join68 } = await import("node:path");
-      const promptPath = join68(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+      const { join: join69 } = await import("node:path");
+      const promptPath = join69(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
       await rm6(promptPath, { force: true });
       await scopedStore.updateTask(task.id, { status: "needs-replan" });
       res.json(updated);
@@ -90247,7 +90971,7 @@ __export(chat_exports, {
   resolveFileReferences: () => resolveFileReferences
 });
 import { EventEmitter as EventEmitter29 } from "node:events";
-import { join as join39, resolve as resolve18, relative as relative9 } from "node:path";
+import { join as join40, resolve as resolve18, relative as relative9 } from "node:path";
 function __getChatDiagnostics() {
   return _diagnostics;
 }
@@ -90280,7 +91004,7 @@ function validateFilePath(basePath, filePath) {
     throw new Error(`Access denied: Absolute paths not allowed`);
   }
   const resolvedBase = resolve18(basePath);
-  const resolvedPath = resolve18(join39(resolvedBase, decodedPath));
+  const resolvedPath = resolve18(join40(resolvedBase, decodedPath));
   const relativePath = relative9(resolvedBase, resolvedPath);
   if (relativePath.startsWith("..") || relativePath.startsWith("../") || relativePath === "..") {
     throw new Error(`Access denied: Path traversal detected`);
@@ -90861,7 +91585,7 @@ ${mentionContext}`;
 import { randomUUID as randomUUID16 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
 import { mkdir as mkdir13, rm as rm2, writeFile as writeFile13 } from "node:fs/promises";
-import { basename as basename10, join as join40, resolve as resolve19 } from "node:path";
+import { basename as basename10, join as join41, resolve as resolve19 } from "node:path";
 function resolveAttachmentPath(rootDir, sessionId, filename) {
   const sessionDir = resolve19(rootDir, ".fusion", "chat-attachments", sessionId);
   const safeName = basename10(filename);
@@ -91114,7 +91838,7 @@ function registerChatRoutes(ctx, deps) {
       await mkdir13(sessionDir, { recursive: true });
       const sanitizedFilename = (file.originalname || "attachment").replace(/[^a-zA-Z0-9._-]/g, "_");
       const filename = `${Date.now()}-${sanitizedFilename}`;
-      const filePath = join40(sessionDir, filename);
+      const filePath = join41(sessionDir, filename);
       await writeFile13(filePath, file.buffer);
       const attachment = {
         id: `att-${randomUUID16().slice(0, 8)}`,
@@ -96035,15 +96759,16 @@ var init_remote_auth = __esm({
 });
 
 // ../dashboard/src/routes/register-settings-memory-routes.ts
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
+import { homedir as homedir6 } from "node:os";
 import { promisify as promisify11 } from "node:util";
 function registerSettingsMemoryRoutes(ctx, deps) {
   const { router, options, store, runtimeLogger, getProjectContext: getProjectContext3, rethrowAsApiError: rethrowAsApiError8 } = ctx;
   const { githubToken, validateModelPresets: validateModelPresets2, sanitizeOverlapIgnorePaths: sanitizeOverlapIgnorePaths2, discoverDashboardPiExtensions: discoverDashboardPiExtensions2 } = deps;
-  const execFileAsync6 = promisify11(execFile4);
+  const execFileAsync7 = promisify11(execFile5);
   async function queryTailscaleFunnelUrl(targetPort) {
     try {
-      const { stdout } = await execFileAsync6("tailscale", ["status", "--json"], { timeout: 3e3 });
+      const { stdout } = await execFileAsync7("tailscale", ["status", "--json"], { timeout: 3e3 });
       const data = JSON.parse(stdout);
       const dnsName = data.Self?.DNSName?.replace(/\.$/, "");
       if (!dnsName) return null;
@@ -96056,12 +96781,38 @@ function registerSettingsMemoryRoutes(ctx, deps) {
   async function isCloudflaredAvailable() {
     const command = process.platform === "win32" ? "where" : "which";
     try {
-      await execFileAsync6(command, ["cloudflared"]);
+      await execFileAsync7(command, ["cloudflared"]);
       return true;
     } catch {
       return false;
     }
   }
+  function resolveCloudflaredBinaryName() {
+    if (process.platform === "linux") {
+      if (process.arch === "arm") {
+        return "cloudflared-linux-armhf";
+      }
+      if (process.arch === "arm64") {
+        return "cloudflared-linux-arm64";
+      }
+      if (process.arch === "x64") {
+        return "cloudflared-linux-amd64";
+      }
+      console.warn(`[remote-access] Unsupported Linux architecture '${process.arch}' for cloudflared; falling back to amd64`);
+      return "cloudflared-linux-amd64";
+    }
+    if (process.platform === "darwin") {
+      if (process.arch === "arm64") {
+        return "cloudflared-darwin-arm64";
+      }
+      if (process.arch === "x64") {
+        return "cloudflared-darwin-amd64";
+      }
+      console.warn(`[remote-access] Unsupported macOS architecture '${process.arch}' for cloudflared; falling back to amd64`);
+      return "cloudflared-darwin-amd64";
+    }
+    return "cloudflared-linux-amd64";
+  }
   function resolveCloudflaredInstallCommand() {
     if (process.platform === "darwin") {
       return "brew install cloudflared";
@@ -96069,21 +96820,77 @@ function registerSettingsMemoryRoutes(ctx, deps) {
     if (process.platform === "win32") {
       return "winget install Cloudflare.cloudflared";
     }
-    return "curl -L --output /usr/local/bin/cloudflared https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64 && chmod +x /usr/local/bin/cloudflared";
+    const binaryName = resolveCloudflaredBinaryName();
+    const downloadUrl = `https://github.com/cloudflare/cloudflared/releases/latest/download/${binaryName}`;
+    return `curl -L --output /tmp/cloudflared ${downloadUrl} && chmod +x /tmp/cloudflared && mv /tmp/cloudflared /usr/local/bin/cloudflared`;
+  }
+  function formatExecError(error) {
+    if (!(error instanceof Error)) {
+      return String(error);
+    }
+    const stdout = error.stdout?.trim();
+    const stderr = error.stderr?.trim();
+    return [error.message, stderr, stdout].filter(Boolean).join(" | ");
   }
   async function installCloudflared() {
-    const command = resolveCloudflaredInstallCommand();
-    const shell = process.platform === "win32" ? "cmd" : "sh";
-    const shellArgs = process.platform === "win32" ? ["/c", command] : ["-c", command];
+    if (process.platform === "win32") {
+      const command = resolveCloudflaredInstallCommand();
+      try {
+        await execFileAsync7("winget", ["install", "Cloudflare.cloudflared"], { timeout: 12e4 });
+        return { success: true, command };
+      } catch (error) {
+        return { success: false, command, error: formatExecError(error) };
+      }
+    }
+    const attemptedCommands = [];
+    const downloadBinaryName = process.platform === "darwin" || process.platform === "linux" ? resolveCloudflaredBinaryName() : "cloudflared-linux-amd64";
+    const downloadUrl = `https://github.com/cloudflare/cloudflared/releases/latest/download/${downloadBinaryName}`;
+    const tempPath = "/tmp/cloudflared";
+    const installFromDirectDownload = async () => {
+      attemptedCommands.push(`curl -L --output ${tempPath} ${downloadUrl}`);
+      await execFileAsync7("curl", ["-L", "--output", tempPath, downloadUrl], { timeout: 12e4 });
+      attemptedCommands.push(`chmod +x ${tempPath}`);
+      await execFileAsync7("chmod", ["+x", tempPath], { timeout: 3e4 });
+      const globalInstallPath = "/usr/local/bin/cloudflared";
+      attemptedCommands.push(`mv ${tempPath} ${globalInstallPath}`);
+      try {
+        await execFileAsync7("mv", [tempPath, globalInstallPath], { timeout: 3e4 });
+      } catch (error) {
+        const localBinDir = `${homedir6()}/.local/bin`;
+        const localInstallPath = `${localBinDir}/cloudflared`;
+        attemptedCommands.push(`mkdir -p ${localBinDir}`);
+        attemptedCommands.push(`mv ${tempPath} ${localInstallPath}`);
+        await execFileAsync7("mkdir", ["-p", localBinDir], { timeout: 3e4 });
+        try {
+          await execFileAsync7("mv", [tempPath, localInstallPath], { timeout: 3e4 });
+        } catch (fallbackError) {
+          throw new Error(
+            `Failed to install cloudflared to /usr/local/bin and ~/.local/bin (${formatExecError(error)}; fallback: ${formatExecError(fallbackError)})`
+          );
+        }
+      }
+    };
+    if (process.platform === "darwin") {
+      attemptedCommands.push("which brew");
+      try {
+        await execFileAsync7("which", ["brew"], { timeout: 15e3 });
+        attemptedCommands.push("brew install cloudflared");
+        await execFileAsync7("brew", ["install", "cloudflared"], { timeout: 12e4 });
+        return { success: true, command: attemptedCommands.join(" && ") };
+      } catch {
+        try {
+          await installFromDirectDownload();
+          return { success: true, command: attemptedCommands.join(" && ") };
+        } catch (error) {
+          return { success: false, command: attemptedCommands.join(" && "), error: formatExecError(error) };
+        }
+      }
+    }
     try {
-      await execFileAsync6(shell, shellArgs, { timeout: 12e4 });
-      return { success: true, command };
+      await installFromDirectDownload();
+      return { success: true, command: attemptedCommands.join(" && ") };
     } catch (error) {
-      return {
-        success: false,
-        command,
-        error: error instanceof Error ? error.message : String(error)
-      };
+      return { success: false, command: attemptedCommands.join(" && "), error: formatExecError(error) };
     }
   }
   async function resolveRemoteBaseUrl(remoteAccess, tunnelUrl) {
@@ -96370,17 +97177,23 @@ function registerSettingsMemoryRoutes(ctx, deps) {
       const tunnelStatus = manager?.getStatus();
       const restore = engine?.getRemoteTunnelRestoreDiagnostics();
       const activeProvider = tunnelStatus?.provider ?? settings.remoteAccess?.activeProvider ?? null;
+      const tunnelState = tunnelStatus?.state ?? "stopped";
       let cloudflaredAvailable = null;
       if (activeProvider === "cloudflare") {
         cloudflaredAvailable = await isCloudflaredAvailable();
       }
+      const externalTunnel = tunnelState === "stopped" ? await engine?.detectExternalTunnel() : null;
       res.json({
         provider: activeProvider,
-        state: tunnelStatus?.state ?? "stopped",
+        state: tunnelState,
         url: tunnelStatus?.url ?? null,
         lastError: tunnelStatus?.lastError?.message ?? null,
         lastErrorCode: tunnelStatus?.lastError?.code ?? null,
         cloudflaredAvailable,
+        externalTunnel: externalTunnel ? {
+          provider: externalTunnel.provider,
+          url: externalTunnel.url
+        } : null,
         restore: restore ?? {
           outcome: "skipped",
           reason: "not_attempted",
@@ -96493,6 +97306,18 @@ function registerSettingsMemoryRoutes(ctx, deps) {
       rethrowAsApiError8(err, "Failed to stop remote tunnel");
     }
   });
+  router.post("/remote/tunnel/kill-external", async (req, res) => {
+    try {
+      const { engine } = await getProjectContext3(req);
+      if (engine) {
+        await engine.killExternalTunnel();
+      }
+      res.json({ ok: true });
+    } catch (err) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError8(err, "Failed to kill external remote tunnel");
+    }
+  });
   router.post("/remote/token/persistent/regenerate", async (req, res) => {
     try {
       const { store: scopedStore } = await getProjectContext3(req);
@@ -97381,7 +98206,7 @@ import * as os3 from "os";
 import * as path2 from "path";
 import * as fs2 from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { join as join41, dirname as dirname12 } from "node:path";
+import { join as join42, dirname as dirname12 } 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";
@@ -97391,12 +98216,12 @@ function findInstalledNodePtyNativeDir() {
   try {
     const packageJsonPath = require2.resolve("node-pty/package.json");
     const pkgRoot = dirname12(packageJsonPath);
-    const releaseDir = join41(pkgRoot, "build", "Release");
-    if (fs2.existsSync(join41(releaseDir, "pty.node"))) {
+    const releaseDir = join42(pkgRoot, "build", "Release");
+    if (fs2.existsSync(join42(releaseDir, "pty.node"))) {
       return releaseDir;
     }
-    const prebuildDir = join41(pkgRoot, "prebuilds", getNativePrebuildName());
-    if (fs2.existsSync(join41(prebuildDir, "pty.node"))) {
+    const prebuildDir = join42(pkgRoot, "prebuilds", getNativePrebuildName());
+    if (fs2.existsSync(join42(prebuildDir, "pty.node"))) {
       return prebuildDir;
     }
     return null;
@@ -97422,8 +98247,8 @@ function ensureNodePtyNativePermissions() {
     candidateDirs.add(installedNativeDir);
   }
   for (const nativeDir of candidateDirs) {
-    const helperPath = join41(nativeDir, "spawn-helper");
-    const nativeModulePath = join41(nativeDir, "pty.node");
+    const helperPath = join42(nativeDir, "spawn-helper");
+    const nativeModulePath = join42(nativeDir, "pty.node");
     try {
       fs2.chmodSync(helperPath, 493);
     } catch {
@@ -97441,14 +98266,14 @@ function ensureNodePtyNativePermissions() {
 function findStagedNativeDir() {
   const prebuildName = getNativePrebuildName();
   if (process.env.FUSION_RUNTIME_DIR) {
-    const envPath = join41(process.env.FUSION_RUNTIME_DIR, prebuildName);
-    if (fs2.existsSync(join41(envPath, "pty.node"))) {
+    const envPath = join42(process.env.FUSION_RUNTIME_DIR, prebuildName);
+    if (fs2.existsSync(join42(envPath, "pty.node"))) {
       return envPath;
     }
   }
   const execDir = dirname12(process.execPath);
-  const nextToBinary = join41(execDir, "runtime", prebuildName);
-  if (fs2.existsSync(join41(nextToBinary, "pty.node"))) {
+  const nextToBinary = join42(execDir, "runtime", prebuildName);
+  if (fs2.existsSync(join42(nextToBinary, "pty.node"))) {
     return nextToBinary;
   }
   return null;
@@ -97468,7 +98293,7 @@ async function loadPtyModule() {
         process.env.NODE_PTY_SPAWN_HELPER_DIR = nativeDir;
       }
       process.env.FUSION_NATIVE_ASSETS_PATH = nativeDir;
-      const nativePath = join41(nativeDir, "pty.node");
+      const nativePath = join42(nativeDir, "pty.node");
       if (fs2.existsSync(nativePath)) {
         try {
           const nativeModule = { exports: {} };
@@ -100353,10 +101178,10 @@ var init_github_poll = __esm({
 });
 
 // ../dashboard/src/routes/resolve-diff-base.ts
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify12 } from "node:util";
 async function runGitCommand(args, cwd, timeout2 = 1e4) {
-  const result = await execFileAsync2("git", args, {
+  const result = await execFileAsync3("git", args, {
     cwd,
     timeout: timeout2,
     maxBuffer: 10 * 1024 * 1024,
@@ -100430,16 +101255,16 @@ async function resolveDiffBase(task, cwd, headRef = "HEAD", runGit = runGitComma
     return void 0;
   }
 }
-var execFileAsync2;
+var execFileAsync3;
 var init_resolve_diff_base = __esm({
   "../dashboard/src/routes/resolve-diff-base.ts"() {
     "use strict";
-    execFileAsync2 = promisify12(execFile5);
+    execFileAsync3 = promisify12(execFile6);
   }
 });
 
 // ../dashboard/src/routes/register-git-github.ts
-import { isAbsolute as isAbsolute15 } from "node:path";
+import { isAbsolute as isAbsolute16 } from "node:path";
 function getCommandErrorMessage2(error) {
   if (error instanceof Error) {
     const anyError = error;
@@ -101040,7 +101865,7 @@ async function getGitWorkingDiff(cwd) {
 function isValidGitFilePath(filePath) {
   if (!filePath || !filePath.trim()) return false;
   if (filePath.startsWith("-")) return false;
-  if (isAbsolute15(filePath)) return false;
+  if (isAbsolute16(filePath)) return false;
   if (filePath.includes("\0")) return false;
   if (filePath.includes("..")) return false;
   if (/[;&|`$(){}[\]\r\n]/.test(filePath)) return false;
@@ -102840,7 +103665,7 @@ var init_register_git_github = __esm({
 });
 
 // ../dashboard/src/terminal.ts
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 import { randomUUID as randomUUID17 } from "node:crypto";
 import { EventEmitter as EventEmitter32 } from "node:events";
 function extractBaseCommand(command) {
@@ -103002,7 +103827,7 @@ var init_terminal = __esm({
           return { sessionId: "", error: validation.error };
         }
         const sessionId = randomUUID17();
-        const childProcess = spawn8(command, [], {
+        const childProcess = spawn9(command, [], {
           cwd,
           shell: true,
           stdio: ["pipe", "pipe", "pipe"],
@@ -103126,7 +103951,7 @@ var init_terminal = __esm({
 });
 
 // ../dashboard/src/file-service.ts
-import { join as join42, resolve as resolve21, relative as relative11, dirname as dirname13, basename as basename12 } from "node:path";
+import { join as join43, resolve as resolve21, relative as relative11, dirname as dirname13, basename as basename12 } 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 mkdir14, access as access6 } from "node:fs/promises";
 async function getTaskBasePath(store, taskId) {
   try {
@@ -103139,7 +103964,7 @@ async function getTaskBasePath(store, taskId) {
       }
     }
     const rootDir = store.getRootDir();
-    return resolve21(join42(rootDir, ".fusion", "tasks", taskId));
+    return resolve21(join43(rootDir, ".fusion", "tasks", taskId));
   } catch (err) {
     const error = err;
     if (error.code === "ENOENT" || error.message && error.message.includes("not found")) {
@@ -103166,7 +103991,7 @@ function validatePath(basePath, filePath) {
     throw new FileServiceError(`Access denied: Absolute paths not allowed`, "EINVAL");
   }
   const resolvedBase = resolve21(basePath);
-  const resolvedPath = resolve21(join42(resolvedBase, decodedPath));
+  const resolvedPath = resolve21(join43(resolvedBase, decodedPath));
   const relativePath = relative11(resolvedBase, resolvedPath);
   if (relativePath.startsWith("..") || relativePath.startsWith("../") || relativePath === "..") {
     throw new FileServiceError(`Access denied: Path traversal detected`, "EINVAL");
@@ -103195,7 +104020,7 @@ async function listFilesForBasePath(basePath, subPath) {
     const entries = await readdir8(targetPath, { withFileTypes: true });
     const fileNodes = [];
     for (const entry of entries) {
-      const entryPath = join42(targetPath, entry.name);
+      const entryPath = join43(targetPath, entry.name);
       const entryStats = await stat7(entryPath);
       fileNodes.push({
         name: entry.name,
@@ -103522,7 +104347,7 @@ async function renameWorkspaceFile(store, workspace, filePath, newName) {
     }
     throw err;
   }
-  const destPath = join42(dirname13(resolvedPath), newName);
+  const destPath = join43(dirname13(resolvedPath), newName);
   const destRelative = relative11(resolve21(workspaceBase), destPath);
   if (destRelative.startsWith("..") || destRelative.startsWith("../") || destRelative === "..") {
     throw new FileServiceError("Destination would be outside workspace", "EINVAL");
@@ -103615,7 +104440,7 @@ function isHiddenPathSegment(name) {
   return name.startsWith(".");
 }
 async function walkDirForMarkdown(basePath, currentRelative, results, options) {
-  const currentPath = currentRelative ? join42(basePath, currentRelative) : basePath;
+  const currentPath = currentRelative ? join43(basePath, currentRelative) : basePath;
   let entries;
   try {
     entries = await readdir8(currentPath, { withFileTypes: true });
@@ -103623,7 +104448,7 @@ async function walkDirForMarkdown(basePath, currentRelative, results, options) {
     return;
   }
   for (const entry of entries) {
-    const entryRelativePath = currentRelative ? join42(currentRelative, entry.name) : entry.name;
+    const entryRelativePath = currentRelative ? join43(currentRelative, entry.name) : entry.name;
     if (entry.isDirectory()) {
       if (MARKDOWN_SCAN_EXCLUDED_DIRS.has(entry.name)) {
         continue;
@@ -103640,7 +104465,7 @@ async function walkDirForMarkdown(basePath, currentRelative, results, options) {
     if (!options.showHidden && isHiddenPathSegment(entry.name)) {
       continue;
     }
-    const fullPath = join42(basePath, entryRelativePath);
+    const fullPath = join43(basePath, entryRelativePath);
     let fileStats;
     try {
       fileStats = await stat7(fullPath);
@@ -103690,7 +104515,7 @@ async function scanMarkdownFiles(store, options) {
       return;
     }
     for (const entry of entries) {
-      const entryRelativePath = relativeDir ? join42(relativeDir, entry.name) : entry.name;
+      const entryRelativePath = relativeDir ? join43(relativeDir, entry.name) : entry.name;
       let shouldRecurse = entry.isDirectory();
       if (!shouldRecurse && typeof entry.isSymbolicLink === "function" && entry.isSymbolicLink()) {
         let symlinkPath;
@@ -103780,8 +104605,8 @@ async function searchWorkspaceFiles(store, workspace, query) {
       if (entry.isDirectory() && EXCLUDED_DIRS.has(entry.name)) {
         continue;
       }
-      const fullPath = join42(dir2, entry.name);
-      const relPath = join42(relativeDir, entry.name);
+      const fullPath = join43(dir2, entry.name);
+      const relPath = join43(relativeDir, entry.name);
       if (entry.isFile()) {
         if (entry.name.toLowerCase().includes(lowerQuery)) {
           results.push({
@@ -103802,8 +104627,8 @@ async function copyDirectoryRecursive(source, destination) {
   await mkdir14(destination, { recursive: true });
   const entries = await readdir8(source, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join42(source, entry.name);
-    const destPath = join42(destination, entry.name);
+    const sourcePath = join43(source, entry.name);
+    const destPath = join43(destination, entry.name);
     if (entry.isDirectory()) {
       await copyDirectoryRecursive(sourcePath, destPath);
     } else {
@@ -107872,7 +108697,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join68(s) {
+      BufferList.prototype.join = function join69(s) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret = "" + p.data;
@@ -130369,19 +131194,19 @@ var init_register_agents_projects_nodes = __esm({
 });
 
 // ../dashboard/src/exec-file.ts
-import { execFile as execFile6 } from "node:child_process";
+import { execFile as execFile7 } from "node:child_process";
 import { promisify as promisify13 } from "node:util";
-var execFileAsync3;
+var execFileAsync4;
 var init_exec_file = __esm({
   "../dashboard/src/exec-file.ts"() {
     "use strict";
-    execFileAsync3 = promisify13(execFile6);
+    execFileAsync4 = promisify13(execFile7);
   }
 });
 
 // ../dashboard/src/routes/register-project-routes.ts
 import * as fsPromises from "node:fs/promises";
-import { dirname as dirname14, isAbsolute as isAbsolute16, join as join43 } from "node:path";
+import { dirname as dirname14, isAbsolute as isAbsolute17, join as join44 } from "node:path";
 var access9, stat8, mkdir15, readdir9, rm3, registerProjectRoutes;
 var init_register_project_routes = __esm({
   "../dashboard/src/routes/register-project-routes.ts"() {
@@ -130529,7 +131354,7 @@ var init_register_project_routes = __esm({
           if (normalizedPath.includes("\0")) {
             throw badRequest("path cannot contain null bytes");
           }
-          if (!isAbsolute16(normalizedPath)) {
+          if (!isAbsolute17(normalizedPath)) {
             throw badRequest("path must be an absolute path");
           }
           if (cloneUrl !== void 0) {
@@ -130586,7 +131411,7 @@ var init_register_project_routes = __esm({
               throw badRequest("cloneUrl must be a non-empty string when provided");
             }
             try {
-              await execFileAsync3("git", ["clone", cloneSource, normalizedPath], {
+              await execFileAsync4("git", ["clone", cloneSource, normalizedPath], {
                 timeout: 9e4,
                 maxBuffer: 10 * 1024 * 1024,
                 encoding: "utf-8"
@@ -130604,7 +131429,7 @@ var init_register_project_routes = __esm({
             }
           }
           let hasFusionDir = false;
-          const fusionDirPath = join43(normalizedPath, ".fusion");
+          const fusionDirPath = join44(normalizedPath, ".fusion");
           try {
             await access9(fusionDirPath);
             hasFusionDir = true;
@@ -130668,8 +131493,8 @@ var init_register_project_routes = __esm({
             const entries = await readdir9(searchPath, { withFileTypes: true });
             for (const entry of entries) {
               if (!entry.isDirectory()) continue;
-              const dirPath = join43(searchPath, entry.name);
-              if (isValidSqliteDatabaseFile(join43(dirPath, ".fusion", "fusion.db"))) {
+              const dirPath = join44(searchPath, entry.name);
+              if (isValidSqliteDatabaseFile(join44(dirPath, ".fusion", "fusion.db"))) {
                 detected.push({
                   path: dirPath,
                   suggestedName: entry.name,
@@ -131104,14 +131929,14 @@ var init_register_node_routes = __esm({
 
 // ../dashboard/src/auth-paths.ts
 import path3 from "node:path";
-import { homedir as homedir6 } from "node:os";
-function getFusionAgentDir2(home = process.env.HOME || process.env.USERPROFILE || homedir6()) {
+import { homedir as homedir7 } from "node:os";
+function getFusionAgentDir2(home = process.env.HOME || process.env.USERPROFILE || homedir7()) {
   return path3.join(home, ".fusion", "agent");
 }
-function getFusionAuthPath2(home = process.env.HOME || process.env.USERPROFILE || homedir6()) {
+function getFusionAuthPath2(home = process.env.HOME || process.env.USERPROFILE || homedir7()) {
   return path3.join(getFusionAgentDir2(home), "auth.json");
 }
-function getAuthFileCandidates(cwd = process.cwd(), home = process.env.HOME || process.env.USERPROFILE || homedir6()) {
+function getAuthFileCandidates(cwd = process.cwd(), home = process.env.HOME || process.env.USERPROFILE || homedir7()) {
   return [
     path3.join(home, ".fusion", "agent", "auth.json"),
     path3.join(home, ".fusion", "auth.json"),
@@ -134096,7 +134921,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 join44, resolve as resolve22 } from "node:path";
+import { join as join45, resolve as resolve22 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline as streamPipeline } from "node:stream/promises";
 function registerAgentImportExportRoutes(ctx) {
@@ -134137,7 +134962,7 @@ function registerAgentImportExportRoutes(ctx) {
       } else if (typeof outputDir === "string") {
         throw badRequest("outputDir cannot be empty");
       } else {
-        resolvedOutputDir = await mkdtemp(join44(tmpdir3(), "fusion-agent-export-"));
+        resolvedOutputDir = await mkdtemp(join45(tmpdir3(), "fusion-agent-export-"));
       }
       const result = await exportAgentsToDirectory2(agentsToExport, resolvedOutputDir, {
         companyName: typeof companyName === "string" ? companyName : void 0,
@@ -134264,7 +135089,7 @@ ${body}`;
       return result;
     }
     const safeCompanySlug = companySlug ? slugifyPathSegment2(companySlug, "unknown-company") : "unknown-company";
-    const skillsBaseDir = join44(projectRoot, "skills", "imported", safeCompanySlug);
+    const skillsBaseDir = join45(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;
@@ -134281,8 +135106,8 @@ ${body}`;
         skillSlug = `${skillSlug}-${counter}`;
       }
       usedSlugs.add(skillSlug);
-      const skillDir = join44(skillsBaseDir, skillSlug);
-      const skillPath = join44(skillDir, "SKILL.md");
+      const skillDir = join45(skillsBaseDir, skillSlug);
+      const skillPath = join45(skillDir, "SKILL.md");
       try {
         await access10(skillPath);
         result.skipped.push(name);
@@ -134452,8 +135277,8 @@ ${body}`;
         const archiveUrl = `https://github.com/${repoOwner}/${repoName}/archive/refs/heads/main.tar.gz`;
         let tempDir = null;
         try {
-          tempDir = await mkdtemp(join44(tmpdir3(), `fn-agent-import-${importCompanySlug}-`));
-          const archivePath = join44(tempDir, "archive.tar.gz");
+          tempDir = await mkdtemp(join45(tmpdir3(), `fn-agent-import-${importCompanySlug}-`));
+          const archivePath = join45(tempDir, "archive.tar.gz");
           const downloadController = new AbortController();
           const downloadTimeout = setTimeout(() => downloadController.abort(), 3e4);
           let archiveResponse;
@@ -135582,7 +136407,7 @@ import * as child_process from "node:child_process";
 function getHomeDir5() {
   return process.env.HOME || process.env.USERPROFILE || os4.homedir();
 }
-function execFileAsync4(file, args, options) {
+function execFileAsync5(file, args, options) {
   return new Promise((resolve39, reject2) => {
     child_process.execFile(file, args, options, (error, stdout, stderr) => {
       if (error) {
@@ -135731,7 +136556,7 @@ async function readConfiguredApiKey(provider, authStorage) {
 }
 async function readClaudeKeychainCredentials() {
   try {
-    const { stdout } = await execFileAsync4(
+    const { stdout } = await execFileAsync5(
       "security",
       ["find-generic-password", "-s", "Claude Code-credentials", "-w"],
       { encoding: "utf-8", timeout: 5e3 }
@@ -136604,13 +137429,13 @@ async function fetchGitHubCopilotUsage() {
     windows: []
   };
   try {
-    await execFileAsync4("gh", ["auth", "status"], { encoding: "utf-8", timeout: 5e3 });
+    await execFileAsync5("gh", ["auth", "status"], { encoding: "utf-8", timeout: 5e3 });
   } catch {
     usage.error = "GitHub CLI not authenticated \u2014 run 'gh auth login'";
     return usage;
   }
   try {
-    const { stdout } = await execFileAsync4("gh", ["api", "/user/copilot", "--jq", "."], {
+    const { stdout } = await execFileAsync5("gh", ["api", "/user/copilot", "--jq", "."], {
       encoding: "utf-8",
       timeout: 1e4
     });
@@ -136763,7 +137588,7 @@ var init_register_usage_routes = __esm({
 });
 
 // ../dashboard/src/claude-cli-probe.ts
-import { spawn as spawn9 } from "node:child_process";
+import { spawn as spawn10 } from "node:child_process";
 async function probeClaudeCli(options = {}) {
   const startedAt = Date.now();
   const timeoutMs = options.timeoutMs ?? PROBE_TIMEOUT_MS;
@@ -136773,7 +137598,7 @@ async function probeClaudeCli(options = {}) {
       resolvePromise({ ...result, probeDurationMs: Date.now() - startedAt });
     };
     let settled = false;
-    const child = spawn9(binaryPath ?? "claude", ["--version"], {
+    const child = spawn10(binaryPath ?? "claude", ["--version"], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const timer = setTimeout(() => {
@@ -136831,7 +137656,7 @@ async function probeClaudeCli(options = {}) {
 async function tryResolveBinaryPath3(binary) {
   return new Promise((resolvePromise) => {
     const which = process.platform === "win32" ? "where" : "which";
-    const child = spawn9(which, [binary], { stdio: ["ignore", "pipe", "ignore"] });
+    const child = spawn10(which, [binary], { stdio: ["ignore", "pipe", "ignore"] });
     let out = "";
     child.stdout?.on("data", (chunk) => {
       out += chunk.toString("utf-8");
@@ -137555,7 +138380,7 @@ function stripAnsi2(str) {
   return str.replace(/\x1B\[[0-9;]*[mGKJHFABCDSTsu]/g, "");
 }
 async function mintAgentApiKeyViaCli(opts) {
-  const { spawn: spawn15 } = await import("node:child_process");
+  const { spawn: spawn16 } = await import("node:child_process");
   const bin = opts.cliBinaryPath ?? "paperclipai";
   const args = [
     "agent",
@@ -137579,7 +138404,7 @@ async function mintAgentApiKeyViaCli(opts) {
   return new Promise((resolve39, reject2) => {
     let child;
     try {
-      child = spawn15(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+      child = spawn16(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
@@ -137662,7 +138487,7 @@ function remapSpawnError(err, bin) {
   return err instanceof Error ? err : new Error(String(err));
 }
 async function spawnPaperclipCliJson(args, opts) {
-  const { spawn: spawn15 } = await import("node:child_process");
+  const { spawn: spawn16 } = await import("node:child_process");
   const bin = opts.cliBinaryPath ?? "paperclipai";
   const fullArgs = [...args, "--json"];
   if (opts.cliConfigPath) {
@@ -137673,7 +138498,7 @@ async function spawnPaperclipCliJson(args, opts) {
   return new Promise((resolve39, reject2) => {
     let child;
     try {
-      child = spawn15(bin, fullArgs, { stdio: ["ignore", "pipe", "pipe"] });
+      child = spawn16(bin, fullArgs, { stdio: ["ignore", "pipe", "pipe"] });
     } catch (err) {
       reject2(remapSpawnError(err, bin));
       return;
@@ -138487,9 +139312,9 @@ var init_register_runtime_provider_routes = __esm({
 });
 
 // ../dashboard/src/update-check.ts
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync10 } from "node:fs";
 import { mkdir as mkdir17, rm as rm5, writeFile as writeFile15 } from "node:fs/promises";
-import { join as join46 } from "node:path";
+import { join as join47 } from "node:path";
 function ttlForFrequency(frequency) {
   switch (frequency) {
     case "manual":
@@ -138503,7 +139328,7 @@ function ttlForFrequency(frequency) {
   }
 }
 function getCachePath(fusionDir) {
-  return join46(fusionDir, CACHE_FILENAME);
+  return join47(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);
@@ -138527,7 +139352,7 @@ function isValidResult(value) {
 }
 function readCachedUpdateCheck(fusionDir) {
   try {
-    const raw = readFileSync9(getCachePath(fusionDir), "utf-8");
+    const raw = readFileSync10(getCachePath(fusionDir), "utf-8");
     const parsed = JSON.parse(raw);
     return isValidResult(parsed) ? parsed : null;
   } catch {
@@ -138595,15 +139420,15 @@ var init_update_check = __esm({
 });
 
 // ../dashboard/src/cli-package-version.ts
-import { existsSync as existsSync30, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync31, readFileSync as readFileSync11 } from "node:fs";
 import { dirname as dirname15, resolve as resolve23 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function readCliPackageVersion(pkgPath) {
-  if (!existsSync30(pkgPath)) {
+  if (!existsSync31(pkgPath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync11(pkgPath, "utf-8"));
     if (parsed.name === CLI_PACKAGE_NAME && typeof parsed.version === "string" && parsed.version.length > 0) {
       return {
         packageJsonPath: pkgPath,
@@ -142972,7 +143797,7 @@ var init_todo_routes = __esm({
 
 // ../dashboard/src/dev-server-detect.ts
 import { glob, readFile as readFile20 } from "node:fs/promises";
-import { dirname as dirname16, join as join47, relative as relative12, resolve as resolve24 } from "node:path";
+import { dirname as dirname16, join as join48, relative as relative12, resolve as resolve24 } from "node:path";
 async function readPackageJson(filePath) {
   try {
     const raw = await readFile20(filePath, "utf-8");
@@ -143015,7 +143840,7 @@ function scoreCandidate(scriptName, pkg) {
 async function collectWorkspacePackageJsons(projectRoot) {
   const discovered = /* @__PURE__ */ new Set();
   try {
-    await readFile20(join47(projectRoot, "pnpm-workspace.yaml"), "utf-8");
+    await readFile20(join48(projectRoot, "pnpm-workspace.yaml"), "utf-8");
   } catch {
   }
   for (const pattern of ["packages/*/package.json", "apps/*/package.json"]) {
@@ -143049,7 +143874,7 @@ function toSource(projectRoot, packageJsonPath) {
 async function detectDevServerScripts(projectRoot) {
   const root = resolve24(projectRoot);
   const candidates = [];
-  const rootPackagePath = join47(root, "package.json");
+  const rootPackagePath = join48(root, "package.json");
   const rootPackage = await readPackageJson(rootPackagePath);
   if (rootPackage) {
     for (const script of extractScripts(rootPackage)) {
@@ -143116,9 +143941,9 @@ var init_dev_server_detect = __esm({
 
 // ../dashboard/src/dev-server-store.ts
 import { mkdir as mkdir18, readFile as readFile21, writeFile as writeFile16 } from "node:fs/promises";
-import { dirname as dirname17, join as join48, resolve as resolve25 } from "node:path";
+import { dirname as dirname17, join as join49, resolve as resolve25 } from "node:path";
 function devServerFilePath(projectDir) {
-  return join48(resolve25(projectDir), ".fusion", "dev-server.json");
+  return join49(resolve25(projectDir), ".fusion", "dev-server.json");
 }
 function normalizeState(candidate) {
   const defaults = DEV_SERVER_DEFAULT_STATE();
@@ -143486,7 +144311,7 @@ var init_dev_server_port_detect = __esm({
 
 // ../dashboard/src/dev-server-process.ts
 import { EventEmitter as EventEmitter33 } from "node:events";
-import { spawn as spawn10 } from "node:child_process";
+import { spawn as spawn11 } from "node:child_process";
 function killManagedProcess2(child, signal) {
   if (typeof child.pid !== "number") {
     return;
@@ -143565,7 +144390,7 @@ var init_dev_server_process = __esm({
           detectedUrl: void 0,
           detectedPort: void 0
         });
-        const child = spawn10(safeCommand, [], {
+        const child = spawn11(safeCommand, [], {
           cwd: safeCwd,
           detached: process.platform !== "win32",
           shell: true,
@@ -144372,7 +145197,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 resolve26, sep as sep7, join as join49, isAbsolute as isAbsolute17 } from "node:path";
+import { resolve as resolve26, sep as sep7, join as join50, isAbsolute as isAbsolute18 } from "node:path";
 import * as nodeFs from "node:fs";
 import os5 from "node:os";
 import v8 from "node:v8";
@@ -144393,8 +145218,8 @@ function hasPackageManagerSettings2(settings) {
 function getPiPackageManagerAgentDir() {
   const fusionAgentDir = getFusionAgentDir();
   const legacyAgentDir = getLegacyPiAgentDir();
-  const fusionSettings = readJsonObject3(join49(fusionAgentDir, "settings.json"));
-  const legacySettings = readJsonObject3(join49(legacyAgentDir, "settings.json"));
+  const fusionSettings = readJsonObject3(join50(fusionAgentDir, "settings.json"));
+  const legacySettings = readJsonObject3(join50(legacyAgentDir, "settings.json"));
   if (hasPackageManagerSettings2(fusionSettings) || !nodeFs.existsSync(legacyAgentDir)) {
     return fusionAgentDir;
   }
@@ -144417,10 +145242,10 @@ async function discoverDashboardPiExtensions(cwd) {
   try {
     const { DefaultPackageManager: DefaultPackageManager5 } = await import("@mariozechner/pi-coding-agent");
     const agentDir = getPiPackageManagerAgentDir();
-    const legacyGlobalSettings = readJsonObject3(join49(getLegacyPiAgentDir(), "settings.json"));
-    const fusionGlobalSettings = readJsonObject3(join49(getFusionAgentDir(), "settings.json"));
+    const legacyGlobalSettings = readJsonObject3(join50(getLegacyPiAgentDir(), "settings.json"));
+    const fusionGlobalSettings = readJsonObject3(join50(getFusionAgentDir(), "settings.json"));
     const globalSettings = { ...legacyGlobalSettings, ...fusionGlobalSettings };
-    const projectSettings = readJsonObject3(join49(cwd, ".fusion", "settings.json"));
+    const projectSettings = readJsonObject3(join50(cwd, ".fusion", "settings.json"));
     const mergedSettings = { ...globalSettings, ...projectSettings };
     const packageManager = new DefaultPackageManager5({
       cwd,
@@ -144556,7 +145381,7 @@ function sanitizeOverlapIgnorePaths(value) {
     if (!trimmed) {
       throw badRequest(`overlapIgnorePaths[${index2}] cannot be empty`);
     }
-    if (isAbsolute17(trimmed) || /^[a-zA-Z]:\//.test(trimmed)) {
+    if (isAbsolute18(trimmed) || /^[a-zA-Z]:\//.test(trimmed)) {
       throw badRequest(`overlapIgnorePaths[${index2}] must be a project-relative path`);
     }
     if (/^\.{1,2}(\/|$)/.test(trimmed) || /(^|\/)\.\.(\/|$)/.test(trimmed)) {
@@ -146761,7 +147586,7 @@ Description: ${step.description}`
           return;
         }
       }
-      const { resolve: resolve39, dirname: dirname29, join: join68 } = await import("node:path");
+      const { resolve: resolve39, dirname: dirname29, join: join69 } = 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";
@@ -146786,7 +147611,7 @@ Description: ${step.description}`
       for (const entry of dirEntries) {
         if (!entry.isDirectory()) continue;
         if (!showHidden && entry.name.startsWith(".")) continue;
-        const entryPath = join68(resolvedPath, entry.name);
+        const entryPath = join69(resolvedPath, entry.name);
         let hasChildren = false;
         try {
           const subEntries = await readdir12(entryPath, { withFileTypes: true });
@@ -147040,9 +147865,9 @@ function truncateAutomationOutput(stdout, stderr) {
   return output;
 }
 async function executeSingleCommand(command, timeoutMs, startedAt) {
-  const { exec: exec12 } = await import("node:child_process");
+  const { exec: exec13 } = await import("node:child_process");
   const { promisify: promisify18 } = await import("node:util");
-  const execAsyncFn = promisify18(exec12);
+  const execAsyncFn = promisify18(exec13);
   const isWindows = process.platform === "win32";
   try {
     const { stdout, stderr } = await execAsyncFn(command, {
@@ -147424,7 +148249,7 @@ function stripTaskListHeavyFields(task) {
   const candidate = task;
   const existingTimed = candidate.timedExecutionMs;
   const timedExecutionMs = typeof existingTimed === "number" ? existingTimed : sumTimedLogEntries(candidate.log);
-  return { ...task, log: [], timedExecutionMs };
+  return { ...task, log: [], timedExecutionMs, tokenUsage: candidate.tokenUsage, workflowStepResults: candidate.workflowStepResults };
 }
 function sumTimedLogEntries(log18) {
   if (!Array.isArray(log18)) return 0;
@@ -152327,8 +153152,8 @@ var init_auth_middleware = __esm({
 // ../dashboard/src/server.ts
 import express from "express";
 import { randomUUID as randomUUID20 } from "node:crypto";
-import { join as join50, dirname as dirname18 } from "node:path";
-import { existsSync as existsSync32, readFileSync as readFileSync12 } from "node:fs";
+import { join as join51, dirname as dirname18 } from "node:path";
+import { existsSync as existsSync33, readFileSync as readFileSync13 } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { createSecureServer as createHttp2SecureServer } from "node:http2";
 function parseVersion2(version) {
@@ -152430,11 +153255,11 @@ function loadTlsCredentialsFromEnv(env = process.env) {
       "FUSION_TLS_* environment is incomplete: set both a cert and a key (inline via FUSION_TLS_CERT/FUSION_TLS_KEY or paths via *_FILE)."
     );
   }
-  const cert = certInline ? Buffer.from(certInline) : readFileSync12(certFile);
-  const key = keyInline ? Buffer.from(keyInline) : readFileSync12(keyFile);
+  const cert = certInline ? Buffer.from(certInline) : readFileSync13(certFile);
+  const key = keyInline ? Buffer.from(keyInline) : readFileSync13(keyFile);
   const caInline = env.FUSION_TLS_CA;
   const caFile = env.FUSION_TLS_CA_FILE;
-  const ca = caInline ? Buffer.from(caInline) : caFile ? readFileSync12(caFile) : void 0;
+  const ca = caInline ? Buffer.from(caInline) : caFile ? readFileSync13(caFile) : void 0;
   return { cert, key, ca };
 }
 function createServer(store, options) {
@@ -152510,11 +153335,11 @@ function createServer(store, options) {
   getTerminalService(store.getRootDir());
   const isHeadless = options?.headless === true;
   const execDir = dirname18(process.execPath);
-  const clientDir = process.env.FUSION_CLIENT_DIR ? process.env.FUSION_CLIENT_DIR : existsSync32(join50(execDir, "client", "index.html")) ? join50(execDir, "client") : existsSync32(join50(__dirname, "..", "dist", "client")) ? join50(__dirname, "..", "dist", "client") : join50(__dirname, "..", "client");
+  const clientDir = process.env.FUSION_CLIENT_DIR ? process.env.FUSION_CLIENT_DIR : existsSync33(join51(execDir, "client", "index.html")) ? join51(execDir, "client") : existsSync33(join51(__dirname, "..", "dist", "client")) ? join51(__dirname, "..", "dist", "client") : join51(__dirname, "..", "client");
   if (!isHeadless) {
     app.get("/version.json", (_req, res) => {
       res.setHeader("Cache-Control", "no-store, max-age=0");
-      res.sendFile(join50(clientDir, "version.json"), (err) => {
+      res.sendFile(join51(clientDir, "version.json"), (err) => {
         if (err) {
           res.status(404).json({ version: null });
         }
@@ -152934,7 +153759,7 @@ data: ${JSON.stringify({ type: event.type, data: event.data })}
   });
   if (!isHeadless) {
     app.get("/{*splat}", (_req, res) => {
-      res.sendFile(join50(clientDir, "index.html"));
+      res.sendFile(join51(clientDir, "index.html"));
     });
   }
   const dashboardApp = app;
@@ -153389,7 +154214,7 @@ var init_server = __esm({
 
 // ../dashboard/src/skills-adapter.ts
 import { access as access11, readFile as readFile22, writeFile as writeFile17, mkdir as mkdir19, readdir as readdir10, stat as stat10 } from "node:fs/promises";
-import { join as join51, relative as relative13, dirname as dirname19 } from "node:path";
+import { join as join52, relative as relative13, dirname as dirname19 } from "node:path";
 async function pathExists(path5) {
   try {
     await access11(path5);
@@ -153645,7 +154470,7 @@ function createSkillsAdapter(options) {
       } catch {
         skillDir = dirname19(skill.path);
       }
-      const skillMdPath = join51(skillDir, "SKILL.md");
+      const skillMdPath = join52(skillDir, "SKILL.md");
       let skillMd = "";
       try {
         skillMd = await readFile22(skillMdPath, "utf-8");
@@ -153853,7 +154678,7 @@ function normalizeEntry(entry) {
   };
 }
 function getProjectSettingsPath(rootDir) {
-  return join51(rootDir, ".fusion", "settings.json");
+  return join52(rootDir, ".fusion", "settings.json");
 }
 var MIN_PUBLIC_SEARCH_QUERY_LENGTH;
 var init_skills_adapter = __esm({
@@ -153917,7 +154742,7 @@ var init_src4 = __esm({
 });
 
 // src/commands/task-lifecycle.ts
-import { exec as exec9 } from "node:child_process";
+import { exec as exec10 } from "node:child_process";
 import { promisify as promisify14 } from "node:util";
 function getMergeStrategy(settings) {
   return settings.mergeStrategy ?? "direct";
@@ -154043,7 +154868,7 @@ var execAsync9;
 var init_task_lifecycle = __esm({
   "src/commands/task-lifecycle.ts"() {
     "use strict";
-    execAsync9 = promisify14(exec9);
+    execAsync9 = promisify14(exec10);
   }
 });
 
@@ -154096,33 +154921,33 @@ var init_port_prompt = __esm({
 });
 
 // src/commands/provider-settings.ts
-import { existsSync as existsSync33, readFileSync as readFileSync13, writeFileSync as writeFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
-import { join as join52, dirname as dirname20, basename as basename15 } from "node:path";
+import { existsSync as existsSync34, readFileSync as readFileSync14, writeFileSync as writeFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
+import { join as join53, dirname as dirname20, basename as basename15 } from "node:path";
 function siblingAgentDir2(agentDir, siblingRoot) {
   if (basename15(agentDir) !== "agent") {
     return void 0;
   }
-  return join52(dirname20(dirname20(agentDir)), siblingRoot, "agent");
+  return join53(dirname20(dirname20(agentDir)), siblingRoot, "agent");
 }
 function readJsonObject4(path5) {
-  if (!existsSync33(path5)) {
+  if (!existsSync34(path5)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync13(path5, "utf-8"));
+    const parsed = JSON.parse(readFileSync14(path5, "utf-8"));
     return parsed !== null && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
   }
 }
 function createReadOnlyProviderSettingsView(cwd, agentDir) {
-  const fusionAgentDir = agentDir.includes(`${join52(".fusion", "agent")}`) ? agentDir : siblingAgentDir2(agentDir, ".fusion");
-  const legacyAgentDir = agentDir.includes(`${join52(".pi", "agent")}`) ? agentDir : siblingAgentDir2(agentDir, ".pi");
-  const legacyGlobalSettings = legacyAgentDir ? readJsonObject4(join52(legacyAgentDir, "settings.json")) : {};
-  const fusionGlobalSettings = fusionAgentDir ? readJsonObject4(join52(fusionAgentDir, "settings.json")) : {};
-  const directGlobalSettings = readJsonObject4(join52(agentDir, "settings.json"));
+  const fusionAgentDir = agentDir.includes(`${join53(".fusion", "agent")}`) ? agentDir : siblingAgentDir2(agentDir, ".fusion");
+  const legacyAgentDir = agentDir.includes(`${join53(".pi", "agent")}`) ? agentDir : siblingAgentDir2(agentDir, ".pi");
+  const legacyGlobalSettings = legacyAgentDir ? readJsonObject4(join53(legacyAgentDir, "settings.json")) : {};
+  const fusionGlobalSettings = fusionAgentDir ? readJsonObject4(join53(fusionAgentDir, "settings.json")) : {};
+  const directGlobalSettings = readJsonObject4(join53(agentDir, "settings.json"));
   const globalSettings = { ...legacyGlobalSettings, ...directGlobalSettings, ...fusionGlobalSettings };
-  const fusionProjectSettings = readJsonObject4(join52(cwd, ".fusion", "settings.json"));
+  const fusionProjectSettings = readJsonObject4(join53(cwd, ".fusion", "settings.json"));
   const mergedSettings = { ...globalSettings, ...fusionProjectSettings };
   return {
     getGlobalSettings: () => structuredClone(globalSettings),
@@ -154137,7 +154962,7 @@ var init_provider_settings = __esm({
 });
 
 // src/commands/provider-auth.ts
-import { existsSync as existsSync34, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync35, readFileSync as readFileSync15 } from "node:fs";
 import { getOAuthProvider as getOAuthProvider2 } from "@mariozechner/pi-ai/oauth";
 function getProviderDisplayName(providerId) {
   const knownProviderNames = new Map(
@@ -154266,11 +155091,11 @@ function createReadOnlyAuthFileStorage(authPaths) {
   const reload = () => {
     const nextCredentials = {};
     for (const authPath of authPaths) {
-      if (!existsSync34(authPath)) {
+      if (!existsSync35(authPath)) {
         continue;
       }
       try {
-        const parsed = JSON.parse(readFileSync14(authPath, "utf-8"));
+        const parsed = JSON.parse(readFileSync15(authPath, "utf-8"));
         for (const [provider, credential] of Object.entries(parsed)) {
           nextCredentials[provider] ??= credential;
         }
@@ -154306,46 +155131,46 @@ var init_provider_auth = __esm({
 });
 
 // src/commands/auth-paths.ts
-import { homedir as homedir8 } from "node:os";
-import { existsSync as existsSync35, readFileSync as readFileSync15 } from "node:fs";
-import { join as join53 } from "node:path";
-function getFusionAgentDir3(home = process.env.HOME || process.env.USERPROFILE || homedir8()) {
-  return join53(home, ".fusion", "agent");
+import { homedir as homedir9 } from "node:os";
+import { existsSync as existsSync36, readFileSync as readFileSync16 } from "node:fs";
+import { join as join54 } from "node:path";
+function getFusionAgentDir3(home = process.env.HOME || process.env.USERPROFILE || homedir9()) {
+  return join54(home, ".fusion", "agent");
 }
-function getLegacyAgentDir(home = process.env.HOME || process.env.USERPROFILE || homedir8()) {
-  return join53(home, ".pi", "agent");
+function getLegacyAgentDir(home = process.env.HOME || process.env.USERPROFILE || homedir9()) {
+  return join54(home, ".pi", "agent");
 }
-function getFusionAuthPath3(home = process.env.HOME || process.env.USERPROFILE || homedir8()) {
-  return join53(getFusionAgentDir3(home), "auth.json");
+function getFusionAuthPath3(home = process.env.HOME || process.env.USERPROFILE || homedir9()) {
+  return join54(getFusionAgentDir3(home), "auth.json");
 }
-function getLegacyAuthPaths2(home = process.env.HOME || process.env.USERPROFILE || homedir8()) {
+function getLegacyAuthPaths2(home = process.env.HOME || process.env.USERPROFILE || homedir9()) {
   return [
-    join53(home, ".pi", "agent", "auth.json"),
-    join53(home, ".pi", "auth.json")
+    join54(home, ".pi", "agent", "auth.json"),
+    join54(home, ".pi", "auth.json")
   ];
 }
-function getFusionModelsPath2(home = process.env.HOME || process.env.USERPROFILE || homedir8()) {
-  return join53(getFusionAgentDir3(home), "models.json");
+function getFusionModelsPath2(home = process.env.HOME || process.env.USERPROFILE || homedir9()) {
+  return join54(getFusionAgentDir3(home), "models.json");
 }
-function getLegacyModelsPaths2(home = process.env.HOME || process.env.USERPROFILE || homedir8()) {
+function getLegacyModelsPaths2(home = process.env.HOME || process.env.USERPROFILE || homedir9()) {
   return [
-    join53(home, ".pi", "agent", "models.json"),
-    join53(home, ".pi", "models.json")
+    join54(home, ".pi", "agent", "models.json"),
+    join54(home, ".pi", "models.json")
   ];
 }
-function getModelRegistryModelsPath2(home = process.env.HOME || process.env.USERPROFILE || homedir8()) {
+function getModelRegistryModelsPath2(home = process.env.HOME || process.env.USERPROFILE || homedir9()) {
   const fusionModelsPath = getFusionModelsPath2(home);
-  if (existsSync35(fusionModelsPath)) {
+  if (existsSync36(fusionModelsPath)) {
     return fusionModelsPath;
   }
-  return getLegacyModelsPaths2(home).find((modelsPath) => existsSync35(modelsPath)) ?? fusionModelsPath;
+  return getLegacyModelsPaths2(home).find((modelsPath) => existsSync36(modelsPath)) ?? fusionModelsPath;
 }
 function readJsonObject5(path5) {
-  if (!existsSync35(path5)) {
+  if (!existsSync36(path5)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync15(path5, "utf-8"));
+    const parsed = JSON.parse(readFileSync16(path5, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -154354,18 +155179,18 @@ function readJsonObject5(path5) {
 function hasPackageManagerSettings3(settings) {
   return Array.isArray(settings.packages) || Array.isArray(settings.npmCommand);
 }
-function getPackageManagerAgentDir2(home = process.env.HOME || process.env.USERPROFILE || homedir8()) {
+function getPackageManagerAgentDir2(home = process.env.HOME || process.env.USERPROFILE || homedir9()) {
   const fusionAgentDir = getFusionAgentDir3(home);
   const legacyAgentDir = getLegacyAgentDir(home);
-  const fusionSettings = readJsonObject5(join53(fusionAgentDir, "settings.json"));
-  const legacySettings = readJsonObject5(join53(legacyAgentDir, "settings.json"));
-  if (hasPackageManagerSettings3(fusionSettings) || !existsSync35(legacyAgentDir)) {
+  const fusionSettings = readJsonObject5(join54(fusionAgentDir, "settings.json"));
+  const legacySettings = readJsonObject5(join54(legacyAgentDir, "settings.json"));
+  if (hasPackageManagerSettings3(fusionSettings) || !existsSync36(legacyAgentDir)) {
     return fusionAgentDir;
   }
   if (hasPackageManagerSettings3(legacySettings)) {
     return legacyAgentDir;
   }
-  return existsSync35(fusionAgentDir) ? fusionAgentDir : legacyAgentDir;
+  return existsSync36(fusionAgentDir) ? fusionAgentDir : legacyAgentDir;
 }
 var init_auth_paths2 = __esm({
   "src/commands/auth-paths.ts"() {
@@ -154523,7 +155348,7 @@ var init_project_context = __esm({
 // src/commands/claude-skills.ts
 import {
   cpSync,
-  existsSync as existsSync36,
+  existsSync as existsSync37,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync7,
   readlinkSync,
@@ -154531,7 +155356,7 @@ import {
   symlinkSync,
   unlinkSync
 } from "node:fs";
-import { dirname as dirname22, join as join54, resolve as resolve28 } from "node:path";
+import { dirname as dirname22, join as join55, resolve as resolve28 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function isPiClaudeCliConfigured(globalSettings) {
   if (!globalSettings || typeof globalSettings !== "object") {
@@ -154552,10 +155377,10 @@ function isPiClaudeCliConfigured(globalSettings) {
 function resolveFusionSkillSource() {
   const here = fileURLToPath6(import.meta.url);
   const candidate = resolve28(dirname22(here), "..", "..", "skill", FUSION_SKILL_NAME);
-  return existsSync36(candidate) ? candidate : null;
+  return existsSync37(candidate) ? candidate : null;
 }
 function installFusionSkillIntoProject(projectPath, options = {}) {
-  const target = join54(projectPath, ".claude", "skills", FUSION_SKILL_NAME);
+  const target = join55(projectPath, ".claude", "skills", FUSION_SKILL_NAME);
   if (options.enabled === false) {
     return { outcome: "skipped", target, reason: "pi-claude-cli not configured" };
   }
@@ -154570,7 +155395,7 @@ function installFusionSkillIntoProject(projectPath, options = {}) {
   try {
     mkdirSync7(dirname22(target), { recursive: true });
     let replaced = false;
-    if (existsSync36(target) || isBrokenSymlink(target)) {
+    if (existsSync37(target) || isBrokenSymlink(target)) {
       const stat12 = lstatSync2(target);
       if (stat12.isSymbolicLink()) {
         const current = safeReadlink(target);
@@ -154580,8 +155405,8 @@ function installFusionSkillIntoProject(projectPath, options = {}) {
         unlinkSync(target);
         replaced = true;
       } else {
-        const skillMd = join54(target, "SKILL.md");
-        if (!existsSync36(skillMd)) {
+        const skillMd = join55(target, "SKILL.md");
+        if (!existsSync37(skillMd)) {
           return {
             outcome: "failed",
             target,
@@ -154627,7 +155452,7 @@ function ensureFusionSkillForProjects(projects, options = { enabled: false }) {
   if (!options.enabled) {
     return projects.map((p) => ({
       outcome: "skipped",
-      target: join54(p.path, ".claude", "skills", FUSION_SKILL_NAME),
+      target: join55(p.path, ".claude", "skills", FUSION_SKILL_NAME),
       reason: "pi-claude-cli not configured"
     }));
   }
@@ -154640,7 +155465,7 @@ function isBrokenSymlink(path5) {
   try {
     const stat12 = lstatSync2(path5);
     if (!stat12.isSymbolicLink()) return false;
-    return !existsSync36(path5);
+    return !existsSync37(path5);
   } catch {
     return false;
   }
@@ -154737,7 +155562,7 @@ var init_claude_skills_runner = __esm({
 });
 
 // src/commands/claude-cli-extension.ts
-import { existsSync as existsSync37, readFileSync as readFileSync16 } from "node:fs";
+import { existsSync as existsSync38, readFileSync as readFileSync17 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 import { dirname as dirname23, resolve as resolve29 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
@@ -154746,7 +155571,7 @@ function resolveClaudeCliExtensionFromModuleUrl(moduleUrl) {
   const here = dirname23(fileURLToPath7(moduleUrl));
   for (const rel of ["pi-claude-cli", "../pi-claude-cli", "../../pi-claude-cli"]) {
     const candidate = resolve29(here, rel, "package.json");
-    if (existsSync37(candidate)) {
+    if (existsSync38(candidate)) {
       pkgJsonPath = candidate;
       break;
     }
@@ -154760,7 +155585,7 @@ function resolveClaudeCliExtensionFromModuleUrl(moduleUrl) {
   }
   let pkgJson;
   try {
-    pkgJson = JSON.parse(readFileSync16(pkgJsonPath, "utf-8"));
+    pkgJson = JSON.parse(readFileSync17(pkgJsonPath, "utf-8"));
   } catch (err) {
     return {
       status: "error",
@@ -154782,7 +155607,7 @@ function resolveClaudeCliExtensionFromModuleUrl(moduleUrl) {
     };
   }
   const entryPath = resolve29(dirname23(pkgJsonPath), rawEntry);
-  if (!existsSync37(entryPath)) {
+  if (!existsSync38(entryPath)) {
     return {
       status: "missing-entry",
       reason: `@fusion/pi-claude-cli extension file not found at ${entryPath}`
@@ -154833,12 +155658,12 @@ var init_claude_cli_extension = __esm({
 });
 
 // src/update-cache.ts
-import { readFileSync as readFileSync17 } from "node:fs";
-import { join as join55 } from "node:path";
+import { readFileSync as readFileSync18 } from "node:fs";
+import { join as join56 } from "node:path";
 function getCachedUpdateStatus(currentVersion) {
   try {
-    const cachePath = join55(resolveGlobalDir(), "update-check.json");
-    const raw = readFileSync17(cachePath, "utf-8");
+    const cachePath = join56(resolveGlobalDir(), "update-check.json");
+    const raw = readFileSync18(cachePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.updateAvailable === true && typeof parsed.latestVersion === "string" && parsed.latestVersion.length > 0 && typeof parsed.currentVersion === "string" && parsed.currentVersion.length > 0) {
       if (typeof currentVersion === "string" && currentVersion.length > 0 && parsed.currentVersion !== currentVersion) {
@@ -154869,7 +155694,7 @@ var init_update_cache = __esm({
 });
 
 // src/commands/self-extension.ts
-import { existsSync as existsSync38, readFileSync as readFileSync18 } from "node:fs";
+import { existsSync as existsSync39, readFileSync as readFileSync19 } from "node:fs";
 import { dirname as dirname24, resolve as resolve30 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function resolveSelfExtension() {
@@ -154877,9 +155702,9 @@ function resolveSelfExtension() {
   let pkgDir;
   let cur = here;
   for (let i = 0; i < 5; i++) {
-    if (existsSync38(resolve30(cur, "package.json"))) {
+    if (existsSync39(resolve30(cur, "package.json"))) {
       try {
-        const parsed = JSON.parse(readFileSync18(resolve30(cur, "package.json"), "utf-8"));
+        const parsed = JSON.parse(readFileSync19(resolve30(cur, "package.json"), "utf-8"));
         if (parsed.name === "@runfusion/fusion") {
           pkgDir = cur;
           break;
@@ -154896,12 +155721,12 @@ function resolveSelfExtension() {
   }
   let pkgJson;
   try {
-    pkgJson = JSON.parse(readFileSync18(resolve30(pkgDir, "package.json"), "utf-8"));
+    pkgJson = JSON.parse(readFileSync19(resolve30(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 = resolve30(pkgDir, "src", "extension.ts");
-  if (existsSync38(srcEntry)) {
+  if (existsSync39(srcEntry)) {
     return { status: "ok", path: srcEntry, packageVersion: pkgJson.version ?? "unknown" };
   }
   const extensions = pkgJson.pi?.extensions;
@@ -154913,7 +155738,7 @@ function resolveSelfExtension() {
     return { status: "missing", reason: "@runfusion/fusion pi.extensions[0] is not a valid path string" };
   }
   const entryPath = resolve30(pkgDir, rawEntry);
-  if (!existsSync38(entryPath)) {
+  if (!existsSync39(entryPath)) {
     return { status: "missing", reason: `@runfusion/fusion extension file not found at ${entryPath}` };
   }
   return { status: "ok", path: entryPath, packageVersion: pkgJson.version ?? "unknown" };
@@ -155125,7 +155950,7 @@ var init_use_projects = __esm({
 });
 
 // src/commands/dashboard-tui/utils.ts
-import { spawn as spawn11 } from "node:child_process";
+import { spawn as spawn12 } from "node:child_process";
 function isTTYAvailable() {
   return Boolean(process.stdout.isTTY && process.stdin.isTTY);
 }
@@ -155138,7 +155963,7 @@ async function copyToClipboard(text) {
   for (const { cmd, args } of candidates) {
     const ok = await new Promise((resolve39) => {
       try {
-        const child = spawn11(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
+        const child = spawn12(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
         child.once("error", () => resolve39(false));
         child.once("close", (code) => resolve39(code === 0));
         child.stdin.end(text);
@@ -155165,7 +155990,7 @@ import { useState as useState2, useSyncExternalStore, useCallback as useCallback
 import { Box, Text, useInput, useApp, useStdout } from "ink";
 import Spinner from "ink-spinner";
 import TextInput from "ink-text-input";
-import { spawn as spawn12 } from "node:child_process";
+import { spawn as spawn13 } from "node:child_process";
 import { appendFileSync } from "node:fs";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 function tuiDebug(tag, data) {
@@ -155191,7 +156016,7 @@ function openInBrowser(url) {
     args = [url];
   }
   try {
-    const child = spawn12(cmd, args, { detached: true, stdio: "ignore" });
+    const child = spawn13(cmd, args, { detached: true, stdio: "ignore" });
     child.unref();
   } catch {
   }
@@ -159168,7 +159993,7 @@ __export(dashboard_exports, {
   promptForPort: () => promptForPort,
   runDashboard: () => runDashboard
 });
-import { join as join56, resolve as pathResolve } from "node:path";
+import { join as join57, resolve as pathResolve } from "node:path";
 import { execFile as execFileCb } from "node:child_process";
 import { promisify as promisify15 } from "node:util";
 import { stat as stat11, readdir as readdir11, readFile as fsReadFile3 } from "node:fs/promises";
@@ -159324,7 +160149,7 @@ function setDiagnosticStoreListenerCheck(check) {
   diagnosticStoreListenerCheck = check;
 }
 async function gitExec(cwd, args) {
-  const { stdout } = await execFileAsync5("git", args, { cwd, maxBuffer: 4 * 1024 * 1024 });
+  const { stdout } = await execFileAsync6("git", args, { cwd, maxBuffer: 4 * 1024 * 1024 });
   return stdout;
 }
 async function buildGitStatus(projectPath) {
@@ -159506,7 +160331,7 @@ async function buildFileListDirectory(projectPath, relativePath) {
     let size = 0;
     let modifiedAt = (/* @__PURE__ */ new Date(0)).toISOString();
     try {
-      const s = await stat11(join56(absDir, d.name));
+      const s = await stat11(join57(absDir, d.name));
       size = d.isDirectory() ? 0 : s.size;
       modifiedAt = s.mtime.toISOString();
     } catch {
@@ -159939,7 +160764,7 @@ async function runDashboard(port, opts = {}) {
         ...claudeCliPaths
       ],
       cwd,
-      join56(cwd, ".fusion", "disabled-auto-extension-discovery")
+      join57(cwd, ".fusion", "disabled-auto-extension-discovery")
     );
     for (const { path: path5, error } of extensionsResult.errors) {
       logSink.log(`Failed to load ${path5}: ${error}`, "extensions");
@@ -160756,7 +161581,7 @@ async function runDashboard(port, opts = {}) {
             listWorktrees: (projectPath) => buildGitWorktrees(projectPath),
             push: async (projectPath) => {
               try {
-                const { stdout, stderr } = await execFileAsync5("git", ["push"], { cwd: projectPath, maxBuffer: 4 * 1024 * 1024 });
+                const { stdout, stderr } = await execFileAsync6("git", ["push"], { cwd: projectPath, maxBuffer: 4 * 1024 * 1024 });
                 return { success: true, output: (stdout + stderr).trim() };
               } catch (err) {
                 const msg = err instanceof Error ? err.stderr ?? err.message : String(err);
@@ -160765,7 +161590,7 @@ async function runDashboard(port, opts = {}) {
             },
             fetch: async (projectPath) => {
               try {
-                const { stdout, stderr } = await execFileAsync5("git", ["fetch"], { cwd: projectPath, maxBuffer: 4 * 1024 * 1024 });
+                const { stdout, stderr } = await execFileAsync6("git", ["fetch"], { cwd: projectPath, maxBuffer: 4 * 1024 * 1024 });
                 return { success: true, output: (stdout + stderr).trim() };
               } catch (err) {
                 const msg = err instanceof Error ? err.stderr ?? err.message : String(err);
@@ -160894,7 +161719,7 @@ async function runDashboard(port, opts = {}) {
   });
   return { dispose };
 }
-var processDiagnosticsRegistered, diagnosticIntervalHandle, DIAGNOSTIC_INTERVAL_MS, diagnosticStartTime, diagnosticDbHealthCheck, diagnosticStoreListenerCheck, STREAM_LOG_FLUSH_IDLE_MS, StreamedLogBuffer, execFileAsync5, FILES_DENYLIST2, FILE_SIZE_LIMIT, BINARY_CHECK_BYTES, MAX_PREVIEW_LINES;
+var processDiagnosticsRegistered, diagnosticIntervalHandle, DIAGNOSTIC_INTERVAL_MS, diagnosticStartTime, diagnosticDbHealthCheck, diagnosticStoreListenerCheck, STREAM_LOG_FLUSH_IDLE_MS, StreamedLogBuffer, execFileAsync6, FILES_DENYLIST2, FILE_SIZE_LIMIT, BINARY_CHECK_BYTES, MAX_PREVIEW_LINES;
 var init_dashboard = __esm({
   "src/commands/dashboard.ts"() {
     "use strict";
@@ -160973,7 +161798,7 @@ var init_dashboard = __esm({
         }
       }
     };
-    execFileAsync5 = promisify15(execFileCb);
+    execFileAsync6 = promisify15(execFileCb);
     FILES_DENYLIST2 = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next", "target", "build"]);
     FILE_SIZE_LIMIT = 1024 * 1024;
     BINARY_CHECK_BYTES = 8 * 1024;
@@ -161428,7 +162253,7 @@ var serve_exports = {};
 __export(serve_exports, {
   runServe: () => runServe
 });
-import { join as join57 } from "node:path";
+import { join as join58 } from "node:path";
 import {
   AuthStorage as AuthStorage3,
   DefaultPackageManager as DefaultPackageManager3,
@@ -161700,7 +162525,7 @@ async function runServe(port, opts = {}) {
         ...claudeCliPaths
       ],
       cwd,
-      join57(cwd, ".fusion", "disabled-auto-extension-discovery")
+      join58(cwd, ".fusion", "disabled-auto-extension-discovery")
     );
     for (const { path: path5, error } of extensionsResult.errors) {
       console.log(`[extensions] Failed to load ${path5}: ${error}`);
@@ -162037,7 +162862,7 @@ var daemon_exports = {};
 __export(daemon_exports, {
   runDaemon: () => runDaemon
 });
-import { join as join58 } from "node:path";
+import { join as join59 } from "node:path";
 import {
   AuthStorage as AuthStorage4,
   DefaultPackageManager as DefaultPackageManager4,
@@ -162307,7 +163132,7 @@ async function runDaemon(opts = {}) {
     const extensionsResult = await discoverAndLoadExtensions4(
       reconciledExtensionPaths,
       cwd,
-      join58(cwd, ".fusion", "disabled-auto-extension-discovery")
+      join59(cwd, ".fusion", "disabled-auto-extension-discovery")
     );
     for (const { path: path5, error } of extensionsResult.errors) {
       console.log(`[extensions] Failed to load ${path5}: ${error}`);
@@ -162508,13 +163333,13 @@ var desktop_exports = {};
 __export(desktop_exports, {
   runDesktop: () => runDesktop
 });
-import { spawn as spawn13 } from "node:child_process";
+import { spawn as spawn14 } from "node:child_process";
 import { once as once2 } from "node:events";
-import { join as join59 } from "node:path";
+import { join as join60 } from "node:path";
 import { createRequire as createRequire5 } from "node:module";
 function runCommand(command, args, cwd) {
   return new Promise((resolve39, reject2) => {
-    const child = spawn13(command, args, {
+    const child = spawn14(command, args, {
       cwd,
       stdio: "inherit",
       env: process.env
@@ -162589,7 +163414,7 @@ async function runDesktop(options = {}) {
   }
   const runtime = await startDashboardRuntime(rootDir, Boolean(options.paused));
   const electronBinary = resolveElectronBinary();
-  const desktopEntry = join59(rootDir, "packages", "desktop", "dist", "main.js");
+  const desktopEntry = join60(rootDir, "packages", "desktop", "dist", "main.js");
   const electronArgs = ["--enable-source-maps", desktopEntry, ...options.dev ? ["--dev"] : []];
   const electronEnv = {
     ...process.env,
@@ -162599,7 +163424,7 @@ async function runDesktop(options = {}) {
     electronEnv.FUSION_DASHBOARD_URL = process.env.FUSION_DASHBOARD_URL ?? "http://localhost:5173";
     electronEnv.NODE_ENV = "development";
   }
-  const electronProcess = spawn13(electronBinary, electronArgs, {
+  const electronProcess = spawn14(electronBinary, electronArgs, {
     cwd: rootDir,
     stdio: "inherit",
     env: electronEnv
@@ -162674,8 +163499,8 @@ __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 { basename as basename17, join as join60 } from "node:path";
+import { watchFile, unwatchFile, statSync as statSync6, existsSync as existsSync40, readFileSync as readFileSync20 } from "node:fs";
+import { basename as basename17, join as join61 } from "node:path";
 function getGitHubIssueUrl(sourceMetadata) {
   if (!sourceMetadata || typeof sourceMetadata !== "object") return void 0;
   const issueUrl = sourceMetadata.issueUrl;
@@ -162975,8 +163800,8 @@ async function runTaskLogs(id, options = {}, projectName) {
   printEntries(filteredEntries);
   if (options.follow) {
     const projectPath = projectContext?.projectPath ?? process.cwd();
-    const logPath = join60(projectPath, ".fusion", "tasks", id, "agent.log");
-    if (!existsSync39(logPath)) {
+    const logPath = join61(projectPath, ".fusion", "tasks", id, "agent.log");
+    if (!existsSync40(logPath)) {
       console.log(`
   Waiting for log file to be created...`);
     }
@@ -163005,7 +163830,7 @@ async function runTaskLogs(id, options = {}, projectName) {
           lastPosition = 0;
         }
         if (stats.size > lastPosition) {
-          const content = readFileSync19(logPath, "utf-8");
+          const content = readFileSync20(logPath, "utf-8");
           const lines = content.slice(lastPosition).split("\n");
           for (const line of lines) {
             if (!line.trim()) continue;
@@ -164253,7 +165078,7 @@ __export(settings_export_exports, {
   runSettingsExport: () => runSettingsExport
 });
 import { writeFile as writeFile18 } from "node:fs/promises";
-import { resolve as resolve31, join as join61 } from "node:path";
+import { resolve as resolve31, join as join62 } from "node:path";
 async function runSettingsExport(options = {}) {
   const scope = options.scope ?? "both";
   const project = options.projectName ? await resolveProject(options.projectName) : void 0;
@@ -164267,7 +165092,7 @@ async function runSettingsExport(options = {}) {
       targetPath = resolve31(outputPath);
     } else {
       const filename = generateExportFilename();
-      targetPath = join61(process.cwd(), filename);
+      targetPath = join62(process.cwd(), filename);
     }
     const jsonContent = JSON.stringify(exportData, null, 2);
     await writeFile18(targetPath, jsonContent);
@@ -164313,7 +165138,7 @@ var settings_import_exports = {};
 __export(settings_import_exports, {
   runSettingsImport: () => runSettingsImport
 });
-import { existsSync as existsSync40 } from "node:fs";
+import { existsSync as existsSync41 } from "node:fs";
 import { resolve as resolve32 } from "node:path";
 async function runSettingsImport(filePath, options = {}) {
   const scope = options.scope ?? "both";
@@ -164324,7 +165149,7 @@ async function runSettingsImport(filePath, options = {}) {
   const skipConfirm = options.yes ?? false;
   try {
     const resolvedPath = resolve32(filePath);
-    if (!existsSync40(resolvedPath)) {
+    if (!existsSync41(resolvedPath)) {
       console.error(`Error: File not found: ${filePath}`);
       process.exit(1);
     }
@@ -164421,7 +165246,7 @@ __export(git_exports, {
   runGitPush: () => runGitPush,
   runGitStatus: () => runGitStatus
 });
-import { exec as exec10 } from "node:child_process";
+import { exec as exec11 } from "node:child_process";
 import { promisify as promisify16 } from "node:util";
 import { createInterface as createInterface4 } from "node:readline/promises";
 async function resolveGitCwd(projectName) {
@@ -164696,7 +165521,7 @@ var init_git = __esm({
   "src/commands/git.ts"() {
     "use strict";
     init_project_context();
-    execAsync10 = promisify16(exec10);
+    execAsync10 = promisify16(exec11);
   }
 });
 
@@ -164797,7 +165622,7 @@ var init_backup2 = __esm({
 });
 
 // src/project-resolver.ts
-import { existsSync as existsSync41, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync42, statSync as statSync7 } from "node:fs";
 import { basename as basename18, dirname as dirname25, resolve as resolve33, normalize as normalize5 } from "node:path";
 import { createInterface as createInterface5 } from "node:readline/promises";
 async function getCentralCore() {
@@ -164873,7 +165698,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}
 
@@ -164891,7 +165716,7 @@ Run \`fn project remove ` + match.name + "` to clean up the registry entry.",
     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}
 
@@ -164956,7 +165781,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}
 
@@ -165396,8 +166221,8 @@ __export(project_exports, {
   runProjectSetDefault: () => runProjectSetDefault,
   runProjectShow: () => runProjectShow
 });
-import { resolve as resolve34, isAbsolute as isAbsolute18, relative as relative14, basename as basename19 } from "node:path";
-import { existsSync as existsSync42, statSync as statSync8 } from "node:fs";
+import { resolve as resolve34, isAbsolute as isAbsolute19, relative as relative14, basename as basename19 } 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 = relative14(process.cwd(), projectPath);
@@ -165525,8 +166350,8 @@ async function runProjectAdd(name, path5, options = {}) {
         const pathInput = await rl.question(`  Project path [${defaultPath}]: `);
         projectPath = pathInput.trim() || defaultPath;
       }
-      const absolutePath2 = isAbsolute18(projectPath) ? projectPath : resolve34(process.cwd(), projectPath);
-      if (!existsSync42(absolutePath2)) {
+      const absolutePath2 = isAbsolute19(projectPath) ? projectPath : resolve34(process.cwd(), projectPath);
+      if (!existsSync43(absolutePath2)) {
         console.error(`
   \u2717 Path does not exist: ${projectPath}`);
         rl.close();
@@ -165539,7 +166364,7 @@ async function runProjectAdd(name, path5, options = {}) {
         process.exit(1);
       }
       const kbDbPath2 = resolve34(absolutePath2, ".fusion", "fusion.db");
-      if (!existsSync42(kbDbPath2) && !options.force) {
+      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] ");
@@ -165570,8 +166395,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 = isAbsolute18(projectPath) ? projectPath : resolve34(process.cwd(), projectPath);
-    if (!existsSync42(absolutePath)) {
+    const absolutePath = isAbsolute19(projectPath) ? projectPath : resolve34(process.cwd(), projectPath);
+    if (!existsSync43(absolutePath)) {
       console.error(`
   \u2717 Path does not exist: ${projectPath}
 `);
@@ -165584,7 +166409,7 @@ async function runProjectAdd(name, path5, options = {}) {
       process.exit(1);
     }
     const kbDbPath = resolve34(absolutePath, ".fusion", "fusion.db");
-    if (!existsSync42(kbDbPath) && !options.force) {
+    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");
@@ -165840,21 +166665,21 @@ var init_project = __esm({
 });
 
 // src/commands/skill-installation.ts
-import { cpSync as cpSync2, existsSync as existsSync43, mkdirSync as mkdirSync8 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { dirname as dirname26, join as join62, resolve as resolve35 } from "node:path";
+import { cpSync as cpSync2, existsSync as existsSync44, mkdirSync as mkdirSync8 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { dirname as dirname26, join as join63, resolve as resolve35 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
-function getSupportedSkillInstallTargets(homeDir = process.env.HOME || process.env.USERPROFILE || homedir9()) {
+function getSupportedSkillInstallTargets(homeDir = process.env.HOME || process.env.USERPROFILE || homedir10()) {
   return [
-    { client: "claude", targetDir: join62(homeDir, ".claude", "skills", FUSION_SKILL_NAME2) },
-    { client: "codex", targetDir: join62(homeDir, ".codex", "skills", FUSION_SKILL_NAME2) },
-    { client: "gemini", targetDir: join62(homeDir, ".gemini", "skills", FUSION_SKILL_NAME2) }
+    { client: "claude", targetDir: join63(homeDir, ".claude", "skills", FUSION_SKILL_NAME2) },
+    { client: "codex", targetDir: join63(homeDir, ".codex", "skills", FUSION_SKILL_NAME2) },
+    { client: "gemini", targetDir: join63(homeDir, ".gemini", "skills", FUSION_SKILL_NAME2) }
   ];
 }
 function resolveBundledFusionSkillSource() {
   const here = fileURLToPath9(import.meta.url);
   const source = resolve35(dirname26(here), "..", "..", "skill", FUSION_SKILL_NAME2);
-  return existsSync43(source) ? source : null;
+  return existsSync44(source) ? source : null;
 }
 function installBundledFusionSkill(options = {}) {
   const sourceDir = options.sourceDir ?? resolveBundledFusionSkillSource();
@@ -165872,7 +166697,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,
@@ -165911,17 +166736,17 @@ 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 join63, resolve as resolve36, basename as basename20 } from "node:path";
-import { exec as exec11 } from "node:child_process";
+import { existsSync as existsSync45, mkdirSync as mkdirSync9, writeFileSync as writeFileSync3, readFileSync as readFileSync21 } from "node:fs";
+import { join as join64, resolve as resolve36, basename as basename20 } from "node:path";
+import { exec as exec12 } from "node:child_process";
 import { promisify as promisify17 } from "node:util";
 async function runInit(options = {}) {
   const cwd = options.path ? resolve36(options.path) : process.cwd();
-  const fusionDir = join63(cwd, ".fusion");
-  const dbPath = join63(fusionDir, "fusion.db");
-  const hasDbPath = existsSync44(dbPath);
+  const fusionDir = join64(cwd, ".fusion");
+  const dbPath = join64(fusionDir, "fusion.db");
+  const hasDbPath = existsSync45(dbPath);
   const hasValidDb = hasDbPath && isValidSqliteDatabaseFile(dbPath);
-  if (existsSync44(fusionDir) && hasDbPath && hasValidDb) {
+  if (existsSync45(fusionDir) && hasDbPath && hasValidDb) {
     const central2 = new CentralCore();
     await central2.init();
     const existing = await central2.getProjectByPath(cwd);
@@ -165943,7 +166768,7 @@ async function runInit(options = {}) {
     await central2.close();
     return;
   }
-  if (existsSync44(fusionDir) && hasDbPath && !hasValidDb) {
+  if (existsSync45(fusionDir) && hasDbPath && !hasValidDb) {
     throw new Error(
       `Existing database at ${dbPath} is not a valid SQLite database. Restore it from .fusion/backups or move it aside before re-running fn init.`
     );
@@ -165951,7 +166776,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`);
   }
@@ -165964,7 +166789,7 @@ async function runInit(options = {}) {
   }
   await addLocalStorageToGitignore(cwd);
   await warnIfQmdMissing();
-  if (!existsSync44(dbPath)) {
+  if (!existsSync45(dbPath)) {
     writeFileSync3(dbPath, "");
     console.log(`  \u2713 Created fusion.db`);
   }
@@ -166014,7 +166839,7 @@ async function runInit(options = {}) {
   }
 }
 async function detectProjectName(dir2) {
-  if (!existsSync44(join63(dir2, ".git"))) {
+  if (!existsSync45(join64(dir2, ".git"))) {
     return basename20(dir2) || "my-project";
   }
   try {
@@ -166034,11 +166859,11 @@ async function detectProjectName(dir2) {
   return basename20(dir2) || "my-project";
 }
 async function addLocalStorageToGitignore(cwd) {
-  const gitignorePath = join63(cwd, ".gitignore");
+  const gitignorePath = join64(cwd, ".gitignore");
   let content = "";
-  if (existsSync44(gitignorePath)) {
+  if (existsSync45(gitignorePath)) {
     try {
-      content = readFileSync20(gitignorePath, "utf-8");
+      content = readFileSync21(gitignorePath, "utf-8");
     } catch {
     }
   }
@@ -166077,8 +166902,8 @@ async function initializeGitRepo(cwd) {
   }
   await ensureGitConfig(cwd, "user.name", "Fusion");
   await ensureGitConfig(cwd, "user.email", "noreply@runfusion.ai");
-  const gitkeepPath = join63(cwd, ".gitkeep");
-  if (!existsSync44(gitkeepPath)) {
+  const gitkeepPath = join64(cwd, ".gitkeep");
+  if (!existsSync45(gitkeepPath)) {
     writeFileSync3(gitkeepPath, "\n");
   }
   await execAsync11("git add .gitkeep", { cwd, timeout: 1e4 });
@@ -166129,7 +166954,7 @@ var init_init = __esm({
     init_claude_skills_runner();
     init_git();
     init_skill_installation();
-    execAsync11 = promisify17(exec11);
+    execAsync11 = promisify17(exec12);
   }
 });
 
@@ -166216,7 +167041,7 @@ 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 { existsSync as existsSync46, mkdirSync as mkdirSync10, readFileSync as readFileSync22, statSync as statSync9, writeFileSync as writeFileSync4 } from "node:fs";
 import { resolve as resolve37 } from "node:path";
 function slugifyPathSegment(input) {
   if (!input || typeof input !== "string") {
@@ -166275,7 +167100,7 @@ async function importSkillsToProject(projectPath, skills, companySlug, dryRun) {
     const skillSlug = slugifyPathSegment(skill.name);
     const skillDir = resolve37(baseSkillsDir, skillSlug);
     const skillPath = resolve37(skillDir, "SKILL.md");
-    if (existsSync45(skillPath)) {
+    if (existsSync46(skillPath)) {
       result.skipped.push(skill.name);
       continue;
     }
@@ -166348,7 +167173,7 @@ async function runAgentImport(source, options) {
   const dryRun = options?.dryRun ?? false;
   const skipExisting = options?.skipExisting ?? false;
   const sourcePath = resolve37(source);
-  if (!existsSync45(sourcePath)) {
+  if (!existsSync46(sourcePath)) {
     console.error(`Path not found: ${sourcePath}`);
     process.exit(1);
   }
@@ -166394,7 +167219,7 @@ async function runAgentImport(source, options) {
       isPackageImport = true;
       ({ items: importItems, result } = prepareAgentCompaniesImport(pkg, conversionOptions));
     } else if (sourcePath.endsWith(".md")) {
-      const content = readFileSync21(sourcePath, "utf-8");
+      const content = readFileSync22(sourcePath, "utf-8");
       const { manifest } = parseSingleAgentManifest(content);
       const pkg = {
         company: void 0,
@@ -166743,8 +167568,8 @@ __export(plugin_exports, {
   runPluginList: () => runPluginList,
   runPluginUninstall: () => runPluginUninstall
 });
-import { existsSync as existsSync46 } from "node:fs";
-import { join as join64 } from "node:path";
+import { existsSync as existsSync47 } from "node:fs";
+import { join as join65 } from "node:path";
 import { readFile as readFile23 } from "node:fs/promises";
 import * as readline from "node:readline";
 async function getProjectPath6(projectName) {
@@ -166782,8 +167607,8 @@ async function createPluginLoader(pluginStore, projectName) {
   return { store: pluginStore, loader };
 }
 async function loadManifestFromPath(pluginPath) {
-  const manifestPath = join64(pluginPath, "manifest.json");
-  if (!existsSync46(manifestPath)) {
+  const manifestPath = join65(pluginPath, "manifest.json");
+  if (!existsSync47(manifestPath)) {
     throw new Error(`Plugin manifest not found at: ${manifestPath}`);
   }
   const content = await readFile23(manifestPath, "utf-8");
@@ -166841,7 +167666,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);
   }
@@ -166973,8 +167798,8 @@ var plugin_scaffold_exports = {};
 __export(plugin_scaffold_exports, {
   runPluginCreate: () => runPluginCreate
 });
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync5, existsSync as existsSync47 } from "node:fs";
-import { join as join65 } from "node:path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync5, existsSync as existsSync48 } from "node:fs";
+import { join as join66 } from "node:path";
 function toTitleCase(str) {
   return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
@@ -167107,24 +167932,24 @@ async function runPluginCreate(name, options) {
     process.exit(1);
   }
   const targetDir = options?.output ?? name;
-  const targetPath = join65(process.cwd(), targetDir);
-  if (existsSync47(targetPath)) {
+  const targetPath = join66(process.cwd(), targetDir);
+  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);
   }
   try {
     mkdirSync11(targetPath, { recursive: true });
-    mkdirSync11(join65(targetPath, "src", "__tests__"), { recursive: true });
-    writeFileSync5(join65(targetPath, "package.json"), generatePackageJson(name));
-    writeFileSync5(join65(targetPath, "tsconfig.json"), generateTsconfig());
-    writeFileSync5(join65(targetPath, "vitest.config.ts"), generateVitestConfig());
-    writeFileSync5(join65(targetPath, "src", "index.ts"), generateIndexTs(name));
+    mkdirSync11(join66(targetPath, "src", "__tests__"), { recursive: true });
+    writeFileSync5(join66(targetPath, "package.json"), generatePackageJson(name));
+    writeFileSync5(join66(targetPath, "tsconfig.json"), generateTsconfig());
+    writeFileSync5(join66(targetPath, "vitest.config.ts"), generateVitestConfig());
+    writeFileSync5(join66(targetPath, "src", "index.ts"), generateIndexTs(name));
     writeFileSync5(
-      join65(targetPath, "src", "__tests__", "index.test.ts"),
+      join66(targetPath, "src", "__tests__", "index.test.ts"),
       generateTestTs(name)
     );
-    writeFileSync5(join65(targetPath, "README.md"), generateReadme(name));
+    writeFileSync5(join66(targetPath, "README.md"), generateReadme(name));
   } catch (err) {
     console.error(
       `Error creating plugin files: ${err instanceof Error ? err.message : String(err)}`
@@ -167158,7 +167983,7 @@ __export(skills_exports, {
   runSkillsSearch: () => runSkillsSearch,
   searchSkills: () => searchSkills
 });
-import { spawn as spawn14 } from "node:child_process";
+import { spawn as spawn15 } from "node:child_process";
 async function searchSkills(query, limit = 10) {
   const url = `${SKILLS_API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`;
   try {
@@ -167236,7 +168061,7 @@ async function runSkillsInstall(args, options) {
     npxArgs.push("--skill", options.skill);
   }
   npxArgs.push("-y", "-a", "pi");
-  const child = spawn14("npx", npxArgs, {
+  const child = spawn15("npx", npxArgs, {
     cwd: process.cwd(),
     stdio: "inherit",
     shell: true
@@ -167274,21 +168099,21 @@ __export(native_patch_exports, {
   isTerminalAvailable: () => isTerminalAvailable,
   setupNativeResolution: () => setupNativeResolution
 });
-import { join as join66, basename as basename21, dirname as dirname27 } 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 join67, basename as basename21, dirname as dirname27 } 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";
   const arch = process.arch === "arm64" ? "arm64" : process.arch === "x64" ? "x64" : "unknown";
   const prebuildName = `${platform3}-${arch}`;
   const execDir = dirname27(process.execPath);
-  const nextToBinary = join66(execDir, "runtime", prebuildName);
-  if (existsSync48(join66(nextToBinary, "pty.node"))) {
+  const nextToBinary = join67(execDir, "runtime", prebuildName);
+  if (existsSync49(join67(nextToBinary, "pty.node"))) {
     return nextToBinary;
   }
   if (process.env.FUSION_RUNTIME_DIR) {
-    const envPath = join66(process.env.FUSION_RUNTIME_DIR, prebuildName);
-    if (existsSync48(join66(envPath, "pty.node"))) {
+    const envPath = join67(process.env.FUSION_RUNTIME_DIR, prebuildName);
+    if (existsSync49(join67(envPath, "pty.node"))) {
       return envPath;
     }
   }
@@ -167298,11 +168123,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");
         }
@@ -167321,23 +168146,23 @@ function setupNativeResolution() {
     process.env.NODE_PTY_SPAWN_HELPER_DIR = nativeDir;
   }
   process.env.FUSION_NATIVE_ASSETS_PATH = nativeDir;
-  const tmpRoot = join66(tmpdir4(), `fn-bunfs-${process.pid}`);
-  const fnDir = join66(tmpRoot, "fn");
-  const prebuildsDir = join66(fnDir, "prebuilds");
-  const platformDir = join66(prebuildsDir, basename21(nativeDir));
+  const tmpRoot = join67(tmpdir4(), `fn-bunfs-${process.pid}`);
+  const fnDir = join67(tmpRoot, "fn");
+  const prebuildsDir = join67(fnDir, "prebuilds");
+  const platformDir = join67(prebuildsDir, basename21(nativeDir));
   try {
     cleanupStaleBunfsLinks();
     mkdirSync12(platformDir, { recursive: true });
-    const ptyNodeDest = join66(platformDir, "pty.node");
-    copyFileSync(join66(nativeDir, "pty.node"), ptyNodeDest);
-    if (existsSync48(join66(nativeDir, "spawn-helper"))) {
-      copyFileSync(join66(nativeDir, "spawn-helper"), join66(platformDir, "spawn-helper"));
+    const ptyNodeDest = join67(platformDir, "pty.node");
+    copyFileSync(join67(nativeDir, "pty.node"), ptyNodeDest);
+    if (existsSync49(join67(nativeDir, "spawn-helper"))) {
+      copyFileSync(join67(nativeDir, "spawn-helper"), join67(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);
@@ -167360,7 +168185,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);
@@ -167406,9 +168231,9 @@ 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 readFileSync23, symlinkSync as symlinkSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
-import { join as join67, dirname as dirname28 } from "node:path";
+import { join as join68, dirname as dirname28 } from "node:path";
 import { tmpdir as tmpdir5 } from "node:os";
 import { performance as performance3 } from "node:perf_hooks";
 var isBunBinary3 = typeof Bun !== "undefined" && !!Bun.embeddedFiles;
@@ -167416,7 +168241,7 @@ function configurePiPackage() {
   if (process.env.PI_PACKAGE_DIR) {
     return;
   }
-  const tmp = mkdtempSync2(join67(tmpdir5(), "fn-pkg-"));
+  const tmp = mkdtempSync2(join68(tmpdir5(), "fn-pkg-"));
   let packageJson = {
     name: "pi",
     version: "0.1.0",
@@ -167426,11 +168251,11 @@ function configurePiPackage() {
     const require4 = createRequire6(import.meta.url);
     const piPackagePath = require4.resolve("@mariozechner/pi-coding-agent/package.json");
     const piPackageDir = dirname28(piPackagePath);
-    packageJson = JSON.parse(readFileSync22(piPackagePath, "utf-8"));
+    packageJson = JSON.parse(readFileSync23(piPackagePath, "utf-8"));
     for (const entry of ["dist", "docs", "examples", "README.md", "CHANGELOG.md"]) {
-      const source = join67(piPackageDir, entry);
-      if (existsSync49(source)) {
-        symlinkSync3(source, join67(tmp, entry));
+      const source = join68(piPackageDir, entry);
+      if (existsSync50(source)) {
+        symlinkSync3(source, join68(tmp, entry));
       }
     }
   } catch {
@@ -167439,7 +168264,7 @@ function configurePiPackage() {
     ...packageJson.piConfig ?? {},
     configDir: ".fusion"
   };
-  writeFileSync6(join67(tmp, "package.json"), JSON.stringify(packageJson, null, 2) + "\n");
+  writeFileSync6(join68(tmp, "package.json"), JSON.stringify(packageJson, null, 2) + "\n");
   process.env.PI_PACKAGE_DIR = tmp;
 }
 configurePiPackage();
@@ -167448,8 +168273,8 @@ setInterval(() => {
   performance3.clearMarks();
 }, 3e4).unref();
 function loadEnvFile(path5) {
-  if (!existsSync49(path5)) return;
-  const contents = readFileSync22(path5, "utf-8");
+  if (!existsSync50(path5)) return;
+  const contents = readFileSync23(path5, "utf-8");
   for (const rawLine of contents.split(/\r?\n/)) {
     const line = rawLine.trim();
     if (!line || line.startsWith("#")) continue;
@@ -167467,8 +168292,8 @@ function loadEnvFile(path5) {
 }
 function loadLocalEnv() {
   const cwd = process.cwd();
-  loadEnvFile(join67(cwd, ".env"));
-  loadEnvFile(join67(cwd, ".env.local"));
+  loadEnvFile(join68(cwd, ".env"));
+  loadEnvFile(join68(cwd, ".env.local"));
 }
 loadLocalEnv();
 async function loadCommandHandlers() {