@runfusion/fusion 0.9.4 → 0.10.0

package/dist/extension.js

@@ -1382,6 +1382,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
@@ -1527,7 +1547,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.
@@ -18108,10 +18138,10 @@ var init_central_core = __esm({
        */
       async generateProjectName(projectPath) {
         try {
-          const { execFile: execFile6 } = await import("node:child_process");
+          const { execFile: execFile7 } = await import("node:child_process");
           const { promisify: promisify13 } = await import("node:util");
-          const execFileAsync4 = promisify13(execFile6);
-          const { stdout } = await execFileAsync4(
+          const execFileAsync5 = promisify13(execFile7);
+          const { stdout } = await execFileAsync5(
             "git",
             ["remote", "get-url", "origin"],
             { cwd: projectPath, timeout: 5e3 }
@@ -18621,7 +18651,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() {
@@ -18758,10 +18788,10 @@ var init_migration = __esm({
           return basename3(projectPath);
         }
         try {
-          const { execFile: execFile6 } = await import("node:child_process");
+          const { execFile: execFile7 } = await import("node:child_process");
           const { promisify: promisify13 } = await import("node:util");
-          const execFileAsync4 = promisify13(execFile6);
-          const { stdout } = await execFileAsync4(
+          const execFileAsync5 = promisify13(execFile7);
+          const { stdout } = await execFileAsync5(
             "git",
             ["remote", "get-url", "origin"],
             { cwd: projectPath, timeout: 1e3 }
@@ -18773,8 +18803,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.
        *
@@ -28227,8 +28275,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static parseFileSync(filePath) {
-        const { readFileSync: readFileSync9 } = __require("fs");
-        const data = readFileSync9(filePath, "utf8");
+        const { readFileSync: readFileSync10 } = __require("fs");
+        const data = readFileSync10(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -29491,13 +29539,13 @@ async function searchWithQmd(rootDir, options) {
   const command = "qmd";
   const limit = Math.max(1, Math.min(options.limit ?? 5, 20));
   try {
-    const { execFile: execFile6 } = await import("node:child_process");
+    const { execFile: execFile7 } = await import("node:child_process");
     const { promisify: promisify13 } = await import("node:util");
-    const execFileAsync4 = promisify13(execFile6);
-    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync4);
+    const execFileAsync5 = promisify13(execFile7);
+    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync5);
     scheduleQmdProjectMemoryRefresh(rootDir);
     const args = buildQmdSearchArgs(rootDir, options);
-    const { stdout } = await execFileAsync4(command, args, {
+    const { stdout } = await execFileAsync5(command, args, {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 1024 * 1024
@@ -29522,12 +29570,12 @@ async function searchWithQmd(rootDir, options) {
     return [];
   }
 }
-async function ensureQmdProjectMemoryCollection(rootDir, execFileAsync4) {
+async function ensureQmdProjectMemoryCollection(rootDir, execFileAsync5) {
   const collectionName = qmdMemoryCollectionName(rootDir);
   const memoryDir = memoryWorkspacePath(rootDir);
   await mkdir6(memoryDir, { recursive: true });
   try {
-    await execFileAsync4("qmd", buildQmdCollectionAddArgs(rootDir), {
+    await execFileAsync5("qmd", buildQmdCollectionAddArgs(rootDir), {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 512 * 1024
@@ -29543,9 +29591,9 @@ ${stderr}`)) {
   return collectionName;
 }
 async function getDefaultExecFileAsync() {
-  const { execFile: execFile6 } = await import("node:child_process");
+  const { execFile: execFile7 } = await import("node:child_process");
   const { promisify: promisify13 } = await import("node:util");
-  return promisify13(execFile6);
+  return promisify13(execFile7);
 }
 async function refreshQmdProjectMemoryIndex(rootDir, options) {
   const key = resolve6(rootDir);
@@ -29560,14 +29608,14 @@ async function refreshQmdProjectMemoryIndex(rootDir, options) {
     }
   }
   const promise = (async () => {
-    const execFileAsync4 = options?.execFileAsync ?? await getDefaultExecFileAsync();
-    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync4);
-    await execFileAsync4("qmd", ["update"], {
+    const execFileAsync5 = options?.execFileAsync ?? await getDefaultExecFileAsync();
+    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync5);
+    await execFileAsync5("qmd", ["update"], {
       cwd: rootDir,
       timeout: 3e4,
       maxBuffer: 1024 * 1024
     });
-    await execFileAsync4("qmd", ["embed"], {
+    await execFileAsync5("qmd", ["embed"], {
       cwd: rootDir,
       timeout: 12e4,
       maxBuffer: 1024 * 1024
@@ -29592,8 +29640,8 @@ function scheduleQmdProjectMemoryRefresh(rootDir) {
 }
 async function isQmdAvailable() {
   try {
-    const execFileAsync4 = await getDefaultExecFileAsync();
-    await execFileAsync4("qmd", ["--help"], {
+    const execFileAsync5 = await getDefaultExecFileAsync();
+    await execFileAsync5("qmd", ["--help"], {
       timeout: 3e3,
       maxBuffer: 128 * 1024
     });
@@ -29603,12 +29651,12 @@ async function isQmdAvailable() {
   }
 }
 async function installQmd(options) {
-  const execFileAsync4 = options?.execFileAsync ?? await getDefaultExecFileAsync();
+  const execFileAsync5 = 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 execFileAsync4(command, args, {
+  await execFileAsync5(command, args, {
     timeout: 12e4,
     maxBuffer: 1024 * 1024
   });
@@ -30403,8 +30451,8 @@ function assertSafeGitBranchName(name) {
   }
 }
 function assertSafeAbsolutePath(path2) {
-  const isAbsolute13 = path2.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path2);
-  if (!path2 || path2.length > 4096 || !isAbsolute13 || path2.startsWith("-") || // Reject shell metacharacters, quotes, control chars, and NULs.
+  const isAbsolute14 = path2.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path2);
+  if (!path2 || path2.length > 4096 || !isAbsolute14 || path2.startsWith("-") || // Reject shell metacharacters, quotes, control chars, and NULs.
   /["'`$\n\r\t;&|<>()*?[\]{}\\\0]/.test(
     path2.replace(/^[A-Za-z]:/, "")
     // ignore the drive-letter colon on Windows
@@ -32529,7 +32577,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 dir = this.taskDir(id);
           let task;
@@ -32580,12 +32628,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(dir);
+            if (!options?.preserveResumeState) {
+              task.worktree = void 0;
+              task.executionStartedAt = void 0;
+              task.executionCompletedAt = void 0;
+              this.resetAllStepsToPending(task);
+              await this.resetPromptCheckboxes(dir);
+            } else {
+              task.executionCompletedAt = void 0;
+            }
           }
           if (toColumn === "in-review") {
             task.recoveryRetryCount = void 0;
@@ -32984,6 +33036,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(dir, 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") {
@@ -35398,7 +35463,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) {
@@ -35443,7 +35508,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") };
     }
@@ -35523,7 +35588,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 {
@@ -35553,7 +35618,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 {};
     }
@@ -43690,8 +43755,8 @@ var require_YAMLMap = __commonJS({
        * @param {Class} Type - If set, forces the returned collection type
        * @returns Instance of Type, Map, or Object
        */
-      toJSON(_, ctx, Type8) {
-        const map = Type8 ? new Type8() : ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {};
+      toJSON(_, ctx, Type9) {
+        const map = Type9 ? new Type9() : ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {};
         if (ctx?.onCreate)
           ctx.onCreate(map);
         for (const item of this.items)
@@ -48914,7 +48979,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) {
@@ -49132,7 +49197,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}`);
@@ -49229,12 +49294,12 @@ function resolveExtractionRoot(tempDir) {
   return tempDir;
 }
 async function extractTarArchive(archivePath, outputDir) {
-  const [{ execFile: execFile6 }, { promisify: promisify13 }] = await Promise.all([
+  const [{ execFile: execFile7 }, { promisify: promisify13 }] = await Promise.all([
     import("node:child_process"),
     import("node:util")
   ]);
-  const execFileAsync4 = promisify13(execFile6);
-  await execFileAsync4("tar", ["xzf", archivePath, "-C", outputDir]);
+  const execFileAsync5 = promisify13(execFile7);
+  await execFileAsync5("tar", ["xzf", archivePath, "-C", outputDir]);
 }
 async function parseCompanyArchive(archivePath) {
   const resolvedArchivePath = resolve9(archivePath);
@@ -50846,11 +50911,11 @@ async function refreshAgentMemoryQmdIndex(rootDir, agentMemory) {
     return;
   }
   const promise = (async () => {
-    const { execFile: execFile6 } = await import("node:child_process");
+    const { execFile: execFile7 } = await import("node:child_process");
     const { promisify: promisify13 } = await import("node:util");
-    const execFileAsync4 = promisify13(execFile6);
+    const execFileAsync5 = promisify13(execFile7);
     try {
-      await execFileAsync4("qmd", buildQmdAgentMemoryCollectionAddArgs(rootDir, agentMemory.agentId), {
+      await execFileAsync5("qmd", buildQmdAgentMemoryCollectionAddArgs(rootDir, agentMemory.agentId), {
         cwd: rootDir,
         timeout: 4e3,
         maxBuffer: 512 * 1024
@@ -50863,8 +50928,8 @@ ${stderr}`)) {
         throw error;
       }
     }
-    await execFileAsync4("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
-    await execFileAsync4("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync5("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync5("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
   })();
   agentQmdRefreshState.set(key, { lastStartedAt: now, inFlight: promise });
   try {
@@ -50885,10 +50950,10 @@ async function searchAgentMemoryWithQmd(rootDir, agentMemory, query, limit) {
   }
   try {
     await refreshAgentMemoryQmdIndex(rootDir, agentMemory);
-    const { execFile: execFile6 } = await import("node:child_process");
+    const { execFile: execFile7 } = await import("node:child_process");
     const { promisify: promisify13 } = await import("node:util");
-    const execFileAsync4 = promisify13(execFile6);
-    const { stdout } = await execFileAsync4("qmd", buildQmdAgentMemorySearchArgs(rootDir, agentMemory.agentId, query, limit), {
+    const execFileAsync5 = promisify13(execFile7);
+    const { stdout } = await execFileAsync5("qmd", buildQmdAgentMemorySearchArgs(rootDir, agentMemory.agentId, query, limit), {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 1024 * 1024
@@ -51702,14 +51767,14 @@ var init_concurrency = __esm({
 });
 
 // ../engine/src/skill-resolver.ts
-import { existsSync as existsSync19, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync5 } from "node:fs";
 import { join as join23 } from "node:path";
 function readJsonObject(path2) {
   if (!existsSync19(path2)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync4(path2, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(path2, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -51938,7 +52003,7 @@ var init_context_limit_detector = __esm({
 });
 
 // ../engine/src/auth-storage.ts
-import { existsSync as existsSync20, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync6 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { join as join24 } from "node:path";
 import { AuthStorage } from "@mariozechner/pi-coding-agent";
@@ -51978,7 +52043,7 @@ function readLegacyCredentials(authPaths = getLegacyAuthPaths()) {
       continue;
     }
     try {
-      const parsed = JSON.parse(readFileSync5(authPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync6(authPath, "utf-8"));
       for (const [provider, credential] of Object.entries(parsed)) {
         credentials[provider] ??= credential;
       }
@@ -52050,13 +52115,13 @@ var init_auth_storage = __esm({
 });
 
 // ../engine/src/custom-providers.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } 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 = readFileSync6(settingsPath, "utf-8");
+    const raw = readFileSync7(settingsPath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.customProviders) ? parsed.customProviders : [];
   } catch {
@@ -52070,7 +52135,7 @@ var init_custom_providers = __esm({
 });
 
 // ../engine/src/pi.ts
-import { existsSync as existsSync21, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync8 } from "node:fs";
 import { exec } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 import { createRequire as createRequire2 } from "node:module";
@@ -52332,7 +52397,7 @@ function readJsonObject2(path2) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync7(path2, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(path2, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -52504,7 +52569,7 @@ function resolveVendoredClaudeCliEntry() {
   try {
     const require_ = createRequire2(import.meta.url);
     const pkgJsonPath = require_.resolve("@fusion/pi-claude-cli/package.json");
-    const pkgJson = JSON.parse(readFileSync7(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(readFileSync8(pkgJsonPath, "utf-8"));
     const extensions = pkgJson.pi?.extensions;
     if (!Array.isArray(extensions) || extensions.length === 0) return null;
     const entry = extensions[0];
@@ -54327,9 +54392,9 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
     return { attachmentContents, imageContents };
   }
   const { readFile: readFile19 } = await import("node:fs/promises");
-  const { join: join41 } = await import("node:path");
+  const { join: join42 } = await import("node:path");
   for (const att of attachments) {
-    const filePath = join41(
+    const filePath = join42(
       rootDir,
       ".fusion",
       "tasks",
@@ -55867,9 +55932,9 @@ Remove or replace these ids and call fn_task_create again.`
             }
             try {
               const { readFile: readFile19 } = await import("node:fs/promises");
-              const { join: join41 } = await import("node:path");
+              const { join: join42 } = await import("node:path");
               const promptContent = await readFile19(
-                join41(rootDir, promptPath),
+                join42(rootDir, promptPath),
                 "utf-8"
               ).catch((err) => {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -60079,6 +60144,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(dir) {
   try {
     await execAsync3("git rev-parse --git-dir", {
@@ -60094,10 +60167,11 @@ async function isGitRepository(dir) {
 }
 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 ")) {
@@ -60249,10 +60323,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);
@@ -61388,13 +61463,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((resolve19) => {
+    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}`
+        );
+      }
+      resolve19({
+        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}`);
+      resolve19({
+        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: log17 } = 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);
+        log17.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);
+        log17.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);
+          log17.warn(`[fn_run_verification] ${taskId}: ${msg}`);
+          effectiveCommand = `${installCmd} && ${command}`;
+        }
+      }
+      log17.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");
+      log17.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;
@@ -61627,6 +61993,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 = [
@@ -61669,6 +62075,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);
@@ -61681,38 +62088,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."
         })
       )
@@ -61725,6 +62132,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
@@ -61890,6 +62317,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
@@ -62346,7 +62783,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";
@@ -62359,7 +62796,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
@@ -62377,11 +62818,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 {
@@ -62413,7 +62854,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 {
@@ -62551,7 +62992,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 });
@@ -62560,7 +63001,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 {
@@ -62712,7 +63153,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;
           }
         }
@@ -62763,7 +63204,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) {
@@ -62810,7 +63251,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;
@@ -62833,8 +63274,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)) {
@@ -62847,8 +63288,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) {
@@ -62970,6 +63411,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,
@@ -63040,7 +63484,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)) {
@@ -63124,7 +63568,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);
@@ -63142,7 +63586,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 });
@@ -63201,7 +63645,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) {
@@ -63243,6 +63687,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)
@@ -63272,11 +63727,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);
             },
@@ -63294,7 +63751,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");
@@ -63429,7 +63886,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;
               }
@@ -63493,6 +63950,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();
@@ -63532,15 +64002,38 @@ Lint, tests, and typecheck are also hard quality gates:
                     lastModelId: detail.modelId
                   });
                   stuckDetector?.trackTask(task.id, retrySession);
-                  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(retrySession, retryPrompt);
                   checkSessionError(retrySession);
@@ -63677,7 +64170,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}`);
@@ -63747,9 +64240,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}`);
@@ -63772,7 +64266,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}`);
@@ -63827,7 +64321,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}`);
@@ -63874,19 +64368,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: {}
             };
@@ -63981,8 +64495,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)"
             }))
           }),
@@ -64288,7 +64802,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");
@@ -64374,7 +64888,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(
@@ -64401,7 +64915,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
         );
       }
       /**
@@ -64410,7 +64925,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");
@@ -65194,7 +65709,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;
@@ -65214,7 +65729,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
        */
       async tryCreateWorktree(branch, path2, taskId, startPoint, attemptNumber = 0, recoveryDepth = 0) {
         await this.assertWorktreePathNotNested(path2, taskId);
-        if (existsSync26(path2)) {
+        if (existsSync27(path2)) {
           const isRegistered = await this.isRegisteredWorktree(path2);
           if (!isRegistered) {
             await this.store.logEntry(
@@ -65364,7 +65879,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 {
@@ -65412,7 +65927,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`,
@@ -65656,6 +66171,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,
@@ -65901,7 +66479,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");
@@ -66089,9 +66667,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;
@@ -66261,12 +66839,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 {
@@ -66388,7 +66966,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.
@@ -68343,7 +68921,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"() {
@@ -68654,7 +69232,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()) {
@@ -68693,7 +69271,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;
 }
@@ -68897,8 +69475,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;
@@ -71563,7 +72141,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));
@@ -71692,7 +72270,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)];
@@ -71702,7 +72280,7 @@ var init_local_docs_provider = __esm({
         const entries = await fs.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
           this.throwIfAborted(signal);
-          const fullPath = join35(dir, entry.name);
+          const fullPath = join36(dir, entry.name);
           const relPath = relative7(this.projectRoot, fullPath).replace(/\\/g, "/");
           if (matchesGitignore(relPath, ignorePatterns)) continue;
           if (entry.isDirectory()) {
@@ -71727,7 +72305,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 [];
@@ -73243,7 +73821,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((resolve19, reject) => {
+    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;
+        reject(errWithOutput);
+        return;
+      }
+      resolve19({ stdout: stdoutText, stderr: stderrText });
+    });
+  });
+}
 async function createAiPromptExecutor(cwd) {
   const disposeLog = createLogger2("cron-runner");
   return async (prompt, modelProvider, modelId) => {
@@ -73271,17 +73864,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";
@@ -73289,7 +73884,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;
@@ -73433,7 +74027,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
@@ -73550,7 +74144,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
@@ -73623,8 +74217,9 @@ var init_cron_runner = __esm({
             setTimeout(() => reject(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,
@@ -73721,7 +74316,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) {
@@ -73734,7 +74329,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";
@@ -73742,7 +74337,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;
@@ -73897,7 +74492,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
@@ -74596,9 +75191,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, "'\\''")}'`;
 }
@@ -74632,7 +75227,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";
@@ -74640,7 +75235,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"]);
@@ -74845,12 +75440,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 }
           );
@@ -74898,11 +75493,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 }
             );
@@ -74910,7 +75505,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
                 });
@@ -74931,7 +75526,7 @@ var init_self_healing = __esm({
             `--grep=${grepArg}`,
             shellQuote(range)
           ].join(" ");
-          return execAsync8(command, {
+          return execAsync7(command, {
             cwd: this.options.rootDir,
             maxBuffer: 1024 * 1024
           });
@@ -74971,7 +75566,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
           });
@@ -74985,9 +75580,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
             });
@@ -75000,7 +75595,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
           });
@@ -75595,7 +76190,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;
           });
@@ -75604,7 +76199,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, {
@@ -75750,9 +76345,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
             });
@@ -75767,7 +76362,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
           });
@@ -75775,7 +76370,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 }
           );
@@ -75875,7 +76470,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
           });
@@ -75908,7 +76503,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
               });
@@ -75935,11 +76530,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;
@@ -75950,7 +76545,7 @@ var init_self_healing = __esm({
         let cleaned = 0;
         for (const path2 of unregistered) {
           const rel = relative8(worktreesDir, path2);
-          if (rel === "" || rel.startsWith("..") || isAbsolute12(rel)) {
+          if (rel === "" || rel.startsWith("..") || isAbsolute13(rel)) {
             log16.warn(`Refusing to remove path outside .worktrees: ${path2}`);
             continue;
           }
@@ -75988,7 +76583,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
               });
@@ -76001,7 +76596,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
                 });
@@ -76044,8 +76639,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;
@@ -76069,7 +76664,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
               });
@@ -76092,7 +76687,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"() {
@@ -76407,7 +77002,7 @@ var init_plugin_runner = __esm({
               };
             }
           };
-          const anySchema = Type6.Any();
+          const anySchema = Type7.Any();
           return {
             name: `plugin_${pluginTool.name}`,
             label: pluginTool.name,
@@ -77706,7 +78301,7 @@ var init_ipc_host = __esm({
 import { EventEmitter as EventEmitter20 } from "node:events";
 import { fork } from "node:child_process";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { dirname as 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"() {
@@ -77868,7 +78463,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.
@@ -79339,7 +79934,8 @@ var init_provider_adapters = __esm({
 
 // ../engine/src/remote-access/tunnel-process-manager.ts
 import { EventEmitter as EventEmitter23 } 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();
 }
@@ -79379,7 +79975,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";
@@ -79387,6 +79983,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) {
@@ -79427,7 +80025,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 };
@@ -79458,6 +80056,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;
@@ -79740,7 +80383,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) {
@@ -79752,7 +80395,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";
@@ -79769,7 +80412,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 {
@@ -80173,6 +80816,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();
@@ -80382,7 +81049,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 {
@@ -83744,7 +84411,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) {
@@ -83854,7 +84521,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
     });
@@ -84067,7 +84734,7 @@ var init_dist = __esm({
 });
 
 // ../../plugins/fusion-plugin-openclaw-runtime/dist/pi-module.js
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import { randomUUID as randomUUID12 } from "node:crypto";
 function asString(v) {
   return typeof v === "string" && v.trim() !== "" ? v.trim() : void 0;
@@ -84144,7 +84811,7 @@ async function promptCli(session, message, config, callbacks, signal) {
   cb.onToolStart?.("openclaw.agent", { sessionId: session.sessionId });
   return new Promise((resolve19, reject) => {
     let settled = false;
-    const child = spawn5(config.binaryPath, args, {
+    const child = spawn6(config.binaryPath, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const hardKill = setTimeout(() => {
@@ -84295,7 +84962,7 @@ var init_runtime_adapter2 = __esm({
 });
 
 // ../../plugins/fusion-plugin-openclaw-runtime/dist/probe.js
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 async function probeOpenClawBinary(opts = {}) {
   const startedAt = Date.now();
   const binary = opts.binaryPath ?? "openclaw";
@@ -84306,7 +84973,7 @@ async function probeOpenClawBinary(opts = {}) {
       resolvePromise({ ...partial, probeDurationMs: Date.now() - startedAt });
     };
     let settled = false;
-    const child = spawn6(resolvedPath ?? binary, ["--version"], {
+    const child = spawn7(resolvedPath ?? binary, ["--version"], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const timer = setTimeout(() => {
@@ -84367,7 +85034,7 @@ async function probeOpenClawBinary(opts = {}) {
 async function tryResolveBinaryPath(binary) {
   return new Promise((resolvePromise) => {
     const which = process.platform === "win32" ? "where" : "which";
-    const child = spawn6(which, [binary], { stdio: ["ignore", "pipe", "ignore"] });
+    const child = spawn7(which, [binary], { stdio: ["ignore", "pipe", "ignore"] });
     let out = "";
     child.stdout?.on("data", (chunk) => {
       out += chunk.toString("utf-8");
@@ -90931,13 +91598,13 @@ var init_github_poll = __esm({
 });
 
 // ../dashboard/src/routes/resolve-diff-base.ts
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify11 } from "node:util";
-var execFileAsync2;
+var execFileAsync3;
 var init_resolve_diff_base = __esm({
   "../dashboard/src/routes/resolve-diff-base.ts"() {
     "use strict";
-    execFileAsync2 = promisify11(execFile4);
+    execFileAsync3 = promisify11(execFile5);
   }
 });
 
@@ -90956,7 +91623,7 @@ var init_register_git_github = __esm({
 });
 
 // ../dashboard/src/terminal.ts
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 import { randomUUID as randomUUID13 } from "node:crypto";
 import { EventEmitter as EventEmitter29 } from "node:events";
 function extractBaseCommand(command) {
@@ -91118,7 +91785,7 @@ var init_terminal = __esm({
           return { sessionId: "", error: validation.error };
         }
         const sessionId = randomUUID13();
-        const childProcess = spawn7(command, [], {
+        const childProcess = spawn8(command, [], {
           cwd,
           shell: true,
           stdio: ["pipe", "pipe", "pipe"],
@@ -91296,13 +91963,13 @@ var init_register_agents_projects_nodes = __esm({
 });
 
 // ../dashboard/src/exec-file.ts
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify12 } from "node:util";
-var execFileAsync3;
+var execFileAsync4;
 var init_exec_file = __esm({
   "../dashboard/src/exec-file.ts"() {
     "use strict";
-    execFileAsync3 = promisify12(execFile5);
+    execFileAsync4 = promisify12(execFile6);
   }
 });
 
@@ -91829,7 +92496,7 @@ function remapSpawnError(err, bin) {
   return err instanceof Error ? err : new Error(String(err));
 }
 async function spawnPaperclipCliJson(args, opts) {
-  const { spawn: spawn10 } = await import("node:child_process");
+  const { spawn: spawn11 } = await import("node:child_process");
   const bin = opts.cliBinaryPath ?? "paperclipai";
   const fullArgs = [...args, "--json"];
   if (opts.cliConfigPath) {
@@ -91840,7 +92507,7 @@ async function spawnPaperclipCliJson(args, opts) {
   return new Promise((resolve19, reject) => {
     let child;
     try {
-      child = spawn10(bin, fullArgs, { stdio: ["ignore", "pipe", "pipe"] });
+      child = spawn11(bin, fullArgs, { stdio: ["ignore", "pipe", "pipe"] });
     } catch (err) {
       reject(remapSpawnError(err, bin));
       return;
@@ -96413,7 +97080,7 @@ var init_auth_middleware = __esm({
 
 // ../dashboard/src/server.ts
 import express from "express";
-import { join as join38, dirname as dirname11 } from "node:path";
+import { join as join39, dirname as dirname11 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function clearAiSessionCleanupInterval() {
   if (!aiSessionCleanupIntervalHandle) {
@@ -96702,8 +97369,8 @@ __export(task_exports, {
   runTaskUpdate: () => runTaskUpdate
 });
 import { createInterface as createInterface2 } from "node:readline/promises";
-import { watchFile, unwatchFile, statSync as statSync6, existsSync as existsSync29, readFileSync as readFileSync8 } from "node:fs";
-import { basename as basename10, join as join39 } from "node:path";
+import { watchFile, unwatchFile, statSync as statSync6, existsSync as existsSync30, readFileSync as readFileSync9 } from "node:fs";
+import { basename as basename10, join as join40 } from "node:path";
 function getGitHubIssueUrl(sourceMetadata) {
   if (!sourceMetadata || typeof sourceMetadata !== "object") return void 0;
   const issueUrl = sourceMetadata.issueUrl;
@@ -97003,8 +97670,8 @@ async function runTaskLogs(id, options = {}, projectName) {
   printEntries(filteredEntries);
   if (options.follow) {
     const projectPath = projectContext?.projectPath ?? process.cwd();
-    const logPath = join39(projectPath, ".fusion", "tasks", id, "agent.log");
-    if (!existsSync29(logPath)) {
+    const logPath = join40(projectPath, ".fusion", "tasks", id, "agent.log");
+    if (!existsSync30(logPath)) {
       console.log(`
   Waiting for log file to be created...`);
     }
@@ -97033,7 +97700,7 @@ async function runTaskLogs(id, options = {}, projectName) {
           lastPosition = 0;
         }
         if (stats.size > lastPosition) {
-          const content = readFileSync8(logPath, "utf-8");
+          const content = readFileSync9(logPath, "utf-8");
           const lines = content.slice(lastPosition).split("\n");
           for (const line of lines) {
             if (!line.trim()) continue;
@@ -98034,7 +98701,7 @@ __export(skills_exports, {
   runSkillsSearch: () => runSkillsSearch,
   searchSkills: () => searchSkills
 });
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 async function searchSkills(query, limit = 10) {
   const url = `${SKILLS_API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`;
   try {
@@ -98112,7 +98779,7 @@ async function runSkillsInstall(args, options) {
     npxArgs.push("--skill", options.skill);
   }
   npxArgs.push("-y", "-a", "pi");
-  const child = spawn8("npx", npxArgs, {
+  const child = spawn9("npx", npxArgs, {
     cwd: process.cwd(),
     stdio: "inherit",
     shell: true
@@ -98144,12 +98811,12 @@ var init_skills = __esm({
 // src/extension.ts
 init_src();
 init_gh_cli();
-import { Type as Type7 } from "typebox";
+import { Type as Type8 } from "typebox";
 import { StringEnum } from "@mariozechner/pi-ai";
-import { resolve as resolve18, basename as basename11, extname as extname3, join as join40 } from "node:path";
+import { resolve as resolve18, basename as basename11, extname as extname3, join as join41 } from "node:path";
 import { readFile as readFile18 } from "node:fs/promises";
-import { existsSync as existsSync30 } from "node:fs";
-import { spawn as spawn9 } from "node:child_process";
+import { existsSync as existsSync31 } from "node:fs";
+import { spawn as spawn10 } from "node:child_process";
 var MIME_TYPES2 = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -98168,7 +98835,7 @@ var MIME_TYPES2 = {
 function resolveProjectRoot(cwd) {
   let current = resolve18(cwd);
   while (true) {
-    if (existsSync30(join40(current, ".fusion"))) {
+    if (existsSync31(join41(current, ".fusion"))) {
       return current;
     }
     const parent = resolve18(current, "..");
@@ -98189,7 +98856,7 @@ async function getStore2(cwd) {
   return store;
 }
 function getFusionDir(cwd) {
-  return join40(resolveProjectRoot(cwd), ".fusion");
+  return join41(resolveProjectRoot(cwd), ".fusion");
 }
 async function validateAssignableAgentId(cwd, agentId) {
   const { AgentStore: AgentStore2, isEphemeralAgent: isEphemeralAgent2 } = await Promise.resolve().then(() => (init_src(), src_exports));
@@ -98250,15 +98917,15 @@ function kbExtension(pi) {
       "Use fn_task_create for task tracking \u2014 be descriptive so the planning agent can write a good plan.",
       "Include the problem AND desired outcome. For bugs, describe current vs expected behavior."
     ],
-    parameters: Type7.Object({
-      description: Type7.String({ description: "What needs to be done \u2014 be descriptive" }),
-      depends: Type7.Optional(
-        Type7.Array(Type7.String(), {
+    parameters: Type8.Object({
+      description: Type8.String({ description: "What needs to be done \u2014 be descriptive" }),
+      depends: Type8.Optional(
+        Type8.Array(Type8.String(), {
           description: "Task IDs this depends on (e.g. ['FN-001', 'FN-002'])"
         })
       ),
-      agentId: Type7.Optional(
-        Type7.String({
+      agentId: Type8.Optional(
+        Type8.String({
           description: "Agent ID to assign this task to (e.g. 'agent-abc123')"
         })
       )
@@ -98311,25 +98978,25 @@ Column: triage
       "Use fn_task_update to modify task title, description, dependencies, or assigned agent after creation.",
       "At least one field must be provided to update."
     ],
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Task ID (e.g. FN-001)" }),
-      title: Type7.Optional(Type7.String({ description: "New task title" })),
-      description: Type7.Optional(Type7.String({ description: "New task description" })),
-      depends: Type7.Optional(
-        Type7.Array(Type7.String(), {
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Task ID (e.g. FN-001)" }),
+      title: Type8.Optional(Type8.String({ description: "New task title" })),
+      description: Type8.Optional(Type8.String({ description: "New task description" })),
+      depends: Type8.Optional(
+        Type8.Array(Type8.String(), {
           description: "New dependency list \u2014 replaces existing dependencies (e.g. ['FN-001', 'FN-002'])"
         })
       ),
-      agentId: Type7.Optional(
-        Type7.Union([
-          Type7.String(),
-          Type7.Null()
+      agentId: Type8.Optional(
+        Type8.Union([
+          Type8.String(),
+          Type8.Null()
         ], {
           description: "Agent ID to assign this task to, or null to clear (e.g. 'agent-abc123')"
         })
       ),
-      nodeId: Type7.Optional(
-        Type7.Union([Type7.String(), Type7.Null()], {
+      nodeId: Type8.Optional(
+        Type8.Union([Type8.String(), Type8.Null()], {
           description: "Node ID override for this task, or null to clear"
         })
       )
@@ -98410,14 +99077,14 @@ Column: triage
     label: "fn: List Tasks",
     description: "List all tasks on the Fusion board, grouped by column.",
     promptSnippet: "List all tasks on the Fusion board grouped by column",
-    parameters: Type7.Object({
-      column: Type7.Optional(
+    parameters: Type8.Object({
+      column: Type8.Optional(
         StringEnum([...COLUMNS], {
           description: "Filter to a specific column"
         })
       ),
-      limit: Type7.Optional(
-        Type7.Number({
+      limit: Type8.Optional(
+        Type8.Number({
           description: "Max tasks to show per column (default: 10)"
         })
       )
@@ -98459,8 +99126,8 @@ Column: triage
     label: "fn: Show Task",
     description: "Show full details for a task including steps, progress, and log entries.",
     promptSnippet: "Show full details for a Fusion task",
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Task ID (e.g. FN-001)" })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Task ID (e.g. FN-001)" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -98513,9 +99180,9 @@ Column: triage
     label: "fn: Attach File",
     description: "Attach a file to a task. Supports images (png, jpg, gif, webp) and text files (txt, log, json, yaml, yml, toml, csv, xml).",
     promptSnippet: "Attach a file to a Fusion task",
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Task ID (e.g. FN-001)" }),
-      path: Type7.String({ description: "Path to the file to attach" })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Task ID (e.g. FN-001)" }),
+      path: Type8.String({ description: "Path to the file to attach" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const filePath = resolve18(ctx.cwd, params.path.replace(/^@/, ""));
@@ -98553,8 +99220,8 @@ Path: .fusion/tasks/${params.id}/attachments/${attachment.filename}`
     label: "fn: Pause Task",
     description: "Pause a task \u2014 stops all automated agent and scheduler interaction for this task.",
     promptSnippet: "Pause a Fusion task (stops automation)",
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Task ID (e.g. FN-001)" })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Task ID (e.g. FN-001)" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -98570,8 +99237,8 @@ Path: .fusion/tasks/${params.id}/attachments/${attachment.filename}`
     label: "fn: Unpause Task",
     description: "Unpause a task \u2014 resumes automated agent and scheduler interaction.",
     promptSnippet: "Unpause a Fusion task (resumes automation)",
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Task ID (e.g. FN-001)" })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Task ID (e.g. FN-001)" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -98592,8 +99259,8 @@ Path: .fusion/tasks/${params.id}/attachments/${attachment.filename}`
       "Only tasks in 'failed' state can be retried",
       "The task will be moved to the todo column with error state cleared"
     ],
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Task ID to retry (e.g. FN-001). Must be in 'failed' state." })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Task ID to retry (e.g. FN-001). Must be in 'failed' state." })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -98633,8 +99300,8 @@ Path: .fusion/tasks/${params.id}/attachments/${attachment.filename}`
       "The duplicated task will be placed in planning for replanning",
       "Dependencies, attachments, and execution state are NOT copied"
     ],
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Source task ID to duplicate (e.g. FN-001)" })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Source task ID to duplicate (e.g. FN-001)" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -98656,9 +99323,9 @@ Path: .fusion/tasks/${params.id}/attachments/${attachment.filename}`
       "The refinement task will be created in planning and depend on the original task",
       "Provide clear feedback about what needs to be refined or improved"
     ],
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Task ID to refine (e.g. FN-001). Must be in 'done' or 'in-review' column." }),
-      feedback: Type7.String({
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Task ID to refine (e.g. FN-001). Must be in 'done' or 'in-review' column." }),
+      feedback: Type8.String({
         description: "Description of what needs to be refined or improved",
         minLength: 1,
         maxLength: 2e3
@@ -98685,8 +99352,8 @@ Path: .fusion/tasks/${params.id}/attachments/${attachment.filename}`
       "Only tasks in the 'done' column can be archived",
       "Archived tasks can be unarchived later if needed"
     ],
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Task ID to archive (e.g. FN-001). Must be in 'done' column." })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Task ID to archive (e.g. FN-001). Must be in 'done' column." })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -98706,8 +99373,8 @@ Path: .fusion/tasks/${params.id}/attachments/${attachment.filename}`
       "Use to restore an archived task back to the done column",
       "Only tasks in the 'archived' column can be unarchived"
     ],
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Task ID to unarchive (e.g. FN-001). Must be in 'archived' column." })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Task ID to unarchive (e.g. FN-001). Must be in 'archived' column." })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -98728,8 +99395,8 @@ Path: .fusion/tasks/${params.id}/attachments/${attachment.filename}`
       "Tasks are permanently deleted and cannot be recovered",
       "Consider archiving instead of deleting for completed work you may need to reference later"
     ],
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Task ID to delete (e.g. FN-001)" })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Task ID to delete (e.g. FN-001)" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -98751,20 +99418,20 @@ Path: .fusion/tasks/${params.id}/attachments/${attachment.filename}`
       "Use --limit to control how many issues to import (default: 30)",
       "Use --labels to filter by specific labels"
     ],
-    parameters: Type7.Object({
-      ownerRepo: Type7.String({
+    parameters: Type8.Object({
+      ownerRepo: Type8.String({
         description: "Repository in owner/repo format (e.g., 'dustinbyrne/fusion')",
         pattern: "^[^/]+/[^/]+$"
       }),
-      limit: Type7.Optional(
-        Type7.Number({
+      limit: Type8.Optional(
+        Type8.Number({
           description: "Max issues to import (default: 30, max: 100)",
           minimum: 1,
           maximum: 100
         })
       ),
-      labels: Type7.Optional(
-        Type7.Array(Type7.String(), {
+      labels: Type8.Optional(
+        Type8.Array(Type8.String(), {
           description: "Label names to filter by"
         })
       )
@@ -98840,14 +99507,14 @@ ${createdTasks.map((task) => `  ${task.id}: ${task.title}`).join("\n") || "  Non
       "Uses gh CLI authentication (run 'gh auth login')",
       "Skips import if the issue is already imported (checks for existing Source URL)"
     ],
-    parameters: Type7.Object({
-      owner: Type7.String({
+    parameters: Type8.Object({
+      owner: Type8.String({
         description: "Repository owner (e.g., 'dustinbyrne')"
       }),
-      repo: Type7.String({
+      repo: Type8.String({
         description: "Repository name (e.g., 'fusion')"
       }),
-      issueNumber: Type7.Number({
+      issueNumber: Type8.Number({
         description: "GitHub issue number to import",
         minimum: 1
       })
@@ -98922,22 +99589,22 @@ ${sourceUrl}`
       "Use --labels to filter by specific labels",
       "Uses gh CLI authentication (run 'gh auth login')"
     ],
-    parameters: Type7.Object({
-      owner: Type7.String({
+    parameters: Type8.Object({
+      owner: Type8.String({
         description: "Repository owner (e.g., 'dustinbyrne')"
       }),
-      repo: Type7.String({
+      repo: Type8.String({
         description: "Repository name (e.g., 'fusion')"
       }),
-      limit: Type7.Optional(
-        Type7.Number({
+      limit: Type8.Optional(
+        Type8.Number({
           description: "Max issues to show (default: 30, max: 100)",
           minimum: 1,
           maximum: 100
         })
       ),
-      labels: Type7.Optional(
-        Type7.Array(Type7.String(), {
+      labels: Type8.Optional(
+        Type8.Array(Type8.String(), {
           description: "Label names to filter by"
         })
       )
@@ -98996,9 +99663,9 @@ ${sourceUrl}`
       "Use for breaking down vague ideas into actionable tasks",
       "The AI will ask clarifying questions before creating the task"
     ],
-    parameters: Type7.Object({
-      description: Type7.Optional(
-        Type7.String({
+    parameters: Type8.Object({
+      description: Type8.Optional(
+        Type8.String({
           description: "Initial plan description (optional) \u2014 the AI will ask clarifying questions if not provided"
         })
       )
@@ -99053,13 +99720,13 @@ Planning session completed. Task ${taskId} is now in planning and will be auto-p
       "Missions are broken down into milestones \u2192 slices \u2192 features \u2192 tasks",
       "Be descriptive so the mission purpose is clear"
     ],
-    parameters: Type7.Object({
-      title: Type7.String({ description: "Mission title \u2014 brief but descriptive" }),
-      description: Type7.Optional(
-        Type7.String({ description: "Detailed mission objectives and context" })
+    parameters: Type8.Object({
+      title: Type8.String({ description: "Mission title \u2014 brief but descriptive" }),
+      description: Type8.Optional(
+        Type8.String({ description: "Detailed mission objectives and context" })
       ),
-      autoAdvance: Type7.Optional(
-        Type7.Boolean({ description: "Automatically activate the next pending slice when the current slice completes" })
+      autoAdvance: Type8.Optional(
+        Type8.Boolean({ description: "Automatically activate the next pending slice when the current slice completes" })
       )
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -99100,7 +99767,7 @@ Status: ${createdMission.status}${createdMission.autoAdvance ? "\nAuto-advance:
       "Missions are grouped by status (active, planning, complete, etc.)",
       "Use before fn_mission_show to find a specific mission ID"
     ],
-    parameters: Type7.Object({}),
+    parameters: Type8.Object({}),
     async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
       const missionStore = store.getMissionStore();
@@ -99145,8 +99812,8 @@ Status: ${createdMission.status}${createdMission.autoAdvance ? "\nAuto-advance:
       "Shows milestones, slices, and features in hierarchical order",
       "Check slice status to see if features can be linked to tasks"
     ],
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Mission ID (e.g., M-001)" })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Mission ID (e.g., M-001)" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -99200,8 +99867,8 @@ Status: ${createdMission.status}${createdMission.autoAdvance ? "\nAuto-advance:
       "Permanently deletes all milestones, slices, and features within the mission",
       "Tasks linked to features are NOT deleted \u2014 only the feature links are removed"
     ],
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Mission ID to delete (e.g., M-001)" })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Mission ID to delete (e.g., M-001)" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -99230,10 +99897,10 @@ Status: ${createdMission.status}${createdMission.autoAdvance ? "\nAuto-advance:
       "Use to break down a mission into manageable phases",
       "Milestones are ordered and contain slices (work units)"
     ],
-    parameters: Type7.Object({
-      missionId: Type7.String({ description: "Parent mission ID (e.g., M-001)" }),
-      title: Type7.String({ description: "Milestone title" }),
-      description: Type7.Optional(Type7.String({ description: "Milestone description" }))
+    parameters: Type8.Object({
+      missionId: Type8.String({ description: "Parent mission ID (e.g., M-001)" }),
+      title: Type8.String({ description: "Milestone title" }),
+      description: Type8.Optional(Type8.String({ description: "Milestone description" }))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -99268,10 +99935,10 @@ Status: ${createdMission.status}${createdMission.autoAdvance ? "\nAuto-advance:
       "Slices are activated for implementation, linking features to tasks",
       "Order slices by priority \u2014 they execute in sequence"
     ],
-    parameters: Type7.Object({
-      milestoneId: Type7.String({ description: "Parent milestone ID (e.g., MS-001)" }),
-      title: Type7.String({ description: "Slice title" }),
-      description: Type7.Optional(Type7.String({ description: "Slice description" }))
+    parameters: Type8.Object({
+      milestoneId: Type8.String({ description: "Parent milestone ID (e.g., MS-001)" }),
+      title: Type8.String({ description: "Slice title" }),
+      description: Type8.Optional(Type8.String({ description: "Slice description" }))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -99306,12 +99973,12 @@ Status: ${createdMission.status}${createdMission.autoAdvance ? "\nAuto-advance:
       "Features start as 'defined' and progress through 'triaged' \u2192 'in-progress' \u2192 'done'",
       "Link features to tasks using fn_feature_link_task"
     ],
-    parameters: Type7.Object({
-      sliceId: Type7.String({ description: "Parent slice ID (e.g., SL-001)" }),
-      title: Type7.String({ description: "Feature title" }),
-      description: Type7.Optional(Type7.String({ description: "Feature description" })),
-      acceptanceCriteria: Type7.Optional(
-        Type7.String({ description: "Acceptance criteria for completing the feature" })
+    parameters: Type8.Object({
+      sliceId: Type8.String({ description: "Parent slice ID (e.g., SL-001)" }),
+      title: Type8.String({ description: "Feature title" }),
+      description: Type8.Optional(Type8.String({ description: "Feature description" })),
+      acceptanceCriteria: Type8.Optional(
+        Type8.String({ description: "Acceptance criteria for completing the feature" })
       )
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -99348,8 +100015,8 @@ Status: ${createdMission.status}${createdMission.autoAdvance ? "\nAuto-advance:
       "Only pending slices can be activated",
       "Slice activation triggers auto-advance when linked tasks complete"
     ],
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Slice ID to activate (e.g., SL-001)" })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Slice ID to activate (e.g., SL-001)" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -99393,9 +100060,9 @@ Status: ${activated.status}`
       "Linking updates the feature status to 'triaged'",
       "When the linked task moves to 'done', the feature status becomes 'done'"
     ],
-    parameters: Type7.Object({
-      featureId: Type7.String({ description: "Feature ID to link (e.g., F-001)" }),
-      taskId: Type7.String({ description: "Task ID to link to (e.g., FN-001)" })
+    parameters: Type8.Object({
+      featureId: Type8.String({ description: "Feature ID to link (e.g., F-001)" }),
+      taskId: Type8.String({ description: "Task ID to link to (e.g., FN-001)" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
@@ -99441,8 +100108,8 @@ Status: ${updated.status}`
       "Stopped agents can be resumed with fn_agent_start",
       "Agents in 'idle', 'error', or 'terminated' state cannot be stopped"
     ],
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Agent ID to stop (e.g., agent-abc123)" })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Agent ID to stop (e.g., agent-abc123)" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const { AgentStore: AgentStore2, AGENT_VALID_TRANSITIONS: AGENT_VALID_TRANSITIONS2 } = await Promise.resolve().then(() => (init_src(), src_exports));
@@ -99492,8 +100159,8 @@ Status: ${updated.status}`
       "Only agents in 'paused' state can be started",
       "Agents in 'idle' or 'error' state cannot be started \u2014 use reset instead"
     ],
-    parameters: Type7.Object({
-      id: Type7.String({ description: "Agent ID to start (e.g., agent-abc123)" })
+    parameters: Type8.Object({
+      id: Type8.String({ description: "Agent ID to start (e.g., agent-abc123)" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const { AgentStore: AgentStore2, AGENT_VALID_TRANSITIONS: AGENT_VALID_TRANSITIONS2 } = await Promise.resolve().then(() => (init_src(), src_exports));
@@ -99542,12 +100209,12 @@ Status: ${updated.status}`
       "Use fn_skills_search to discover skills before installing",
       "Returns skills sorted by popularity (install count)"
     ],
-    parameters: Type7.Object({
-      query: Type7.String({
+    parameters: Type8.Object({
+      query: Type8.String({
         description: "Search query \u2014 framework name, technology, or capability (e.g., 'react', 'firebase', 'testing', 'docker')"
       }),
-      limit: Type7.Optional(
-        Type7.Number({
+      limit: Type8.Optional(
+        Type8.Number({
           description: "Max results to return (default: 10, max: 50)",
           minimum: 1,
           maximum: 50
@@ -99596,12 +100263,12 @@ Status: ${updated.status}`
       "The source is in owner/repo format (e.g., 'firebase/agent-skills')",
       "Specify the skill name to install a specific skill, or omit to install all from the source"
     ],
-    parameters: Type7.Object({
-      source: Type7.String({
+    parameters: Type8.Object({
+      source: Type8.String({
         description: "GitHub source in owner/repo format (e.g., 'firebase/agent-skills')"
       }),
-      skill: Type7.Optional(
-        Type7.String({
+      skill: Type8.Optional(
+        Type8.String({
           description: "Specific skill name to install (e.g., 'firebase-basics'). Omit to install all skills from the source."
         })
       )
@@ -99624,7 +100291,7 @@ Status: ${updated.status}`
         npxArgs.push("--skill", params.skill);
       }
       npxArgs.push("-y", "-a", "pi");
-      const child = spawn9("npx", npxArgs, {
+      const child = spawn10("npx", npxArgs, {
         cwd: resolveProjectRoot(ctx.cwd),
         stdio: "pipe",
         shell: true
@@ -99706,7 +100373,7 @@ Status: ${updated.status}`
         return;
       }
       const port = trimmed ? parseInt(trimmed, 10) || 4040 : 4040;
-      const child = spawn9("fn", ["dashboard", "--port", String(port)], {
+      const child = spawn10("fn", ["dashboard", "--port", String(port)], {
         cwd: resolveProjectRoot(ctx.cwd),
         stdio: ["ignore", "pipe", "pipe"],
         detached: false,