@runfusion/fusion 0.0.5 → 0.1.0

package/dist/bin.js

@@ -134,9 +134,11 @@ var init_settings_schema = __esm({
       defaultPresetBySize: {},
       autoResolveConflicts: true,
       smartConflictResolution: true,
+      worktreeRebaseBeforeMerge: true,
+      worktreeRebaseRemote: "",
       strictScopeEnforcement: false,
       buildRetryCount: 0,
-      verificationFixRetries: 1,
+      verificationFixRetries: 3,
       buildTimeoutMs: 3e5,
       requirePlanApproval: false,
       specStalenessEnabled: false,
@@ -30549,6 +30551,7 @@ ${newTask.description}
             }
           }
           if (updates.steps !== void 0) task.steps = updates.steps;
+          if (updates.currentStep !== void 0) task.currentStep = updates.currentStep;
           if (updates.status === null) {
             task.status = void 0;
           } else if (updates.status !== void 0) {
@@ -37138,9 +37141,9 @@ var require_pump = __commonJS({
     "use strict";
     var once3 = require_once();
     var eos = require_end_of_stream();
-    var fs;
+    var fs2;
     try {
-      fs = __require("fs");
+      fs2 = __require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -37151,8 +37154,8 @@ var require_pump = __commonJS({
     };
     var isFS = function(stream) {
       if (!ancient) return false;
-      if (!fs) return false;
-      return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close);
+      if (!fs2) return false;
+      return (stream instanceof (fs2.ReadStream || noop) || stream instanceof (fs2.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -37366,7 +37369,7 @@ var require_pend = __commonJS({
 var require_fd_slicer = __commonJS({
   "../../node_modules/.pnpm/fd-slicer@1.1.0/node_modules/fd-slicer/index.js"(exports) {
     "use strict";
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var util = __require("util");
     var stream = __require("stream");
     var Readable2 = stream.Readable;
@@ -37391,7 +37394,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self2 = this;
       self2.pend.go(function(cb) {
-        fs.read(self2.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        fs2.read(self2.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
           cb();
           callback(err, bytesRead, buffer2);
         });
@@ -37400,7 +37403,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
       var self2 = this;
       self2.pend.go(function(cb) {
-        fs.write(self2.fd, buffer, offset, length, position, function(err, written, buffer2) {
+        fs2.write(self2.fd, buffer, offset, length, position, function(err, written, buffer2) {
           cb();
           callback(err, written, buffer2);
         });
@@ -37421,7 +37424,7 @@ var require_fd_slicer = __commonJS({
       if (self2.refCount > 0) return;
       if (self2.refCount < 0) throw new Error("invalid unref");
       if (self2.autoClose) {
-        fs.close(self2.fd, onCloseDone);
+        fs2.close(self2.fd, onCloseDone);
       }
       function onCloseDone(err) {
         if (err) {
@@ -37458,7 +37461,7 @@ var require_fd_slicer = __commonJS({
       self2.context.pend.go(function(cb) {
         if (self2.destroyed) return cb();
         var buffer = new Buffer(toRead);
-        fs.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) {
+        fs2.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) {
           if (err) {
             self2.destroy(err);
           } else if (bytesRead === 0) {
@@ -37505,7 +37508,7 @@ var require_fd_slicer = __commonJS({
       }
       self2.context.pend.go(function(cb) {
         if (self2.destroyed) return cb();
-        fs.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) {
+        fs2.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) {
           if (err2) {
             self2.destroy();
             cb();
@@ -37934,7 +37937,7 @@ var require_buffer_crc32 = __commonJS({
 var require_yauzl = __commonJS({
   "../../node_modules/.pnpm/yauzl@2.10.0/node_modules/yauzl/index.js"(exports) {
     "use strict";
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var zlib = __require("zlib");
     var fd_slicer = require_fd_slicer();
     var crc32 = require_buffer_crc32();
@@ -37964,10 +37967,10 @@ var require_yauzl = __commonJS({
       if (options.validateEntrySizes == null) options.validateEntrySizes = true;
       if (options.strictFileNames == null) options.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs.open(path4, "r", function(err, fd) {
+      fs2.open(path4, "r", function(err, fd) {
         if (err) return callback(err);
         fromFd(fd, options, function(err2, zipfile) {
-          if (err2) fs.close(fd, defaultCallback);
+          if (err2) fs2.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -37984,7 +37987,7 @@ var require_yauzl = __commonJS({
       if (options.validateEntrySizes == null) options.validateEntrySizes = true;
       if (options.strictFileNames == null) options.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs.fstat(fd, function(err, stats) {
+      fs2.fstat(fd, function(err, stats) {
         if (err) return callback(err);
         var reader = fd_slicer.createFromFd(fd, { autoClose: true });
         fromRandomAccessReader(reader, stats.size, options, callback);
@@ -38565,7 +38568,7 @@ var require_extract_zip = __commonJS({
   "../../node_modules/.pnpm/extract-zip@2.0.1/node_modules/extract-zip/index.js"(exports, module) {
     "use strict";
     var debug = require_src()("extract-zip");
-    var { createWriteStream: createWriteStream2, promises: fs } = __require("fs");
+    var { createWriteStream: createWriteStream2, promises: fs2 } = __require("fs");
     var getStream = require_get_stream();
     var path4 = __require("path");
     var { promisify: promisify14 } = __require("util");
@@ -38606,8 +38609,8 @@ var require_extract_zip = __commonJS({
             }
             const destDir = path4.dirname(path4.join(this.opts.dir, entry.fileName));
             try {
-              await fs.mkdir(destDir, { recursive: true });
-              const canonicalDestDir = await fs.realpath(destDir);
+              await fs2.mkdir(destDir, { recursive: true });
+              const canonicalDestDir = await fs2.realpath(destDir);
               const relativeDestDir = path4.relative(this.opts.dir, canonicalDestDir);
               if (relativeDestDir.split(path4.sep).includes("..")) {
                 throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
@@ -38651,14 +38654,14 @@ var require_extract_zip = __commonJS({
           mkdirOptions.mode = procMode;
         }
         debug("mkdir", { dir: destDir, ...mkdirOptions });
-        await fs.mkdir(destDir, mkdirOptions);
+        await fs2.mkdir(destDir, mkdirOptions);
         if (isDir) return;
         debug("opening read stream", dest);
         const readStream = await promisify14(this.zipfile.openReadStream.bind(this.zipfile))(entry);
         if (symlink) {
           const link = await getStream(readStream);
           debug("creating symlink", link, dest);
-          await fs.symlink(link, dest);
+          await fs2.symlink(link, dest);
         } else {
           await pipeline(readStream, createWriteStream2(dest, { mode: procMode }));
         }
@@ -38690,8 +38693,8 @@ var require_extract_zip = __commonJS({
       if (!path4.isAbsolute(opts.dir)) {
         throw new Error("Target directory is expected to be absolute");
       }
-      await fs.mkdir(opts.dir, { recursive: true });
-      opts.dir = await fs.realpath(opts.dir);
+      await fs2.mkdir(opts.dir, { recursive: true });
+      opts.dir = await fs2.realpath(opts.dir);
       return new Extractor(zipPath, opts).extract();
     };
   }
@@ -45550,14 +45553,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs = this.flowScalar(this.type);
+              const fs2 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map2.items.push({ start, key: fs, sep: [] });
+                map2.items.push({ start, key: fs2, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs);
+                this.stack.push(fs2);
               } else {
-                Object.assign(it, { key: fs, sep: [] });
+                Object.assign(it, { key: fs2, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -45685,13 +45688,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs = this.flowScalar(this.type);
+              const fs2 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs, sep: [] });
+                fc.items.push({ start: [], key: fs2, sep: [] });
               else if (it.sep)
-                this.stack.push(fs);
+                this.stack.push(fs2);
               else
-                Object.assign(it, { key: fs, sep: [] });
+                Object.assign(it, { key: fs2, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -49972,7 +49975,7 @@ var require_windowsPtyAgent = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.argsToCommandLine = exports.WindowsPtyAgent = void 0;
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var os3 = __require("os");
     var path4 = __require("path");
     var child_process_1 = __require("child_process");
@@ -50031,7 +50034,7 @@ var require_windowsPtyAgent = __commonJS({
           this._outSocket.on("connect", function() {
             _this._outSocket.emit("ready_datapipe");
           });
-          var inSocketFD = fs.openSync(term.conin, "w");
+          var inSocketFD = fs2.openSync(term.conin, "w");
           this._inSocket = new net_1.Socket({
             fd: inSocketFD,
             readable: false,
@@ -50465,7 +50468,7 @@ var require_unixTerminal = __commonJS({
     })();
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.UnixTerminal = void 0;
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var path4 = __require("path");
     var tty = __require("tty");
     var terminal_1 = require_terminal();
@@ -50728,7 +50731,7 @@ var require_unixTerminal = __commonJS({
             return;
           }
           var task = this._writeQueue[0];
-          fs.write(this._fd, task.buffer, task.offset, function(err, written) {
+          fs2.write(this._fd, task.buffer, task.offset, function(err, written) {
             if (err) {
               if ("code" in err && err.code === "EAGAIN") {
                 _this._writeImmediate = setImmediate(function() {
@@ -50790,26 +50793,74 @@ var require_lib = __commonJS({
 import { EventEmitter as EventEmitter17 } from "events";
 import * as os2 from "os";
 import * as path from "path";
-import { existsSync as existsSync17 } from "node:fs";
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
 import { join as join22, dirname as dirname7 } from "node:path";
-function findStagedNativeDir() {
+function getNativePrebuildName() {
   const platform3 = process.platform === "darwin" ? "darwin" : process.platform === "linux" ? "linux" : process.platform === "win32" ? "win32" : "unknown";
   const arch = process.arch === "arm64" ? "arm64" : process.arch === "x64" ? "x64" : "unknown";
-  const prebuildName = `${platform3}-${arch}`;
+  return `${platform3}-${arch}`;
+}
+function findInstalledNodePtyNativeDir() {
+  try {
+    const packageJsonPath = require2.resolve("node-pty/package.json");
+    const nativeDir = join22(dirname7(packageJsonPath), "prebuilds", getNativePrebuildName());
+    return fs.existsSync(join22(nativeDir, "pty.node")) ? nativeDir : null;
+  } catch {
+    return null;
+  }
+}
+function ensureNodePtyNativePermissions() {
+  if (process.platform === "win32") {
+    return;
+  }
+  const candidateDirs = /* @__PURE__ */ new Set();
+  const envNativeDir = process.env.NODE_PTY_SPAWN_HELPER_DIR || process.env.FUSION_NATIVE_ASSETS_PATH;
+  if (envNativeDir) {
+    candidateDirs.add(envNativeDir);
+  }
+  const stagedNativeDir = findStagedNativeDir();
+  if (stagedNativeDir) {
+    candidateDirs.add(stagedNativeDir);
+  }
+  const installedNativeDir = findInstalledNodePtyNativeDir();
+  if (installedNativeDir) {
+    candidateDirs.add(installedNativeDir);
+  }
+  for (const nativeDir of candidateDirs) {
+    const helperPath = join22(nativeDir, "spawn-helper");
+    const nativeModulePath = join22(nativeDir, "pty.node");
+    try {
+      fs.chmodSync(helperPath, 493);
+    } catch {
+    }
+    try {
+      fs.chmodSync(nativeModulePath, 493);
+    } catch (err) {
+      console.warn("[terminal] Failed to repair node-pty native permissions:", {
+        nativeDir,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+}
+function findStagedNativeDir() {
+  const prebuildName = getNativePrebuildName();
   if (process.env.FUSION_RUNTIME_DIR) {
     const envPath = join22(process.env.FUSION_RUNTIME_DIR, prebuildName);
-    if (existsSync17(join22(envPath, "pty.node"))) {
+    if (fs.existsSync(join22(envPath, "pty.node"))) {
       return envPath;
     }
   }
   const execDir = dirname7(process.execPath);
   const nextToBinary = join22(execDir, "runtime", prebuildName);
-  if (existsSync17(join22(nextToBinary, "pty.node"))) {
+  if (fs.existsSync(join22(nextToBinary, "pty.node"))) {
     return nextToBinary;
   }
   return null;
 }
 async function loadPtyModule() {
+  ensureNodePtyNativePermissions();
   if (ptyModule) {
     return ptyModule;
   }
@@ -50824,7 +50875,7 @@ async function loadPtyModule() {
       }
       process.env.FUSION_NATIVE_ASSETS_PATH = nativeDir;
       const nativePath = join22(nativeDir, "pty.node");
-      if (existsSync17(nativePath)) {
+      if (fs.existsSync(nativePath)) {
         try {
           const nativeModule = { exports: {} };
           process.dlopen(nativeModule, nativePath);
@@ -50861,13 +50912,14 @@ function getTerminalService(projectRoot, maxSessions) {
   terminalServices.set(resolvedRoot, service);
   return service;
 }
-var isBunBinary, ptyModule, ptyLoadError, MAX_SCROLLBACK_SIZE, MIN_MAX_SESSIONS, MAX_MAX_SESSIONS, DEFAULT_MAX_SESSIONS, OUTPUT_THROTTLE_MS, OUTPUT_BATCH_SIZE, STALE_SESSION_THRESHOLD_MS, SESSION_ID_PATTERN, ALLOWED_SHELL_PATHS, STRIP_ENV_VARS, TerminalService, terminalServices;
+var isBunBinary, ptyModule, ptyLoadError, require2, MAX_SCROLLBACK_SIZE, MIN_MAX_SESSIONS, MAX_MAX_SESSIONS, DEFAULT_MAX_SESSIONS, OUTPUT_THROTTLE_MS, OUTPUT_BATCH_SIZE, STALE_SESSION_THRESHOLD_MS, SESSION_ID_PATTERN, ALLOWED_SHELL_PATHS, STRIP_ENV_VARS, TerminalService, terminalServices;
 var init_terminal_service = __esm({
   "../dashboard/src/terminal-service.ts"() {
     "use strict";
     isBunBinary = typeof Bun !== "undefined" && !!Bun.embeddedFiles;
     ptyModule = null;
     ptyLoadError = null;
+    require2 = createRequire(import.meta.url);
     MAX_SCROLLBACK_SIZE = 5e4;
     MIN_MAX_SESSIONS = 1;
     MAX_MAX_SESSIONS = 100;
@@ -50957,13 +51009,13 @@ var init_terminal_service = __esm({
           const normalizedUserShell = this.isWindows ? userShell.toLowerCase() : userShell;
           for (const allowed of allowedShells) {
             const normalizedAllowed = this.isWindows ? allowed.toLowerCase() : allowed;
-            if (normalizedAllowed === normalizedUserShell && existsSync17(allowed)) {
+            if (normalizedAllowed === normalizedUserShell && fs.existsSync(allowed)) {
               return { shell: allowed, args: getShellArgs(allowed) };
             }
           }
         }
         for (const shell of allowedShells) {
-          if (existsSync17(shell)) {
+          if (fs.existsSync(shell)) {
             return { shell, args: getShellArgs(shell) };
           }
         }
@@ -50984,7 +51036,7 @@ var init_terminal_service = __esm({
           detectedShell,
           detectedArgs,
           envShell: process.env.SHELL ?? null,
-          allowedShells: this.getAllowedShells().filter((shellPath) => existsSync17(shellPath))
+          allowedShells: this.getAllowedShells().filter((shellPath) => fs.existsSync(shellPath))
         };
       }
       /**
@@ -51005,7 +51057,7 @@ var init_terminal_service = __esm({
           return this.projectRoot;
         }
         try {
-          const stat11 = await import("node:fs/promises").then((fs) => fs.stat(cwd));
+          const stat11 = await import("node:fs/promises").then((fs2) => fs2.stat(cwd));
           if (stat11.isDirectory()) {
             return cwd;
           }
@@ -51168,7 +51220,7 @@ var init_terminal_service = __esm({
           addSpawnAttempt(shell, [], "retry-without-login");
         }
         for (const allowedShell of this.getAllowedShells()) {
-          if (allowedShell === shell || !existsSync17(allowedShell)) continue;
+          if (allowedShell === shell || !fs.existsSync(allowedShell)) continue;
           const shellName = path.basename(allowedShell).toLowerCase().replace(".exe", "");
           const fallbackArgs = shellName === "bash" || shellName === "zsh" ? [] : [];
           addSpawnAttempt(allowedShell, fallbackArgs, "allowed-fallback");
@@ -65072,6 +65124,71 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
       mergerLog.warn(`${taskId}: unable to verify/checkout main branch \u2014 proceeding on current HEAD`);
     }
   }
+  if (settings.worktreeRebaseBeforeMerge !== false) {
+    try {
+      let remote = settings.worktreeRebaseRemote?.trim();
+      if (!remote) {
+        try {
+          const { stdout: mainBranchOut } = await execAsync2(
+            "git rev-parse --abbrev-ref HEAD",
+            { cwd: rootDir, encoding: "utf-8" }
+          );
+          const mainBranch = mainBranchOut.trim();
+          const { stdout: configuredRemote } = await execAsync2(
+            `git config --get branch.${mainBranch}.remote`,
+            { cwd: rootDir, encoding: "utf-8" }
+          ).catch(() => ({ stdout: "" }));
+          remote = configuredRemote.trim();
+        } catch {
+        }
+      }
+      if (!remote) {
+        try {
+          const { stdout: remotesOut } = await execAsync2("git remote", {
+            cwd: rootDir,
+            encoding: "utf-8"
+          });
+          const remotes = remotesOut.trim().split(/\s+/).filter(Boolean);
+          if (remotes.length === 1) {
+            remote = remotes[0];
+          } else if (remotes.includes("origin")) {
+            remote = "origin";
+          }
+        } catch {
+        }
+      }
+      if (!remote) {
+        mergerLog.log(`${taskId}: no remote resolvable \u2014 skipping pre-merge rebase`);
+      } else {
+        mergerLog.log(`${taskId}: fetching ${remote} before merge`);
+        await execAsync2(`git fetch "${remote}"`, { cwd: rootDir });
+        try {
+          const { stdout: mainBranchOut } = await execAsync2(
+            "git rev-parse --abbrev-ref HEAD",
+            { cwd: rootDir, encoding: "utf-8" }
+          );
+          const mainBranch = mainBranchOut.trim();
+          const remoteRef = `${remote}/${mainBranch}`;
+          if (worktreePath) {
+            await execAsync2(`git rebase "${remoteRef}"`, { cwd: worktreePath });
+            mergerLog.log(`${taskId}: rebased ${branch} onto ${remoteRef}`);
+          } else {
+            mergerLog.warn(`${taskId}: no worktreePath \u2014 skipping task branch rebase`);
+          }
+        } catch (rebaseErr) {
+          const msg = rebaseErr instanceof Error ? rebaseErr.message : String(rebaseErr);
+          mergerLog.warn(`${taskId}: pre-merge rebase failed (${msg}) \u2014 aborting rebase and falling through to smart/AI merge`);
+          if (worktreePath) {
+            await execAsync2("git rebase --abort", { cwd: worktreePath }).catch(() => {
+            });
+          }
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      mergerLog.warn(`${taskId}: pre-merge rebase pipeline failed (${msg}) \u2014 proceeding without rebase`);
+    }
+  }
   let commitLog = "";
   let diffStat = "";
   try {
@@ -65170,7 +65287,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
     } catch (error) {
       if (error.name === "VerificationError") {
         const verificationErr = error;
-        const maxFixRetries = Math.min(settings.verificationFixRetries ?? 1, 3);
+        const maxFixRetries = Math.min(settings.verificationFixRetries ?? 3, 3);
         if (maxFixRetries > 0 && (verificationErr.verificationResult.testResult || verificationErr.verificationResult.buildResult)) {
           mergerLog.log(`${taskId}: deterministic verification failed \u2014 attempting in-merge fix (up to ${maxFixRetries} attempts)`);
           await store.logEntry(taskId, `Verification failed during merge \u2014 attempting in-merge fix (up to ${maxFixRetries} attempts)`);
@@ -65215,7 +65332,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
         throw error;
       }
       if (error.message?.includes("Build verification failed")) {
-        const maxFixRetries = Math.min(settings.verificationFixRetries ?? 1, 3);
+        const maxFixRetries = Math.min(settings.verificationFixRetries ?? 3, 3);
         if (maxFixRetries > 0 && (effectiveTestCommand || effectiveBuildCommand)) {
           mergerLog.log(`${taskId}: build verification failed \u2014 attempting in-merge fix`);
           await store.logEntry(taskId, `Build verification failed during merge \u2014 attempting in-merge fix`);
@@ -67588,19 +67705,6 @@ import { existsSync as existsSync26 } from "node:fs";
 import { readFile as readFile16, writeFile as writeFile12 } from "node:fs/promises";
 import { Type as Type4 } from "@mariozechner/pi-ai";
 import { ModelRegistry as ModelRegistry2, SessionManager as SessionManager2 } from "@mariozechner/pi-coding-agent";
-function determineRevisionResetStart(steps, feedback) {
-  const total = steps.length;
-  if (total === 0) return 0;
-  const skipPreflight = /preflight/i.test(steps[0].name);
-  const firstCandidate = skipPreflight ? 1 : 0;
-  if (firstCandidate >= total) return total;
-  const fb = feedback.toLowerCase();
-  for (let i = firstCandidate; i < total; i++) {
-    const tokens = steps[i].name.toLowerCase().match(/[a-z][a-z]{4,}/g) ?? [];
-    if (tokens.some((t) => fb.includes(t))) return i;
-  }
-  return firstCandidate;
-}
 function truncateWorkflowScriptOutput2(output) {
   if (output.length <= WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2) return output;
   return `... output truncated to last ${WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2} characters ...
@@ -69917,35 +70021,23 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
       }
       /**
        * Handle a workflow step revision request.
-       * 
-       * This method:
-       * 1. Updates PROMPT.md with "Workflow Revision Instructions" section
-       * 2. Resets task execution state (all steps reset to pending)
-       * 3. Schedules fresh execution to run after current guard unwinds
-       * 
-       * The task stays in "in-progress" and is scheduled for a fresh executor pass.
+       *
+       * Re-opens ONLY the last step so the executor has exactly one pending slot
+       * to re-enter through. All earlier done steps stay done — the agent reads
+       * the injected feedback from PROMPT.md and applies an in-place fix rather
+       * than redoing any completed step.
        */
       async handleWorkflowRevisionRequest(task, worktreePath, feedback, stepName) {
         executorLog.log(`${task.id}: workflow revision requested by step "${stepName}"`);
         const updatedTask = await this.store.getTask(task.id);
-        const resetStart = determineRevisionResetStart(updatedTask.steps, feedback);
-        const targetStepName = resetStart < updatedTask.steps.length ? updatedTask.steps[resetStart].name : null;
-        const resetSummary = resetStart >= updatedTask.steps.length ? "no steps to reset" : `resetting steps ${resetStart + 1}\u2013${updatedTask.steps.length} (starting at "${targetStepName}")`;
+        const reopen = await this.reopenLastStepForRevision(task.id, updatedTask);
+        const reopenSummary = reopen ? `re-opening Step ${reopen.index + 1} ("${reopen.name}") for in-place fix` : "no step to re-open (none were completed)";
         await this.store.logEntry(
           task.id,
-          `Workflow step "${stepName}" requested revision \u2014 ${resetSummary}`,
+          `Workflow step "${stepName}" requested revision \u2014 ${reopenSummary}`,
           feedback
         );
-        await this.injectWorkflowRevisionInstructions(task, feedback, {
-          resetStart,
-          targetStepName,
-          totalSteps: updatedTask.steps.length
-        });
-        for (let i = resetStart; i < updatedTask.steps.length; i++) {
-          if (updatedTask.steps[i].status !== "pending") {
-            await this.store.updateStep(task.id, i, "pending");
-          }
-        }
+        await this.injectWorkflowRevisionInstructions(task, feedback);
         await this.store.updateTask(task.id, {
           status: null,
           sessionFile: null
@@ -69967,12 +70059,36 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
           }
         }, 0);
       }
+      /**
+       * Re-open the last non-pending step so a revision/failure handler gives the
+       * executor exactly one pending slot to re-enter through. Returns the index
+       * and name of the step that was flipped to `pending`, or null when there
+       * was nothing to re-open.
+       */
+      async reopenLastStepForRevision(taskId, task) {
+        const steps = task.steps;
+        if (steps.length === 0) return null;
+        let targetIndex = -1;
+        for (let i = steps.length - 1; i >= 0; i--) {
+          if (steps[i].status !== "pending") {
+            targetIndex = i;
+            break;
+          }
+        }
+        if (targetIndex === -1) {
+          await this.store.updateTask(taskId, { currentStep: 0 });
+          return null;
+        }
+        await this.store.updateStep(taskId, targetIndex, "pending");
+        await this.store.updateTask(taskId, { currentStep: targetIndex });
+        return { index: targetIndex, name: steps[targetIndex].name };
+      }
       /**
        * Inject or update the "Workflow Revision Instructions" section in PROMPT.md.
        * This section contains feedback from workflow steps that requested revisions.
        * The section is replaced entirely to avoid accumulation of old feedback.
        */
-      async injectWorkflowRevisionInstructions(task, feedback, scope) {
+      async injectWorkflowRevisionInstructions(task, feedback) {
         const promptPath = join35(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
         let content;
         try {
@@ -69981,14 +70097,7 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
           executorLog.warn(`${task.id}: PROMPT.md not found at ${promptPath}, skipping revision injection`);
           return;
         }
-        let scopeLine;
-        if (scope && scope.targetStepName && scope.resetStart < scope.totalSteps) {
-          scopeLine = `Re-execution starts at **Step ${scope.resetStart + 1} ("${scope.targetStepName}")**. Earlier steps remain done \u2014 do not re-run them unless the feedback explicitly calls them out.`;
-        } else if (scope && scope.resetStart >= scope.totalSteps) {
-          scopeLine = "No steps were reset; apply the feedback as an in-place fix and call task_done() when complete.";
-        } else {
-          scopeLine = "Address the feedback above by making the necessary code changes, then mark all affected steps as done and call task_done() when complete.";
-        }
+        const scopeLine = "All prior steps remain **done**. Apply the feedback above as an in-place fix (make the necessary code changes, commit, and call `task_done()` when complete). Do **not** re-run or re-plan any earlier step unless the feedback explicitly calls it out.";
         const revisionSectionHeader = "## Workflow Revision Instructions";
         const revisionSectionContent = `${revisionSectionHeader}
 
@@ -70047,11 +70156,7 @@ ${feedback}
         });
         await this.injectWorkflowStepFailureInstructions(task, failureFeedback, stepName, retryCount);
         const updatedTask = await this.store.getTask(task.id);
-        for (let i = 0; i < updatedTask.steps.length; i++) {
-          if (updatedTask.steps[i].status !== "pending") {
-            await this.store.updateStep(task.id, i, "pending");
-          }
-        }
+        await this.reopenLastStepForRevision(task.id, updatedTask);
         await this.store.updateTask(task.id, {
           status: null,
           sessionFile: null
@@ -70095,11 +70200,7 @@ Please fix the issues so the verification can pass on the next attempt.`,
         );
         await this.injectWorkflowStepFailureInstructions(task, failureFeedback, stepName, MAX_WORKFLOW_STEP_RETRIES);
         const updatedTask = await this.store.getTask(taskId);
-        for (let i = 0; i < updatedTask.steps.length; i++) {
-          if (updatedTask.steps[i].status !== "pending") {
-            await this.store.updateStep(taskId, i, "pending");
-          }
-        }
+        await this.reopenLastStepForRevision(taskId, updatedTask);
         await this.store.updateTask(taskId, {
           status: null,
           error: null,
@@ -75898,6 +75999,12 @@ async function getHeartbeatMemorySettings(taskStore) {
   }
   return maybeGetSettings.call(taskStore);
 }
+function isTickableState(state) {
+  return state === "active" || state === "running";
+}
+function isHeartbeatManaged(agent) {
+  return !isEphemeralAgent(agent);
+}
 var HEARTBEAT_SYSTEM_PROMPT, HEARTBEAT_NO_TASK_SYSTEM_PROMPT, heartbeatDoneParams, HeartbeatMonitor, HeartbeatTriggerScheduler;
 var init_agent_heartbeat = __esm({
   "../engine/src/agent-heartbeat.ts"() {
@@ -77134,10 +77241,6 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
        * @param config - Per-agent heartbeat config
        */
       registerAgent(agentId, config) {
-        if (config.enabled === false) {
-          heartbeatLog.log(`Skipping timer registration for ${agentId} (disabled)`);
-          return;
-        }
         let rawIntervalMs = config.heartbeatIntervalMs;
         let usingDefaultInterval = false;
         if (!rawIntervalMs || typeof rawIntervalMs !== "number" || !Number.isFinite(rawIntervalMs) || rawIntervalMs <= 0) {
@@ -77227,8 +77330,13 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
         this.assignedListener = async (agent, taskId) => {
           if (!this.running) return;
           try {
-            if (agent.runtimeConfig?.enabled === false) {
-              heartbeatLog.log(`Assignment trigger skipped for ${agent.id} (heartbeat disabled)`);
+            if (!isHeartbeatManaged(agent)) {
+              heartbeatLog.log(`Assignment trigger skipped for ${agent.id} (ephemeral/internal)`);
+              return;
+            }
+            const runtimeConfig = agent.runtimeConfig ?? {};
+            if (runtimeConfig.enabled === false) {
+              heartbeatLog.log(`Assignment trigger skipped for ${agent.id} (disabled)`);
               return;
             }
             const activeRun = await this.store.getActiveHeartbeatRun(agent.id);
@@ -77297,9 +77405,21 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
       watchAgentLifecycle() {
         if (this.updatedListener || this.deletedListener) return;
         this.updatedListener = (agent) => {
-          if (agent.state === "terminated" || agent.runtimeConfig?.enabled === false) {
+          if (!isHeartbeatManaged(agent) || !isTickableState(agent.state)) {
             this.unregisterAgent(agent.id);
+            return;
           }
+          if (this.timers.has(agent.id)) {
+            return;
+          }
+          const rc = agent.runtimeConfig ?? {};
+          this.registerAgent(agent.id, {
+            heartbeatIntervalMs: rc.heartbeatIntervalMs,
+            maxConcurrentRuns: rc.maxConcurrentRuns
+          });
+          heartbeatLog.log(
+            `State-driven registration: ${agent.id} is ${agent.state} \u2014 timer armed`
+          );
         };
         this.deletedListener = (agentId) => {
           this.unregisterAgent(agentId);
@@ -77330,8 +77450,8 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
             this.unregisterAgent(agentId);
             return;
           }
-          if (agent.state === "terminated" || agent.runtimeConfig?.enabled === false) {
-            heartbeatLog.log(`Timer tick skipped for ${agentId} (disabled or terminated)`);
+          if (!isHeartbeatManaged(agent) || !isTickableState(agent.state)) {
+            heartbeatLog.log(`Timer tick skipped for ${agentId} (state=${agent.state})`);
             this.unregisterAgent(agentId);
             return;
           }
@@ -77675,6 +77795,10 @@ var init_self_healing = __esm({
           const result = await readLog("HEAD");
           stdout = result.stdout;
         }
+        if (!stdout.trim() && task.baseCommitSha) {
+          const result = await readLog("HEAD");
+          stdout = result.stdout;
+        }
         const firstLine = stdout.trim().split("\n").find(Boolean);
         if (!firstLine) return null;
         const [sha, subject] = firstLine.split("");
@@ -79536,13 +79660,13 @@ var init_in_process_runtime = __esm({
               this.taskStore
             );
             this.triggerScheduler.start();
+            const isHeartbeatEnabledAgent = (agent) => !isEphemeralAgent(agent) && agent.runtimeConfig?.enabled !== false;
             this.agentCreatedListener = (agent) => {
               if (!this.triggerScheduler) return;
+              if (!isHeartbeatEnabledAgent(agent)) return;
               const rc = agent.runtimeConfig;
-              if (rc?.enabled === false) return;
               this.triggerScheduler.registerAgent(agent.id, {
                 heartbeatIntervalMs: rc?.heartbeatIntervalMs,
-                enabled: rc?.enabled,
                 maxConcurrentRuns: rc?.maxConcurrentRuns
               });
               runtimeLog.log(`Registered new agent ${agent.id} for heartbeat triggers`);
@@ -79550,18 +79674,17 @@ var init_in_process_runtime = __esm({
             this.agentStore.on("agent:created", this.agentCreatedListener);
             this.agentUpdatedListener = (agent) => {
               if (!this.triggerScheduler) return;
-              const rc = agent.runtimeConfig;
-              if (rc?.enabled === false) {
+              if (!isHeartbeatEnabledAgent(agent)) {
                 this.triggerScheduler.unregisterAgent(agent.id);
-                runtimeLog.log(`Unregistered agent ${agent.id} from heartbeat triggers (disabled)`);
-              } else {
-                this.triggerScheduler.registerAgent(agent.id, {
-                  heartbeatIntervalMs: rc?.heartbeatIntervalMs,
-                  enabled: rc?.enabled,
-                  maxConcurrentRuns: rc?.maxConcurrentRuns
-                });
-                runtimeLog.log(`Re-registered agent ${agent.id} for heartbeat triggers`);
+                runtimeLog.log(`Unregistered agent ${agent.id} from heartbeat triggers`);
+                return;
               }
+              const rc = agent.runtimeConfig;
+              this.triggerScheduler.registerAgent(agent.id, {
+                heartbeatIntervalMs: rc?.heartbeatIntervalMs,
+                maxConcurrentRuns: rc?.maxConcurrentRuns
+              });
+              runtimeLog.log(`Re-registered agent ${agent.id} for heartbeat triggers`);
             };
             this.agentStore.on("agent:updated", this.agentUpdatedListener);
             this.ephemeralTerminationListener = (agentId, from, to) => {
@@ -79596,15 +79719,13 @@ var init_in_process_runtime = __esm({
               const agents = await this.agentStore.listAgents();
               let registeredCount = 0;
               for (const agent of agents) {
+                if (!isHeartbeatEnabledAgent(agent)) continue;
                 const rc = agent.runtimeConfig;
-                if (rc?.enabled !== false) {
-                  this.triggerScheduler.registerAgent(agent.id, {
-                    heartbeatIntervalMs: rc?.heartbeatIntervalMs,
-                    enabled: rc?.enabled,
-                    maxConcurrentRuns: rc?.maxConcurrentRuns
-                  });
-                  registeredCount++;
-                }
+                this.triggerScheduler.registerAgent(agent.id, {
+                  heartbeatIntervalMs: rc?.heartbeatIntervalMs,
+                  maxConcurrentRuns: rc?.maxConcurrentRuns
+                });
+                registeredCount++;
               }
               if (agents.length > 0) {
                 runtimeLog.log(`Registered ${registeredCount} of ${agents.length} agents for heartbeat triggers`);
@@ -88081,13 +88202,13 @@ var require_readdir_glob = __commonJS({
   "../../node_modules/.pnpm/readdir-glob@1.1.3/node_modules/readdir-glob/index.js"(exports, module) {
     "use strict";
     module.exports = readdirGlob;
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var { EventEmitter: EventEmitter33 } = __require("events");
     var { Minimatch } = require_minimatch();
     var { resolve: resolve29 } = __require("path");
     function readdir11(dir2, strict) {
       return new Promise((resolve30, reject2) => {
-        fs.readdir(dir2, { withFileTypes: true }, (err, files) => {
+        fs2.readdir(dir2, { withFileTypes: true }, (err, files) => {
           if (err) {
             switch (err.code) {
               case "ENOTDIR":
@@ -88120,7 +88241,7 @@ var require_readdir_glob = __commonJS({
     }
     function stat11(file, followSymlinks) {
       return new Promise((resolve30, reject2) => {
-        const statFunc = followSymlinks ? fs.stat : fs.lstat;
+        const statFunc = followSymlinks ? fs2.stat : fs2.lstat;
         statFunc(file, (err, stats) => {
           if (err) {
             switch (err.code) {
@@ -90183,54 +90304,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs) {
+    function patch(fs2) {
       if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs);
-      }
-      if (!fs.lutimes) {
-        patchLutimes(fs);
-      }
-      fs.chown = chownFix(fs.chown);
-      fs.fchown = chownFix(fs.fchown);
-      fs.lchown = chownFix(fs.lchown);
-      fs.chmod = chmodFix(fs.chmod);
-      fs.fchmod = chmodFix(fs.fchmod);
-      fs.lchmod = chmodFix(fs.lchmod);
-      fs.chownSync = chownFixSync(fs.chownSync);
-      fs.fchownSync = chownFixSync(fs.fchownSync);
-      fs.lchownSync = chownFixSync(fs.lchownSync);
-      fs.chmodSync = chmodFixSync(fs.chmodSync);
-      fs.fchmodSync = chmodFixSync(fs.fchmodSync);
-      fs.lchmodSync = chmodFixSync(fs.lchmodSync);
-      fs.stat = statFix(fs.stat);
-      fs.fstat = statFix(fs.fstat);
-      fs.lstat = statFix(fs.lstat);
-      fs.statSync = statFixSync(fs.statSync);
-      fs.fstatSync = statFixSync(fs.fstatSync);
-      fs.lstatSync = statFixSync(fs.lstatSync);
-      if (fs.chmod && !fs.lchmod) {
-        fs.lchmod = function(path4, mode, cb) {
+        patchLchmod(fs2);
+      }
+      if (!fs2.lutimes) {
+        patchLutimes(fs2);
+      }
+      fs2.chown = chownFix(fs2.chown);
+      fs2.fchown = chownFix(fs2.fchown);
+      fs2.lchown = chownFix(fs2.lchown);
+      fs2.chmod = chmodFix(fs2.chmod);
+      fs2.fchmod = chmodFix(fs2.fchmod);
+      fs2.lchmod = chmodFix(fs2.lchmod);
+      fs2.chownSync = chownFixSync(fs2.chownSync);
+      fs2.fchownSync = chownFixSync(fs2.fchownSync);
+      fs2.lchownSync = chownFixSync(fs2.lchownSync);
+      fs2.chmodSync = chmodFixSync(fs2.chmodSync);
+      fs2.fchmodSync = chmodFixSync(fs2.fchmodSync);
+      fs2.lchmodSync = chmodFixSync(fs2.lchmodSync);
+      fs2.stat = statFix(fs2.stat);
+      fs2.fstat = statFix(fs2.fstat);
+      fs2.lstat = statFix(fs2.lstat);
+      fs2.statSync = statFixSync(fs2.statSync);
+      fs2.fstatSync = statFixSync(fs2.fstatSync);
+      fs2.lstatSync = statFixSync(fs2.lstatSync);
+      if (fs2.chmod && !fs2.lchmod) {
+        fs2.lchmod = function(path4, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs.lchmodSync = function() {
+        fs2.lchmodSync = function() {
         };
       }
-      if (fs.chown && !fs.lchown) {
-        fs.lchown = function(path4, uid, gid, cb) {
+      if (fs2.chown && !fs2.lchown) {
+        fs2.lchown = function(path4, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs.lchownSync = function() {
+        fs2.lchownSync = function() {
         };
       }
       if (platform3 === "win32") {
-        fs.rename = typeof fs.rename !== "function" ? fs.rename : (function(fs$rename) {
+        fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : (function(fs$rename) {
           function rename6(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs.stat(to, function(stater, st) {
+                  fs2.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -90246,9 +90367,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename6, fs$rename);
           return rename6;
-        })(fs.rename);
+        })(fs2.rename);
       }
-      fs.read = typeof fs.read !== "function" ? fs.read : (function(fs$read) {
+      fs2.read = typeof fs2.read !== "function" ? fs2.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -90256,22 +90377,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _2, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs.read);
-      fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs2.read);
+      fs2.readSync = typeof fs2.readSync !== "function" ? fs2.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs2, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -90281,10 +90402,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs.readSync);
-      function patchLchmod(fs2) {
-        fs2.lchmod = function(path4, mode, callback) {
-          fs2.open(
+      })(fs2.readSync);
+      function patchLchmod(fs3) {
+        fs3.lchmod = function(path4, mode, callback) {
+          fs3.open(
             path4,
             constants2.O_WRONLY | constants2.O_SYMLINK,
             mode,
@@ -90293,80 +90414,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs2.fchmod(fd, mode, function(err2) {
-                fs2.close(fd, function(err22) {
+              fs3.fchmod(fd, mode, function(err2) {
+                fs3.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs2.lchmodSync = function(path4, mode) {
-          var fd = fs2.openSync(path4, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
+        fs3.lchmodSync = function(path4, mode) {
+          var fd = fs3.openSync(path4, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs2.fchmodSync(fd, mode);
+            ret = fs3.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs2.closeSync(fd);
+                fs3.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs2.closeSync(fd);
+              fs3.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs2) {
-        if (constants2.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
-          fs2.lutimes = function(path4, at, mt, cb) {
-            fs2.open(path4, constants2.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs3) {
+        if (constants2.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
+          fs3.lutimes = function(path4, at, mt, cb) {
+            fs3.open(path4, constants2.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs2.futimes(fd, at, mt, function(er2) {
-                fs2.close(fd, function(er22) {
+              fs3.futimes(fd, at, mt, function(er2) {
+                fs3.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs2.lutimesSync = function(path4, at, mt) {
-            var fd = fs2.openSync(path4, constants2.O_SYMLINK);
+          fs3.lutimesSync = function(path4, at, mt) {
+            var fd = fs3.openSync(path4, constants2.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs2.futimesSync(fd, at, mt);
+              ret = fs3.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs2.closeSync(fd);
+                  fs3.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs2.closeSync(fd);
+                fs3.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs2.futimes) {
-          fs2.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs3.futimes) {
+          fs3.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs2.lutimesSync = function() {
+          fs3.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs, target, mode, function(er) {
+          return orig.call(fs2, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -90376,7 +90497,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs, target, mode);
+            return orig.call(fs2, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -90385,7 +90506,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs, target, uid, gid, function(er) {
+          return orig.call(fs2, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -90395,7 +90516,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs, target, uid, gid);
+            return orig.call(fs2, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -90415,13 +90536,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
+          return options ? orig.call(fs2, target, options, callback) : orig.call(fs2, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
+          var stats = options ? orig.call(fs2, target, options) : orig.call(fs2, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -90451,7 +90572,7 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs) {
+    function legacy(fs2) {
       return {
         ReadStream,
         WriteStream
@@ -90494,7 +90615,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs2.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -90533,7 +90654,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs.open;
+          this._open = fs2.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -90569,7 +90690,7 @@ var require_clone = __commonJS({
 var require_graceful_fs = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module) {
     "use strict";
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -90601,12 +90722,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs[gracefulQueue]) {
+    if (!fs2[gracefulQueue]) {
       queue2 = global[gracefulQueue] || [];
-      publishQueue(fs, queue2);
-      fs.close = (function(fs$close) {
+      publishQueue(fs2, queue2);
+      fs2.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs, fd, function(err) {
+          return fs$close.call(fs2, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -90618,40 +90739,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs.close);
-      fs.closeSync = (function(fs$closeSync) {
+      })(fs2.close);
+      fs2.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs, arguments);
+          fs$closeSync.apply(fs2, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs.closeSync);
+      })(fs2.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs[gracefulQueue]);
-          __require("assert").equal(fs[gracefulQueue].length, 0);
+          debug(fs2[gracefulQueue]);
+          __require("assert").equal(fs2[gracefulQueue].length, 0);
         });
       }
     }
     var queue2;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
-      module.exports = patch(fs);
-      fs.__patched = true;
-    }
-    function patch(fs2) {
-      polyfills(fs2);
-      fs2.gracefulify = patch;
-      fs2.createReadStream = createReadStream2;
-      fs2.createWriteStream = createWriteStream2;
-      var fs$readFile = fs2.readFile;
-      fs2.readFile = readFile24;
+      publishQueue(global, fs2[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs2));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs2.__patched) {
+      module.exports = patch(fs2);
+      fs2.__patched = true;
+    }
+    function patch(fs3) {
+      polyfills(fs3);
+      fs3.gracefulify = patch;
+      fs3.createReadStream = createReadStream2;
+      fs3.createWriteStream = createWriteStream2;
+      var fs$readFile = fs3.readFile;
+      fs3.readFile = readFile24;
       function readFile24(path4, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -90667,8 +90788,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs2.writeFile;
-      fs2.writeFile = writeFile16;
+      var fs$writeFile = fs3.writeFile;
+      fs3.writeFile = writeFile16;
       function writeFile16(path4, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -90684,9 +90805,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs2.appendFile;
+      var fs$appendFile = fs3.appendFile;
       if (fs$appendFile)
-        fs2.appendFile = appendFile3;
+        fs3.appendFile = appendFile3;
       function appendFile3(path4, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -90702,9 +90823,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs2.copyFile;
+      var fs$copyFile = fs3.copyFile;
       if (fs$copyFile)
-        fs2.copyFile = copyFile;
+        fs3.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -90722,8 +90843,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs2.readdir;
-      fs2.readdir = readdir11;
+      var fs$readdir = fs3.readdir;
+      fs3.readdir = readdir11;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir11(path4, options, cb) {
         if (typeof options === "function")
@@ -90764,21 +90885,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs2);
+        var legStreams = legacy(fs3);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs2.ReadStream;
+      var fs$ReadStream = fs3.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs2.WriteStream;
+      var fs$WriteStream = fs3.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs2, "ReadStream", {
+      Object.defineProperty(fs3, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -90788,7 +90909,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs2, "WriteStream", {
+      Object.defineProperty(fs3, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -90799,7 +90920,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs2, "FileReadStream", {
+      Object.defineProperty(fs3, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -90810,7 +90931,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs2, "FileWriteStream", {
+      Object.defineProperty(fs3, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -90859,13 +90980,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream2(path4, options) {
-        return new fs2.ReadStream(path4, options);
+        return new fs3.ReadStream(path4, options);
       }
       function createWriteStream2(path4, options) {
-        return new fs2.WriteStream(path4, options);
+        return new fs3.WriteStream(path4, options);
       }
-      var fs$open = fs2.open;
-      fs2.open = open;
+      var fs$open = fs3.open;
+      fs3.open = open;
       function open(path4, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -90881,20 +91002,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs2;
+      return fs3;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs[gracefulQueue].push(elem);
+      fs2[gracefulQueue].push(elem);
       retry2();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs[gracefulQueue].length; ++i) {
-        if (fs[gracefulQueue][i].length > 2) {
-          fs[gracefulQueue][i][3] = now;
-          fs[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs2[gracefulQueue].length; ++i) {
+        if (fs2[gracefulQueue][i].length > 2) {
+          fs2[gracefulQueue][i][3] = now;
+          fs2[gracefulQueue][i][4] = now;
         }
       }
       retry2();
@@ -90902,9 +91023,9 @@ var require_graceful_fs = __commonJS({
     function retry2() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs[gracefulQueue].length === 0)
+      if (fs2[gracefulQueue].length === 0)
         return;
-      var elem = fs[gracefulQueue].shift();
+      var elem = fs2[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -90926,7 +91047,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs[gracefulQueue].push(elem);
+          fs2[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -106119,8 +106240,8 @@ var require_commonjs4 = __commonJS({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep6, { nocase, childrenCacheSize = 16 * 1024, fs = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs);
+      constructor(cwd = process.cwd(), pathImpl, sep6, { nocase, childrenCacheSize = 16 * 1024, fs: fs2 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs2);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = (0, node_url_1.fileURLToPath)(cwd);
         }
@@ -106679,8 +106800,8 @@ var require_commonjs4 = __commonJS({
       /**
        * @internal
        */
-      newRoot(fs) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs });
+      newRoot(fs2) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs2 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -106709,8 +106830,8 @@ var require_commonjs4 = __commonJS({
       /**
        * @internal
        */
-      newRoot(fs) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs });
+      newRoot(fs2) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs2 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -107896,7 +108017,7 @@ var require_commonjs5 = __commonJS({
 var require_file = __commonJS({
   "../../node_modules/.pnpm/archiver-utils@5.0.2/node_modules/archiver-utils/file.js"(exports, module) {
     "use strict";
-    var fs = require_graceful_fs();
+    var fs2 = require_graceful_fs();
     var path4 = __require("path");
     var flatten = require_flatten();
     var difference = require_difference();
@@ -107923,7 +108044,7 @@ var require_file = __commonJS({
     };
     file.exists = function() {
       var filepath = path4.join.apply(path4, arguments);
-      return fs.existsSync(filepath);
+      return fs2.existsSync(filepath);
     };
     file.expand = function(...args) {
       var options = isPlainObject(args[0]) ? args.shift() : {};
@@ -107941,7 +108062,7 @@ var require_file = __commonJS({
             if (typeof options.filter === "function") {
               return options.filter(filepath);
             } else {
-              return fs.statSync(filepath)[options.filter]();
+              return fs2.statSync(filepath)[options.filter]();
             }
           } catch (e) {
             return false;
@@ -108050,7 +108171,7 @@ var require_file = __commonJS({
 var require_archiver_utils = __commonJS({
   "../../node_modules/.pnpm/archiver-utils@5.0.2/node_modules/archiver-utils/index.js"(exports, module) {
     "use strict";
-    var fs = require_graceful_fs();
+    var fs2 = require_graceful_fs();
     var path4 = __require("path");
     var isStream = require_is_stream();
     var lazystream = require_lazystream();
@@ -108099,7 +108220,7 @@ var require_archiver_utils = __commonJS({
     };
     utils.lazyReadStream = function(filepath) {
       return new lazystream.Readable(function() {
-        return fs.createReadStream(filepath);
+        return fs2.createReadStream(filepath);
       });
     };
     utils.normalizeInputSource = function(source) {
@@ -108127,7 +108248,7 @@ var require_archiver_utils = __commonJS({
         callback = base;
         base = dirpath;
       }
-      fs.readdir(dirpath, function(err, list) {
+      fs2.readdir(dirpath, function(err, list) {
         var i = 0;
         var file;
         var filepath;
@@ -108140,7 +108261,7 @@ var require_archiver_utils = __commonJS({
             return callback(null, results);
           }
           filepath = path4.join(dirpath, file);
-          fs.stat(filepath, function(err2, stats) {
+          fs2.stat(filepath, function(err2, stats) {
             results.push({
               path: filepath,
               relative: path4.relative(base, filepath).replace(/\\/g, "/"),
@@ -108204,7 +108325,7 @@ var require_error = __commonJS({
 var require_core = __commonJS({
   "../../node_modules/.pnpm/archiver@7.0.1/node_modules/archiver/lib/core.js"(exports, module) {
     "use strict";
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var glob2 = require_readdir_glob();
     var async = (init_async(), __toCommonJS(async_exports));
     var path4 = __require("path");
@@ -108268,7 +108389,7 @@ var require_core = __commonJS({
       data.sourcePath = filepath;
       task.data = data;
       this._entriesCount++;
-      if (data.stats && data.stats instanceof fs.Stats) {
+      if (data.stats && data.stats instanceof fs2.Stats) {
         task = this._updateQueueTaskWithStats(task, data.stats);
         if (task) {
           if (data.stats.size) {
@@ -108439,7 +108560,7 @@ var require_core = __commonJS({
         callback();
         return;
       }
-      fs.lstat(task.filepath, function(err, stats) {
+      fs2.lstat(task.filepath, function(err, stats) {
         if (this._state.aborted) {
           setImmediate(callback);
           return;
@@ -108482,7 +108603,7 @@ var require_core = __commonJS({
         task.data.sourceType = "buffer";
         task.source = Buffer.concat([]);
       } else if (stats.isSymbolicLink() && this._moduleSupports("symlink")) {
-        var linkPath = fs.readlinkSync(task.filepath);
+        var linkPath = fs2.readlinkSync(task.filepath);
         var dirName = path4.dirname(task.filepath);
         task.data.type = "symlink";
         task.data.linkname = path4.relative(dirName, path4.resolve(dirName, linkPath));
@@ -121468,6 +121589,34 @@ Description: ${step.description}`
       rethrowAsApiError3(err);
     }
   });
+  const TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set(["done", "archived"]);
+  function isTerminalTaskStatus(status) {
+    return status !== void 0 && TERMINAL_TASK_STATUSES.has(status);
+  }
+  async function sanitizeAgentTaskLinks(agents, scopedStore) {
+    const taskIds = [...new Set(agents.map((a) => a.taskId).filter((id) => id !== void 0))];
+    const taskStatusMap = /* @__PURE__ */ new Map();
+    await Promise.all(
+      taskIds.map(async (taskId) => {
+        try {
+          const task = await scopedStore.getTask(taskId);
+          if (task) {
+            taskStatusMap.set(taskId, task.column);
+          }
+        } catch {
+        }
+      })
+    );
+    return agents.map((agent) => {
+      if (!agent.taskId) return agent;
+      const taskStatus = taskStatusMap.get(agent.taskId);
+      if (isTerminalTaskStatus(taskStatus)) {
+        const { taskId: _omitted, ...sanitized } = agent;
+        return sanitized;
+      }
+      return agent;
+    });
+  }
   router.get("/agents", async (req, res) => {
     try {
       const filter2 = {};
@@ -121485,7 +121634,8 @@ Description: ${step.description}`
       const agentStore = new AgentStore2({ rootDir: scopedStore.getFusionDir() });
       await agentStore.init();
       const agents = await agentStore.listAgents(filter2);
-      res.json(agents);
+      const sanitizedAgents = await sanitizeAgentTaskLinks(agents, scopedStore);
+      res.json(sanitizedAgents);
     } catch (err) {
       if (err instanceof ApiError) {
         throw err;
@@ -122180,7 +122330,8 @@ ${body}`;
       await agentStore.init();
       const agents = await agentStore.listAgents();
       const activeCount = agents.filter((a) => a.state === "active" || a.state === "running").length;
-      const assignedTaskCount = agents.filter((a) => a.taskId).length;
+      const sanitizedAgents = await sanitizeAgentTaskLinks(agents, scopedStore);
+      const assignedTaskCount = sanitizedAgents.filter((a) => a.taskId).length;
       let completedRuns = 0;
       let failedRuns = 0;
       for (const agent of agents) {
@@ -122242,7 +122393,8 @@ ${body}`;
       if (!agent) {
         throw notFound("Agent not found");
       }
-      res.json(agent);
+      const [sanitizedAgent] = await sanitizeAgentTaskLinks([agent], scopedStore);
+      res.json(sanitizedAgent);
     } catch (err) {
       if (err instanceof ApiError) {
         throw err;
@@ -131577,6 +131729,9 @@ function isApiPath(path4) {
   return path4 === "/api" || path4.startsWith("/api/");
 }
 function getDaemonToken(options) {
+  if (options?.noAuth) {
+    return void 0;
+  }
   if (options?.daemon?.token) {
     return options.daemon.token;
   }
@@ -131800,7 +131955,7 @@ function createServer(store, options) {
       }
     }
   }));
-  const daemonToken = options?.daemon?.token ?? process.env.FUSION_DAEMON_TOKEN;
+  const daemonToken = options?.noAuth ? void 0 : options?.daemon?.token ?? process.env.FUSION_DAEMON_TOKEN;
   if (daemonToken) {
     app.use(createAuthMiddleware(daemonToken));
   }
@@ -132143,7 +132298,7 @@ function setupTerminalWebSocket(app, server, store, options) {
     if (pathname !== "/api/terminal/ws") {
       return;
     }
-    if (wsDaemonToken && !authenticateUpgradeRequest(wsDaemonToken, req)) {
+    if (wsDaemonToken && !options?.noAuth && !authenticateUpgradeRequest(wsDaemonToken, req)) {
       socket.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
       socket.destroy();
       return;
@@ -132334,7 +132489,7 @@ function setupBadgeWebSocket(app, server, store, options) {
     if (pathname !== "/api/ws") {
       return;
     }
-    if (badgeWsDaemonToken && !authenticateUpgradeRequest(badgeWsDaemonToken, req)) {
+    if (badgeWsDaemonToken && !options?.noAuth && !authenticateUpgradeRequest(badgeWsDaemonToken, req)) {
       socket.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
       socket.destroy();
       return;
@@ -133593,6 +133748,696 @@ var init_project_context = __esm({
   }
 });
 
+// src/commands/dashboard-tui.ts
+import * as readline from "node:readline";
+function moveCursorTo(x, y) {
+  process.stdout.write(`\x1B[${y};${x}H`);
+}
+function clearLine() {
+  process.stdout.write("\x1B[2K");
+}
+function clearScreen() {
+  process.stdout.write("\x1B[2J");
+}
+function hideCursor() {
+  process.stdout.write("\x1B[?25l");
+}
+function showCursor() {
+  process.stdout.write("\x1B[?25h");
+}
+function enableAlternateScreen() {
+  process.stdout.write("\x1B[?47h");
+}
+function disableAlternateScreen() {
+  process.stdout.write("\x1B[?47l");
+}
+function colorize(text, color) {
+  const colors = {
+    reset: "\x1B[0m",
+    bold: "\x1B[1m",
+    dim: "\x1B[2m",
+    red: "\x1B[31m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    magenta: "\x1B[35m",
+    cyan: "\x1B[36m",
+    white: "\x1B[37m",
+    gray: "\x1B[90m",
+    brightRed: "\x1B[91m",
+    brightGreen: "\x1B[92m",
+    brightYellow: "\x1B[93m",
+    brightBlue: "\x1B[94m",
+    brightMagenta: "\x1B[95m",
+    brightCyan: "\x1B[96m"
+  };
+  return `${colors[color] || ""}${text}${colors.reset}`;
+}
+function formatTimestamp3(date) {
+  const h = date.getHours().toString().padStart(2, "0");
+  const m = date.getMinutes().toString().padStart(2, "0");
+  const s = date.getSeconds().toString().padStart(2, "0");
+  const ms = date.getMilliseconds().toString().padStart(3, "0");
+  return `${h}:${m}:${s}.${ms}`;
+}
+function formatUptime(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h ${minutes % 60}m`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+function visibleLength(str) {
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").length;
+}
+function visibleTruncate(text, maxWidth) {
+  if (maxWidth <= 0) return "";
+  const currentLength = visibleLength(text);
+  if (currentLength <= maxWidth) return text;
+  const ansiRegex = /\x1b\[[0-9;]*[a-zA-Z]/g;
+  let result = "";
+  let visibleCount = 0;
+  let match;
+  const ansiMatches = [];
+  while ((match = ansiRegex.exec(text)) !== null) {
+    ansiMatches.push({
+      start: match.index,
+      end: match.index + match[0].length,
+      seq: match[0]
+    });
+  }
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const ansiMatch = ansiMatches.find((m) => m.start === i);
+    if (ansiMatch) {
+      result += ansiMatch.seq;
+      continue;
+    }
+    visibleCount++;
+    result += char;
+    if (visibleCount >= maxWidth - 3) {
+      break;
+    }
+  }
+  if (visibleCount >= maxWidth - 3 && visibleCount < currentLength) {
+    result += "...";
+  }
+  return result;
+}
+function centerText(text, width, padChar = " ") {
+  const visibleLen = visibleLength(text);
+  const padding = Math.max(0, width - visibleLen);
+  const leftPad = Math.floor(padding / 2);
+  const rightPad = padding - leftPad;
+  return padChar.repeat(leftPad) + text + padChar.repeat(rightPad);
+}
+function padRight(text, width) {
+  if (width <= 0) return "";
+  const visibleLen = visibleLength(text);
+  return text + " ".repeat(Math.max(0, width - visibleLen));
+}
+function isTTYAvailable() {
+  return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+var MAX_LOG_ENTRIES, LogRingBuffer, SECTION_ORDER, DashboardTUI, DashboardLogSink;
+var init_dashboard_tui = __esm({
+  "src/commands/dashboard-tui.ts"() {
+    "use strict";
+    MAX_LOG_ENTRIES = 1e3;
+    LogRingBuffer = class {
+      entries = [];
+      count = 0;
+      push(entry) {
+        if (this.entries.length < MAX_LOG_ENTRIES) {
+          this.entries.push(entry);
+        } else {
+          this.entries[this.count % MAX_LOG_ENTRIES] = entry;
+        }
+        this.count++;
+      }
+      getAll() {
+        if (this.count <= MAX_LOG_ENTRIES) {
+          return this.entries.slice();
+        }
+        const start = this.count % MAX_LOG_ENTRIES;
+        return [
+          ...this.entries.slice(start),
+          ...this.entries.slice(0, start)
+        ];
+      }
+      clear() {
+        this.entries = [];
+        this.count = 0;
+      }
+      get total() {
+        return this.count;
+      }
+    };
+    SECTION_ORDER = ["logs", "system", "utilities", "stats", "settings"];
+    DashboardTUI = class {
+      activeSection = "logs";
+      logBuffer;
+      systemInfo = null;
+      taskStats = null;
+      settings = null;
+      callbacks = null;
+      isRunning = false;
+      rl = null;
+      originalHandlers = /* @__PURE__ */ new Map();
+      lastRenderHeight = 0;
+      showHelp = false;
+      uptimeTimer = null;
+      resizeHandler = null;
+      constructor() {
+        this.logBuffer = new LogRingBuffer();
+      }
+      // ── Public API ─────────────────────────────────────────────────────────────
+      /** Returns whether the TUI is currently running */
+      get running() {
+        return this.isRunning;
+      }
+      setCallbacks(callbacks) {
+        this.callbacks = callbacks;
+      }
+      setSystemInfo(info) {
+        this.systemInfo = info;
+        this.render();
+      }
+      setTaskStats(stats) {
+        this.taskStats = stats;
+        this.render();
+      }
+      setSettings(settings) {
+        this.settings = settings;
+        this.render();
+      }
+      addLog(entry) {
+        this.logBuffer.push({
+          ...entry,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        this.render();
+      }
+      log(message, prefix) {
+        this.addLog({ level: "info", message, prefix });
+      }
+      warn(message, prefix) {
+        this.addLog({ level: "warn", message, prefix });
+      }
+      error(message, prefix) {
+        this.addLog({ level: "error", message, prefix });
+      }
+      async start() {
+        if (this.isRunning) return;
+        this.isRunning = true;
+        enableAlternateScreen();
+        hideCursor();
+        this.saveSignalHandlers();
+        this.rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+          terminal: true
+        });
+        process.stdin.setRawMode?.(true);
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.on("keypress", (str, key) => {
+          if (str) {
+            this.handleKeypress(str);
+          } else if (key.ctrl && key.name === "c") {
+            this.handleKeypress("");
+          } else if (key.name === "right") {
+            this.handleKeypress("\x1B[C");
+          } else if (key.name === "left") {
+            this.handleKeypress("\x1B[D");
+          } else if (key.name === "up") {
+            this.handleKeypress("\x1B[A");
+          } else if (key.name === "down") {
+            this.handleKeypress("\x1B[B");
+          } else if (key.name === "escape") {
+            this.handleKeypress("\x1B");
+          }
+        });
+        this.uptimeTimer = setInterval(() => {
+          if (this.isRunning) {
+            this.renderFooter();
+          }
+        }, 5e3);
+        this.resizeHandler = () => {
+          if (this.isRunning) {
+            this.render();
+          }
+        };
+        process.stdout.on("resize", this.resizeHandler);
+        this.render();
+      }
+      async stop() {
+        if (!this.isRunning) return;
+        this.isRunning = false;
+        if (this.uptimeTimer) {
+          clearInterval(this.uptimeTimer);
+          this.uptimeTimer = null;
+        }
+        if (this.resizeHandler) {
+          process.stdout.off("resize", this.resizeHandler);
+          this.resizeHandler = null;
+        }
+        this.restoreTerminal();
+        this.restoreSignalHandlers();
+        if (this.rl) {
+          this.rl.close();
+          this.rl = null;
+        }
+      }
+      // ── Private: Signal Handling ───────────────────────────────────────────────
+      saveSignalHandlers() {
+        const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+        for (const sig of signals) {
+          const listeners = process.listeners(sig);
+          if (listeners.length > 0) {
+            this.originalHandlers.set(sig, listeners[listeners.length - 1]);
+          }
+        }
+      }
+      restoreSignalHandlers() {
+        for (const [sig, handler] of this.originalHandlers) {
+          process.on(sig, handler);
+        }
+        this.originalHandlers.clear();
+      }
+      // ── Private: Terminal Restoration ────────────────────────────────────────
+      restoreTerminal() {
+        showCursor();
+        disableAlternateScreen();
+        process.stdout.write("\n");
+        process.stdin.pause?.();
+        process.stdin.setRawMode?.(false);
+      }
+      // ── Private: Key Handling ────────────────────────────────────────────────
+      handleKeypress(key) {
+        if (key === "") {
+          void this.stop();
+          process.exit(0);
+          return;
+        }
+        if (key === "q" || key === "Q") {
+          void this.stop();
+          process.exit(0);
+          return;
+        }
+        if (key === "?" || key === "h" || key === "H") {
+          this.showHelp = !this.showHelp;
+          this.render();
+          return;
+        }
+        if (key >= "1" && key <= "5") {
+          const index2 = parseInt(key, 10) - 1;
+          if (index2 >= 0 && index2 < SECTION_ORDER.length) {
+            this.activeSection = SECTION_ORDER[index2];
+            this.showHelp = false;
+            this.render();
+          }
+          return;
+        }
+        if (key === "\x1B[C" || key === "n" || key === "N") {
+          const currentIndex = SECTION_ORDER.indexOf(this.activeSection);
+          this.activeSection = SECTION_ORDER[(currentIndex + 1) % SECTION_ORDER.length];
+          this.showHelp = false;
+          this.render();
+          return;
+        }
+        if (key === "\x1B[D" || key === "p" || key === "P") {
+          const currentIndex = SECTION_ORDER.indexOf(this.activeSection);
+          this.activeSection = SECTION_ORDER[(currentIndex - 1 + SECTION_ORDER.length) % SECTION_ORDER.length];
+          this.showHelp = false;
+          this.render();
+          return;
+        }
+        if (this.activeSection === "utilities") {
+          this.handleUtilityKeypress(key);
+        }
+      }
+      async handleUtilityKeypress(key) {
+        if (!this.callbacks) return;
+        switch (key.toLowerCase()) {
+          case "r":
+            await this.callbacks.onRefreshStats();
+            break;
+          case "c":
+            this.callbacks.onClearLogs();
+            this.logBuffer.clear();
+            this.render();
+            break;
+          case "t":
+            if (this.systemInfo) {
+              const newPaused = this.systemInfo.engineMode !== "paused";
+              const newSettings = await this.callbacks.onTogglePause(newPaused);
+              const newEngineMode = newSettings.enginePaused ? "paused" : "active";
+              this.setSystemInfo({ ...this.systemInfo, engineMode: newEngineMode });
+              this.setSettings(newSettings);
+            }
+            break;
+        }
+      }
+      // ── Private: Rendering ───────────────────────────────────────────────────
+      render() {
+        if (!this.isRunning) return;
+        clearScreen();
+        moveCursorTo(1, 1);
+        this.renderHeader();
+        this.renderSection();
+        this.renderFooter();
+        if (this.showHelp) {
+          this.renderHelpOverlay();
+        }
+      }
+      renderHeader() {
+        const cols = process.stdout.columns || 80;
+        const title = colorize("  fn board  ", "cyan");
+        const titleLen = visibleLength(title);
+        process.stdout.write(title);
+        if (cols >= 70) {
+          for (let i = 0; i < SECTION_ORDER.length; i++) {
+            const section = SECTION_ORDER[i];
+            const isActive = section === this.activeSection;
+            const num = (i + 1).toString();
+            const label = section.charAt(0).toUpperCase() + section.slice(1);
+            const tabText = `[${num}] ${label}`;
+            const style = isActive ? "brightBlue" : "dim";
+            process.stdout.write(colorize(` ${tabText} `, style));
+          }
+        } else if (cols >= 40) {
+          const shortLabels = {
+            logs: "L",
+            system: "S",
+            utilities: "U",
+            stats: "St",
+            settings: "Se"
+          };
+          for (let i = 0; i < SECTION_ORDER.length; i++) {
+            const section = SECTION_ORDER[i];
+            const isActive = section === this.activeSection;
+            const num = (i + 1).toString();
+            const shortLabel = shortLabels[section];
+            const tabText = `[${num}]${shortLabel}`;
+            const style = isActive ? "brightBlue" : "dim";
+            process.stdout.write(colorize(` ${tabText} `, style));
+          }
+        } else {
+          const activeIndex = SECTION_ORDER.indexOf(this.activeSection);
+          const activeLabel = this.activeSection.charAt(0).toUpperCase() + this.activeSection.slice(1);
+          process.stdout.write(colorize(` [${activeIndex + 1}]${activeLabel} `, "brightBlue"));
+          process.stdout.write(colorize(" [n/p]nav ", "dim"));
+        }
+        const tabsLength = SECTION_ORDER.reduce((acc, s, i) => {
+          let label;
+          if (cols >= 70) {
+            label = s.charAt(0).toUpperCase() + s.slice(1);
+          } else if (cols >= 40) {
+            const shortLabels = {
+              logs: "L",
+              system: "S",
+              utilities: "U",
+              stats: "St",
+              settings: "Se"
+            };
+            label = shortLabels[s];
+          } else {
+            label = s.charAt(0).toUpperCase() + s.slice(1);
+          }
+          const tabText = `[${i + 1}]${label} `;
+          return acc + tabText.length;
+        }, 0);
+        const headerLen = titleLen + tabsLength;
+        const remaining = cols - headerLen;
+        if (remaining > 0) {
+          process.stdout.write(" ".repeat(remaining));
+        }
+        process.stdout.write("\n");
+        process.stdout.write(colorize("\u2500".repeat(Math.max(20, cols)), "dim") + "\n");
+      }
+      renderSection() {
+        switch (this.activeSection) {
+          case "logs":
+            this.renderLogsSection();
+            break;
+          case "system":
+            this.renderSystemSection();
+            break;
+          case "utilities":
+            this.renderUtilitiesSection();
+            break;
+          case "stats":
+            this.renderStatsSection();
+            break;
+          case "settings":
+            this.renderSettingsSection();
+            break;
+        }
+      }
+      renderLogsSection() {
+        const cols = process.stdout.columns || 80;
+        const entries = this.logBuffer.getAll();
+        const maxRows = Math.max(1, (process.stdout.rows ?? 38) - 8);
+        process.stdout.write(colorize("\n  LOGS\n", "bold"));
+        process.stdout.write(colorize(`  Ring buffer: ${this.logBuffer.total}/${MAX_LOG_ENTRIES} entries
+
+`, "dim"));
+        if (entries.length === 0) {
+          process.stdout.write(colorize("  No log entries yet.\n", "dim"));
+          return;
+        }
+        const displayEntries = entries.slice(-maxRows).reverse();
+        for (const entry of displayEntries) {
+          const ts = colorize(formatTimestamp3(entry.timestamp), "dim");
+          const prefix = entry.prefix ? colorize(`[${entry.prefix}]`, "gray") : "";
+          const levelChar = entry.level === "error" ? colorize("\u2717", "brightRed") : entry.level === "warn" ? colorize("\u26A0", "brightYellow") : colorize("\u2713", "brightGreen");
+          const messageWidth = Math.max(8, cols - 40);
+          const message = visibleTruncate(entry.message, messageWidth);
+          const line = `  ${ts} ${levelChar} ${prefix ? prefix + " " : ""}${message}`;
+          process.stdout.write(visibleTruncate(line, cols - 1) + "\n");
+        }
+      }
+      renderSystemSection() {
+        if (!this.systemInfo) {
+          process.stdout.write(colorize("\n  System information not available.\n", "dim"));
+          return;
+        }
+        const cols = process.stdout.columns || 80;
+        const info = this.systemInfo;
+        const rows = [];
+        rows.push(colorize("\n  SYSTEM INFORMATION\n", "bold"));
+        rows.push("");
+        const labelWidth = 12;
+        const availableValueWidth = Math.max(8, cols - labelWidth - 1);
+        rows.push(`  ${colorize("Host:", "white")} ${info.host}`);
+        rows.push(`  ${colorize("Port:", "white")} ${info.port}`);
+        rows.push(`  ${colorize("URL:", "white")} ${colorize(visibleTruncate(info.baseUrl, availableValueWidth), "brightCyan")}`);
+        rows.push("");
+        if (info.authEnabled) {
+          rows.push(`  ${colorize("Auth:", "white")} ${colorize("bearer token required", "yellow")}`);
+          if (info.authToken) {
+            rows.push(`  ${colorize("Token:", "white")} ${visibleTruncate(info.authToken, availableValueWidth)}`);
+          }
+          if (info.tokenizedUrl) {
+            rows.push(`  ${colorize("Open:", "white")} ${visibleTruncate(info.tokenizedUrl, availableValueWidth)}`);
+            rows.push(colorize("  (browser stores token, click once)", "dim"));
+          }
+        } else {
+          rows.push(`  ${colorize("Auth:", "white")} ${colorize("disabled (--no-auth)", "dim")}`);
+        }
+        rows.push("");
+        rows.push(`  ${colorize("AI Engine:", "white")} ${info.engineMode === "dev" ? colorize("\u2717 disabled (dev mode)", "yellow") : info.engineMode === "paused" ? colorize("\u23F8 paused", "brightYellow") : colorize("\u2713 active", "brightGreen")}`);
+        rows.push(`  ${colorize("File Watcher:", "white")} ${info.fileWatcher ? colorize("\u2713 active", "brightGreen") : colorize("\u2717 inactive", "brightRed")}`);
+        rows.push(`  ${colorize("Uptime:", "white")} ${formatUptime(Date.now() - info.startTimeMs)}`);
+        for (const row of rows) {
+          process.stdout.write(visibleTruncate(row, cols) + "\n");
+        }
+      }
+      renderUtilitiesSection() {
+        const cols = process.stdout.columns || 80;
+        const actions = [
+          { id: "refresh", label: "Refresh Stats", key: "r", description: "Re-fetch task and agent counts" },
+          { id: "clear", label: "Clear Logs", key: "c", description: "Clear the log ring buffer" },
+          { id: "pause", label: "Toggle Engine Pause", key: "t", description: "Pause/resume AI engine automation" },
+          { id: "help", label: "Help", key: "?", description: "Show keyboard shortcuts" }
+        ];
+        process.stdout.write(colorize("\n  UTILITIES\n", "bold"));
+        process.stdout.write(colorize("  Press key to execute action\n\n", "dim"));
+        const prefixWidth = 2 + 3 + 1 + 20 + 3;
+        const descriptionWidth = Math.max(8, cols - prefixWidth - 1);
+        for (const action of actions) {
+          const keyDisplay = colorize(`[${action.key}]`, "brightYellow");
+          const label = colorize(action.label.padEnd(20), "white");
+          const description = visibleTruncate(action.description, descriptionWidth);
+          const line = `  ${keyDisplay} ${label} - ${description}`;
+          process.stdout.write(visibleTruncate(line, cols - 1) + "\n");
+        }
+      }
+      renderStatsSection() {
+        const cols = process.stdout.columns || 80;
+        if (!this.taskStats) {
+          process.stdout.write(colorize("\n  Statistics not available.\n", "dim"));
+          return;
+        }
+        const stats = this.taskStats;
+        const rows = [];
+        rows.push(colorize("\n  STATISTICS\n", "bold"));
+        rows.push("");
+        rows.push(`  ${colorize("Total Tasks:", "white")} ${stats.total}`);
+        rows.push("");
+        rows.push(`  ${colorize("By Column:", "dim")}`);
+        for (const [column, count] of Object.entries(stats.byColumn)) {
+          const colName = column.replace("-", " ").replace(/\b\w/g, (l) => l.toUpperCase());
+          const activeMark = (column === "in-progress" || column === "in-review") && count > 0 ? colorize(" \u25CF", "brightGreen") : "";
+          rows.push(`    ${colName}: ${count}${activeMark}`);
+        }
+        rows.push("");
+        rows.push(`  ${colorize("Active Tasks:", "white")} ${stats.active} (in-progress + in-review)`);
+        rows.push("");
+        rows.push(`  ${colorize("Agents:", "dim")}`);
+        rows.push(`    Idle:    ${stats.agents.idle}`);
+        rows.push(`    Active:  ${stats.agents.active}`);
+        rows.push(`    Running: ${stats.agents.running}`);
+        rows.push(`    Error:   ${stats.agents.error}`);
+        for (const row of rows) {
+          process.stdout.write(visibleTruncate(row, cols) + "\n");
+        }
+      }
+      renderSettingsSection() {
+        const cols = process.stdout.columns || 80;
+        if (!this.settings) {
+          process.stdout.write(colorize("\n  Settings not available.\n", "dim"));
+          return;
+        }
+        const s = this.settings;
+        const rows = [];
+        rows.push(colorize("\n  SETTINGS\n", "bold"));
+        rows.push("");
+        const settingsList = [
+          ["maxConcurrent", s.maxConcurrent.toString()],
+          ["maxWorktrees", s.maxWorktrees.toString()],
+          ["autoMerge", s.autoMerge ? "enabled" : "disabled"],
+          ["mergeStrategy", s.mergeStrategy],
+          ["pollIntervalMs", `${s.pollIntervalMs}ms`],
+          ["enginePaused", s.enginePaused ? "yes" : "no"],
+          ["globalPause", s.globalPause ? "yes" : "no"]
+        ];
+        const keyWidth = Math.max(...settingsList.map(([k]) => k.length));
+        for (const [key, value] of settingsList) {
+          const keyPad = key.padEnd(keyWidth);
+          const isEnabled = value === "enabled" || value === "yes";
+          const isDisabled = value === "disabled" || value === "no";
+          const valueColor = isEnabled ? "brightGreen" : isDisabled ? "brightYellow" : "white";
+          rows.push(`  ${colorize(keyPad, "gray")}  ${colorize(value, valueColor)}`);
+        }
+        for (const row of rows) {
+          process.stdout.write(visibleTruncate(row, cols) + "\n");
+        }
+      }
+      renderFooter() {
+        const cols = process.stdout.columns || 80;
+        const footerY = Math.max(1, (process.stdout.rows ?? 22) - 2);
+        moveCursorTo(1, footerY);
+        clearLine();
+        const status = this.systemInfo ? `${this.systemInfo.baseUrl} | ${formatUptime(Date.now() - this.systemInfo.startTimeMs)}` : "";
+        const left = colorize("Press ? for help", "dim");
+        const right = colorize(visibleTruncate(status, Math.max(20, cols - 20)), "dim");
+        const leftLen = visibleLength(left);
+        const rightLen = visibleLength(right);
+        process.stdout.write(left);
+        const padding = Math.max(1, cols - leftLen - rightLen - 2);
+        process.stdout.write(" ".repeat(padding));
+        process.stdout.write(right);
+        process.stdout.write("\n");
+      }
+      renderHelpOverlay() {
+        const cols = process.stdout.columns || 80;
+        const rows = process.stdout.rows || 24;
+        const boxWidth = Math.min(62, Math.max(cols - 4, 20));
+        const useBoxDrawing = cols >= boxWidth + 4;
+        let helpLines;
+        if (useBoxDrawing) {
+          helpLines = [
+            colorize("\u250C" + "\u2500".repeat(boxWidth) + "\u2510", "brightBlue"),
+            colorize("\u2502" + centerText("KEYBOARD SHORTCUTS", boxWidth, " ") + "\u2502", "brightBlue"),
+            colorize("\u251C" + "\u2500".repeat(boxWidth) + "\u2524", "brightBlue"),
+            colorize("\u2502  [1-5]       Switch to tab by number" + padRight("", boxWidth - 39) + "\u2502", "white"),
+            colorize("\u2502  [n] / \u2192     Next tab" + padRight("", boxWidth - 25) + "\u2502", "white"),
+            colorize("\u2502  [p] / \u2190     Previous tab" + padRight("", boxWidth - 27) + "\u2502", "white"),
+            colorize("\u2502  [r]         Refresh stats (Utilities)" + padRight("", boxWidth - 36) + "\u2502", "white"),
+            colorize("\u2502  [c]         Clear logs (Utilities)" + padRight("", boxWidth - 33) + "\u2502", "white"),
+            colorize("\u2502  [t]         Toggle engine pause (Utilities)" + padRight("", boxWidth - 42) + "\u2502", "white"),
+            colorize("\u2502  [?] / [h]   Toggle help" + padRight("", boxWidth - 24) + "\u2502", "white"),
+            colorize("\u2502  [q]         Quit" + padRight("", boxWidth - 15) + "\u2502", "white"),
+            colorize("\u2502  [Ctrl+C]    Force quit" + padRight("", boxWidth - 22) + "\u2502", "white"),
+            colorize("\u2514" + "\u2500".repeat(boxWidth) + "\u2518", "brightBlue")
+          ];
+        } else {
+          const maxLineWidth = cols - 2;
+          helpLines = [
+            visibleTruncate(colorize("KEYBOARD SHORTCUTS", "brightBlue"), maxLineWidth),
+            visibleTruncate(colorize("  [1-5] Switch tab | [n/p] Next/Prev | [q] Quit", "white"), maxLineWidth),
+            visibleTruncate(colorize("  [r] Refresh | [c] Clear logs | [t] Toggle engine", "white"), maxLineWidth),
+            visibleTruncate(colorize("  [?/h] Help | [Ctrl+C] Force quit", "white"), maxLineWidth)
+          ];
+        }
+        const compactBoxWidth = useBoxDrawing ? boxWidth : Math.max(...helpLines.map(visibleLength));
+        const boxHeight = helpLines.length;
+        const safeStartX = Math.max(1, Math.floor((cols - compactBoxWidth) / 2));
+        const safeStartY = Math.max(1, Math.floor((rows - boxHeight) / 2));
+        const clearTop = Math.max(1, safeStartY - 1);
+        const clearBottom = Math.min(rows, safeStartY + boxHeight);
+        for (let y = clearTop; y <= clearBottom; y++) {
+          moveCursorTo(1, y);
+          clearLine();
+        }
+        for (let i = 0; i < helpLines.length; i++) {
+          moveCursorTo(safeStartX, safeStartY + i);
+          process.stdout.write(helpLines[i]);
+        }
+      }
+    };
+    DashboardLogSink = class {
+      tui = null;
+      isTTY;
+      constructor(tui) {
+        this.tui = tui ?? null;
+        this.isTTY = tui?.running ?? false;
+      }
+      setTUI(tui) {
+        this.tui = tui;
+        this.isTTY = true;
+      }
+      log(message, prefix) {
+        if (this.tui && this.isTTY) {
+          this.tui.log(message, prefix);
+        } else {
+          console.log(prefix ? `[${prefix}] ${message}` : message);
+        }
+      }
+      warn(message, prefix) {
+        if (this.tui && this.isTTY) {
+          this.tui.warn(message, prefix);
+        } else {
+          console.warn(prefix ? `[${prefix}] ${message}` : message);
+        }
+      }
+      error(message, prefix) {
+        if (this.tui && this.isTTY) {
+          this.tui.error(message, prefix);
+        } else {
+          console.error(prefix ? `[${prefix}] ${message}` : message);
+        }
+      }
+    };
+  }
+});
+
 // src/commands/dashboard.ts
 var dashboard_exports = {};
 __export(dashboard_exports, {
@@ -133608,7 +134453,7 @@ function formatBytes2(bytes) {
   if (bytes < 1024 * 1024 * 1024) return `${Math.round(bytes / (1024 * 1024))}MB`;
   return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
 }
-function formatUptime(ms) {
+function formatUptime2(ms) {
   const seconds = Math.floor(ms / 1e3);
   const minutes = Math.floor(seconds / 60);
   const hours = Math.floor(minutes / 60);
@@ -133645,7 +134490,7 @@ function logDiagnostics(prefix, startTime, dbHealthCheck) {
     } catch {
     }
   }
-  const logLine = `[${prefix}] diagnostics: uptime=${formatUptime(uptime)} rss=${formatBytes2(mem.rss)} heap=${formatBytes2(mem.heapUsed)}/${formatBytes2(mem.heapTotal)} external=${formatBytes2(mem.external)} arrayBuffers=${formatBytes2(mem.arrayBuffers)} handles=${handleCount} requests=${requestCount} db=${dbHealth}${listenerInfo}`;
+  const logLine = `[${prefix}] diagnostics: uptime=${formatUptime2(uptime)} rss=${formatBytes2(mem.rss)} heap=${formatBytes2(mem.heapUsed)}/${formatBytes2(mem.heapTotal)} external=${formatBytes2(mem.external)} arrayBuffers=${formatBytes2(mem.arrayBuffers)} handles=${handleCount} requests=${requestCount} db=${dbHealth}${listenerInfo}`;
   console.log(logLine);
 }
 function ensureProcessDiagnostics() {
@@ -133668,11 +134513,11 @@ function ensureProcessDiagnostics() {
       requestCount = process._getActiveRequests?.()?.length ?? -1;
     } catch {
     }
-    console.log(`[dashboard] beforeExit code=${code} uptime=${formatUptime(uptime)} handles=${handleCount} requests=${requestCount}`);
+    console.log(`[dashboard] beforeExit code=${code} uptime=${formatUptime2(uptime)} handles=${handleCount} requests=${requestCount}`);
   });
   process.on("exit", (code) => {
     const uptime = Date.now() - diagnosticStartTime;
-    console.log(`[dashboard] exit code=${code} uptime=${formatUptime(uptime)}`);
+    console.log(`[dashboard] exit code=${code} uptime=${formatUptime2(uptime)}`);
   });
   process.on("uncaughtExceptionMonitor", (error) => {
     console.error(`[dashboard] uncaught exception pid=${process.pid}: ${error.stack || error.message}`);
@@ -133718,7 +134563,73 @@ async function runDashboard(port, opts = {}) {
     }
   }
   const cwd = await resolveRuntimeProjectPath();
-  const store = new TaskStore(cwd);
+  const isTTY = isTTYAvailable();
+  let tui;
+  const dashboardStartedAt = Date.now();
+  let store;
+  let agentStore;
+  const logSink = new DashboardLogSink();
+  if (isTTY) {
+    tui = new DashboardTUI();
+    tui.setCallbacks({
+      onRefreshStats: async () => {
+        if (store && agentStore) {
+          const tasks = await store.listTasks({ slim: true, includeArchived: false });
+          const counts = /* @__PURE__ */ new Map();
+          for (const task of tasks) {
+            counts.set(task.column, (counts.get(task.column) ?? 0) + 1);
+          }
+          const active = tasks.filter(
+            (task) => task.column === "in-progress" || task.column === "in-review"
+          ).length;
+          const agents = await agentStore.listAgents();
+          const agentStats = { idle: 0, active: 0, running: 0, error: 0 };
+          for (const agent of agents) {
+            const state = agent.state;
+            if (state in agentStats) {
+              agentStats[state]++;
+            }
+          }
+          tui.setTaskStats({
+            total: tasks.length,
+            byColumn: Object.fromEntries(counts),
+            active,
+            agents: agentStats
+          });
+        }
+      },
+      onClearLogs: () => {
+      },
+      onTogglePause: async (paused) => {
+        if (store) {
+          await store.updateSettings({ enginePaused: paused });
+          tui.log(`Engine ${paused ? "paused" : "resumed"}`);
+          const fullSettings = await store.getSettings();
+          return {
+            maxConcurrent: fullSettings.maxConcurrent ?? 1,
+            maxWorktrees: fullSettings.maxWorktrees ?? 2,
+            autoMerge: fullSettings.autoMerge ?? false,
+            mergeStrategy: fullSettings.mergeStrategy ?? "direct",
+            pollIntervalMs: fullSettings.pollIntervalMs ?? 6e4,
+            enginePaused: fullSettings.enginePaused ?? false,
+            globalPause: fullSettings.globalPause ?? false
+          };
+        }
+        return {
+          maxConcurrent: 1,
+          maxWorktrees: 2,
+          autoMerge: false,
+          mergeStrategy: "direct",
+          pollIntervalMs: 6e4,
+          enginePaused: paused,
+          globalPause: false
+        };
+      }
+    });
+    await tui.start();
+    logSink.setTUI(tui);
+  }
+  store = new TaskStore(cwd);
   await store.init();
   await store.watch();
   setDiagnosticDbHealthCheck(() => store.healthCheck());
@@ -133730,15 +134641,78 @@ async function runDashboard(port, opts = {}) {
     "settings:updated": store.listenerCount("settings:updated"),
     "agent:log": store.listenerCount("agent:log")
   }));
+  let tuiRefreshPending = false;
+  let tuiRefreshDebounceTimer = null;
+  async function refreshTUIStats() {
+    if (!tui || !isTTY) return;
+    if (!store || !agentStore) return;
+    if (tuiRefreshPending) return;
+    tuiRefreshPending = true;
+    try {
+      const tasks = await store.listTasks({ slim: true, includeArchived: false });
+      const counts = /* @__PURE__ */ new Map();
+      for (const task of tasks) {
+        counts.set(task.column, (counts.get(task.column) ?? 0) + 1);
+      }
+      const active = tasks.filter(
+        (task) => task.column === "in-progress" || task.column === "in-review"
+      ).length;
+      const agents = await agentStore.listAgents();
+      const agentStats = { idle: 0, active: 0, running: 0, error: 0 };
+      for (const agent of agents) {
+        const state = agent.state;
+        if (state in agentStats) {
+          agentStats[state]++;
+        }
+      }
+      tui.setTaskStats({
+        total: tasks.length,
+        byColumn: Object.fromEntries(counts),
+        active,
+        agents: agentStats
+      });
+    } finally {
+      tuiRefreshPending = false;
+    }
+  }
+  async function refreshTUISettings() {
+    if (!tui || !isTTY) return;
+    if (!store) return;
+    try {
+      const settings = await store.getSettings();
+      tui.setSettings({
+        maxConcurrent: settings.maxConcurrent ?? 1,
+        maxWorktrees: settings.maxWorktrees ?? 2,
+        autoMerge: settings.autoMerge ?? false,
+        mergeStrategy: settings.mergeStrategy ?? "direct",
+        pollIntervalMs: settings.pollIntervalMs ?? 6e4,
+        enginePaused: settings.enginePaused ?? false,
+        globalPause: settings.globalPause ?? false
+      });
+    } catch {
+    }
+  }
+  function scheduleStatsRefresh() {
+    if (tuiRefreshDebounceTimer) {
+      clearTimeout(tuiRefreshDebounceTimer);
+    }
+    tuiRefreshDebounceTimer = setTimeout(() => {
+      void refreshTUIStats();
+    }, 500);
+  }
   const handlers = [];
   const disposeCallbacks = [];
   let disposed = false;
   let shutdownInProgress = false;
-  const dashboardStartedAt = Date.now();
   async function logShutdownDiagnostics(reason) {
     const uptimeSeconds = Math.round((Date.now() - dashboardStartedAt) / 1e3);
     let taskSummary = "tasks=unknown";
     try {
+      if (!store) {
+        taskSummary = "tasks=unavailable (store not initialized)";
+        console.log(`[dashboard] shutdown requested reason=${reason} pid=${process.pid} ppid=${process.ppid} uptime=${uptimeSeconds}s ${taskSummary}`);
+        return;
+      }
       const tasks = await store.listTasks({ slim: true, includeArchived: false });
       const counts = /* @__PURE__ */ new Map();
       for (const task of tasks) {
@@ -133762,8 +134736,20 @@ async function runDashboard(port, opts = {}) {
   }
   const automationStore = new AutomationStore(cwd);
   await automationStore.init();
-  const agentStore = new AgentStore({ rootDir: store.getFusionDir() });
+  agentStore = new AgentStore({ rootDir: store.getFusionDir() });
   await agentStore.init();
+  if (tui && isTTY) {
+    registerHandler(store, "task:created", scheduleStatsRefresh);
+    registerHandler(store, "task:moved", scheduleStatsRefresh);
+    registerHandler(store, "task:updated", scheduleStatsRefresh);
+    registerHandler(store, "task:deleted", scheduleStatsRefresh);
+    registerHandler(store, "settings:updated", () => {
+      void refreshTUISettings();
+    });
+    registerHandler(agentStore, "agent:created", scheduleStatsRefresh);
+    registerHandler(agentStore, "agent:updated", scheduleStatsRefresh);
+    registerHandler(agentStore, "agent:deleted", scheduleStatsRefresh);
+  }
   const pluginStore = new PluginStore(store.getFusionDir());
   await pluginStore.init();
   const pluginLoader = new PluginLoader({
@@ -133774,7 +134760,7 @@ async function runDashboard(port, opts = {}) {
   let triggerScheduler;
   if (opts.paused) {
     await store.updateSettings({ enginePaused: true });
-    console.log("[engine] Starting in paused mode \u2014 automation disabled");
+    logSink.log("Starting in paused mode \u2014 automation disabled", "engine");
   }
   const onMergeImpl = (taskId) => aiMergeTask(store, cwd, taskId, {
     agentStore,
@@ -133819,14 +134805,14 @@ async function runDashboard(port, opts = {}) {
       join48(cwd, ".fusion", "disabled-auto-extension-discovery")
     );
     for (const { path: path4, error } of extensionsResult.errors) {
-      console.log(`[extensions] Failed to load ${path4}: ${error}`);
+      logSink.log(`Failed to load ${path4}: ${error}`, "extensions");
     }
     for (const { name, config, extensionPath } of extensionsResult.runtime.pendingProviderRegistrations) {
       try {
         modelRegistry.registerProvider(name, config);
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        console.log(`[extensions] Failed to register provider from ${extensionPath}: ${message}`);
+        logSink.log(`Failed to register provider from ${extensionPath}: ${message}`, "extensions");
       }
     }
     extensionsResult.runtime.pendingProviderRegistrations = [];
@@ -133866,15 +134852,15 @@ async function runDashboard(port, opts = {}) {
           api: "openai-completions",
           models: orModels
         });
-        console.log(`[openrouter] Synced ${orModels.length} models from OpenRouter API`);
+        logSink.log(`Synced ${orModels.length} models from OpenRouter API`, "openrouter");
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        console.log(`[openrouter] Failed to sync models: ${message}`);
+        logSink.log(`Failed to sync models: ${message}`, "openrouter");
       }
     })();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.log(`[extensions] Failed to discover extensions: ${message}`);
+    logSink.log(`Failed to discover extensions: ${message}`, "extensions");
     createExtensionRuntime2();
     modelRegistry.refresh();
   }
@@ -133886,6 +134872,13 @@ async function runDashboard(port, opts = {}) {
   function dispose() {
     if (disposed) return;
     disposed = true;
+    if (tuiRefreshDebounceTimer) {
+      clearTimeout(tuiRefreshDebounceTimer);
+      tuiRefreshDebounceTimer = null;
+    }
+    if (tui) {
+      void tui.stop();
+    }
     for (const { target, event, handler } of handlers) {
       target.off(event, handler);
     }
@@ -133953,7 +134946,8 @@ async function runDashboard(port, opts = {}) {
       onProjectFirstAccessed: (projectId) => engineManager.onProjectAccessed(projectId),
       skillsAdapter,
       https: loadTlsCredentialsFromEnv(),
-      daemon: dashboardAuthToken ? { token: dashboardAuthToken } : void 0
+      daemon: dashboardAuthToken ? { token: dashboardAuthToken } : void 0,
+      noAuth: opts.noAuth
     });
     const shutdown = async (signal) => {
       if (shutdownInProgress) return;
@@ -134022,10 +135016,10 @@ async function runDashboard(port, opts = {}) {
         taskStore: store,
         rootDir: cwd,
         onMissed: (agentId) => {
-          console.log(`[engine] Agent ${agentId} missed heartbeat`);
+          logSink.log(`Agent ${agentId} missed heartbeat`, "engine");
         },
         onTerminated: (agentId) => {
-          console.log(`[engine] Agent ${agentId} terminated (unresponsive)`);
+          logSink.log(`Agent ${agentId} terminated (unresponsive)`, "engine");
         }
       });
       heartbeatMonitorImpl.start();
@@ -134048,20 +135042,20 @@ async function runDashboard(port, opts = {}) {
       triggerScheduler.start();
       const agents = await agentStore.listAgents();
       for (const agent of agents) {
+        if (isEphemeralAgent(agent)) continue;
+        if (agent.state !== "active" && agent.state !== "running") continue;
         const rc = agent.runtimeConfig;
-        if (rc && (rc.heartbeatIntervalMs || rc.enabled !== void 0 || rc.maxConcurrentRuns)) {
-          triggerScheduler.registerAgent(agent.id, {
-            heartbeatIntervalMs: rc.heartbeatIntervalMs,
-            enabled: rc.enabled,
-            maxConcurrentRuns: rc.maxConcurrentRuns
-          });
-        }
+        triggerScheduler.registerAgent(agent.id, {
+          heartbeatIntervalMs: rc?.heartbeatIntervalMs,
+          maxConcurrentRuns: rc?.maxConcurrentRuns
+        });
       }
       if (agents.length > 0) {
-        console.log(`[engine] Registered ${triggerScheduler.getRegisteredAgents().length} agents for heartbeat triggers`);
+        logSink.log(`Registered ${triggerScheduler.getRegisteredAgents().length} agents for heartbeat triggers`, "engine");
       }
     } catch (err) {
-      console.log(`[engine] HeartbeatMonitor initialization failed (continuing without agent monitoring):`, err);
+      const message = err instanceof Error ? err.message : String(err);
+      logSink.log(`HeartbeatMonitor initialization failed (continuing without agent monitoring): ${message}`, "engine");
     }
     app = createServer(store, {
       onMerge,
@@ -134094,7 +135088,8 @@ async function runDashboard(port, opts = {}) {
       pluginRunner: pluginLoader,
       skillsAdapter,
       https: loadTlsCredentialsFromEnv(),
-      daemon: dashboardAuthToken ? { token: dashboardAuthToken } : void 0
+      daemon: dashboardAuthToken ? { token: dashboardAuthToken } : void 0,
+      noAuth: opts.noAuth
     });
   }
   if (opts.dev) {
@@ -134196,32 +135191,89 @@ async function runDashboard(port, opts = {}) {
     const displayHost = selectedHost === "0.0.0.0" || selectedHost === "::" ? selectedHost : "localhost";
     const baseUrl = `http://${displayHost}:${actualPort}`;
     const tokenizedUrl = dashboardAuthToken ? `${baseUrl}/?token=${encodeURIComponent(dashboardAuthToken)}` : baseUrl;
-    console.log();
-    console.log(`  fn board`);
-    console.log(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
-    console.log(`  \u2192 ${baseUrl}`);
-    if (dashboardAuthToken) {
-      console.log(`  Auth:    bearer token required`);
-      console.log(`  Token:   ${dashboardAuthToken}`);
-      console.log(`  Open:    ${tokenizedUrl}`);
-      console.log(`           (the browser stores the token so you only need to click once)`);
-    } else {
-      console.log(`  Auth:    disabled (--no-auth)`);
-    }
-    console.log();
-    console.log(`  Tasks stored in .fusion/tasks/`);
-    console.log(`  Merge:      AI-assisted (conflict resolution + commit messages)`);
-    if (opts.dev) {
-      console.log(`  AI engine:  \u2717 disabled (dev mode)`);
+    if (isTTY && tui) {
+      const settings = await store.getSettings();
+      const engineMode = opts.dev ? "dev" : settings.enginePaused ? "paused" : "active";
+      const systemInfo = {
+        host: displayHost,
+        port: actualPort,
+        baseUrl,
+        authEnabled: Boolean(dashboardAuthToken),
+        authToken: dashboardAuthToken,
+        tokenizedUrl: dashboardAuthToken ? tokenizedUrl : void 0,
+        engineMode,
+        fileWatcher: true,
+        startTimeMs: dashboardStartedAt
+      };
+      tui.setSystemInfo(systemInfo);
+      tui.setSettings({
+        maxConcurrent: settings.maxConcurrent ?? 1,
+        maxWorktrees: settings.maxWorktrees ?? 2,
+        autoMerge: settings.autoMerge ?? false,
+        mergeStrategy: settings.mergeStrategy ?? "direct",
+        pollIntervalMs: settings.pollIntervalMs ?? 6e4,
+        enginePaused: settings.enginePaused ?? false,
+        globalPause: settings.globalPause ?? false
+      });
+      const tasks = await store.listTasks({ slim: true, includeArchived: false });
+      const counts = /* @__PURE__ */ new Map();
+      for (const task of tasks) {
+        counts.set(task.column, (counts.get(task.column) ?? 0) + 1);
+      }
+      const active = tasks.filter(
+        (task) => task.column === "in-progress" || task.column === "in-review"
+      ).length;
+      const agents = await agentStore.listAgents();
+      const agentStats = { idle: 0, active: 0, running: 0, error: 0 };
+      for (const agent of agents) {
+        const state = agent.state;
+        if (state in agentStats) {
+          agentStats[state]++;
+        }
+      }
+      tui.setTaskStats({
+        total: tasks.length,
+        byColumn: Object.fromEntries(counts),
+        active,
+        agents: agentStats
+      });
+      tui.log(`Dashboard started at ${baseUrl}`);
+      if (engineMode === "active") {
+        tui.log("AI engine active");
+      } else if (engineMode === "dev") {
+        tui.log("AI engine disabled (dev mode)");
+      } else {
+        tui.log("AI engine paused");
+      }
+      tui.log("File watcher active");
     } else {
-      console.log(`  AI engine:  \u2713 active`);
-      console.log(`    \u2022 triage: auto-specifying tasks`);
-      console.log(`    \u2022 scheduler: dependency-aware execution`);
-      console.log(`    \u2022 cron: scheduled task execution`);
+      console.log();
+      console.log(`  fn board`);
+      console.log(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+      console.log(`  \u2192 ${baseUrl}`);
+      if (dashboardAuthToken) {
+        console.log(`  Auth:    bearer token required`);
+        console.log(`  Token:   ${dashboardAuthToken}`);
+        console.log(`  Open:    ${tokenizedUrl}`);
+        console.log(`           (the browser stores the token so you only need to click once)`);
+      } else {
+        console.log(`  Auth:    disabled (--no-auth)`);
+      }
+      console.log();
+      console.log(`  Tasks stored in .fusion/tasks/`);
+      console.log(`  Merge:      AI-assisted (conflict resolution + commit messages)`);
+      if (opts.dev) {
+        console.log(`  AI engine:  \u2717 disabled (dev mode)`);
+      } else {
+        console.log(`  AI engine:  \u2713 active`);
+        console.log(`    \u2022 triage: auto-specifying tasks`);
+        console.log(`    \u2022 scheduler: dependency-aware execution`);
+        console.log(`    \u2022 cron: scheduled task execution`);
+      }
+      console.log(`  File watcher: \u2713 active`);
+      console.log(`  Press Ctrl+C to stop`);
+      console.log();
     }
-    console.log(`  File watcher: \u2713 active`);
-    console.log(`  Press Ctrl+C to stop`);
-    console.log();
   });
   return { dispose };
 }
@@ -134238,6 +135290,7 @@ var init_dashboard = __esm({
     init_provider_auth();
     init_auth_paths2();
     init_project_context();
+    init_dashboard_tui();
     processDiagnosticsRegistered = false;
     diagnosticIntervalHandle = null;
     DIAGNOSTIC_INTERVAL_MS = 30 * 60 * 1e3;
@@ -134254,7 +135307,7 @@ __export(node_exports, {
   formatBytes: () => formatBytes3,
   formatLastActivity: () => formatLastActivity,
   formatStatusBar: () => formatStatusBar,
-  formatUptime: () => formatUptime2,
+  formatUptime: () => formatUptime3,
   isValidNodeName: () => isValidNodeName,
   maskApiKey: () => maskApiKey,
   runMeshStatus: () => runMeshStatus,
@@ -134267,7 +135320,7 @@ __export(node_exports, {
   runNodeRemove: () => runNodeRemove,
   runNodeShow: () => runNodeShow
 });
-import { createInterface as createInterface2 } from "node:readline/promises";
+import { createInterface as createInterface3 } from "node:readline/promises";
 function maskApiKey(key) {
   if (!key) return "none";
   if (key.length < 4) return "****";
@@ -134284,7 +135337,7 @@ function formatBytes3(bytes) {
   if (value >= 10) return `${value.toFixed(1)} ${units[i]}`;
   return `${value.toFixed(2)} ${units[i]}`;
 }
-function formatUptime2(ms) {
+function formatUptime3(ms) {
   if (ms < 0) return "0s";
   const seconds = Math.floor(ms / 1e3);
   const minutes = Math.floor(seconds / 60);
@@ -134462,7 +135515,7 @@ async function runNodeDisconnect(name, options = {}) {
       process.exit(1);
     }
     if (!options.force) {
-      const rl = createInterface2({ input: process.stdin, output: process.stdout });
+      const rl = createInterface3({ input: process.stdin, output: process.stdout });
       const answer = await rl.question(`Disconnect node '${node.name}'? [y/N] `);
       rl.close();
       if (answer.trim().toLowerCase() !== "y") {
@@ -134532,7 +135585,7 @@ async function runNodeShow(name, options = {}) {
       console.log(`    CPU Usage:    ${formatStatusBar(metrics.cpuUsage)}`);
       console.log(`    Memory:       ${formatBytes3(metrics.memoryUsed)} / ${formatBytes3(metrics.memoryTotal)}`);
       console.log(`    Storage:      ${formatBytes3(metrics.storageUsed)} / ${formatBytes3(metrics.storageTotal)}`);
-      console.log(`    Uptime:       ${formatUptime2(metrics.uptime)}`);
+      console.log(`    Uptime:       ${formatUptime3(metrics.uptime)}`);
       console.log(`    Reported:     ${formatLastActivity(metrics.reportedAt)}`);
     } else {
       console.log();
@@ -134688,7 +135741,7 @@ function formatBytes4(bytes) {
   if (bytes < 1024 * 1024 * 1024) return `${Math.round(bytes / (1024 * 1024))}MB`;
   return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
 }
-function formatUptime3(ms) {
+function formatUptime4(ms) {
   const seconds = Math.floor(ms / 1e3);
   const minutes = Math.floor(seconds / 60);
   const hours = Math.floor(minutes / 60);
@@ -134723,7 +135776,7 @@ function logDiagnostics2(prefix, dbHealthCheck) {
     } catch {
     }
   }
-  const logLine = `[${prefix}] diagnostics: uptime=${formatUptime3(uptime)} rss=${formatBytes4(mem.rss)} heap=${formatBytes4(mem.heapUsed)}/${formatBytes4(mem.heapTotal)} external=${formatBytes4(mem.external)} arrayBuffers=${formatBytes4(mem.arrayBuffers)} handles=${handleCount} requests=${requestCount} db=${dbHealth}${listenerInfo}`;
+  const logLine = `[${prefix}] diagnostics: uptime=${formatUptime4(uptime)} rss=${formatBytes4(mem.rss)} heap=${formatBytes4(mem.heapUsed)}/${formatBytes4(mem.heapTotal)} external=${formatBytes4(mem.external)} arrayBuffers=${formatBytes4(mem.arrayBuffers)} handles=${handleCount} requests=${requestCount} db=${dbHealth}${listenerInfo}`;
   console.log(logLine);
 }
 function stopDiagnosticInterval2() {
@@ -134750,11 +135803,11 @@ function ensureProcessDiagnostics2() {
       requestCount = process._getActiveRequests?.()?.length ?? -1;
     } catch {
     }
-    console.log(`[serve] beforeExit code=${code} uptime=${formatUptime3(uptime)} handles=${handleCount} requests=${requestCount}`);
+    console.log(`[serve] beforeExit code=${code} uptime=${formatUptime4(uptime)} handles=${handleCount} requests=${requestCount}`);
   });
   process.on("exit", (code) => {
     const uptime = Date.now() - serveStartTime;
-    console.log(`[serve] exit code=${code} uptime=${formatUptime3(uptime)}`);
+    console.log(`[serve] exit code=${code} uptime=${formatUptime4(uptime)}`);
   });
   process.on("uncaughtExceptionMonitor", (error) => {
     console.error(`[serve] uncaught exception pid=${process.pid}: ${error.stack || error.message}`);
@@ -135189,7 +136242,7 @@ function formatBytes5(bytes) {
   if (bytes < 1024 * 1024 * 1024) return `${Math.round(bytes / (1024 * 1024))}MB`;
   return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
 }
-function formatUptime4(ms) {
+function formatUptime5(ms) {
   const seconds = Math.floor(ms / 1e3);
   const minutes = Math.floor(seconds / 60);
   const hours = Math.floor(minutes / 60);
@@ -135217,7 +136270,7 @@ function logDiagnostics3(dbHealthCheck) {
       dbHealth = "error";
     }
   }
-  const logLine = `[daemon] diagnostics: uptime=${formatUptime4(uptime)} rss=${formatBytes5(mem.rss)} heap=${formatBytes5(mem.heapUsed)}/${formatBytes5(mem.heapTotal)} external=${formatBytes5(mem.external)} arrayBuffers=${formatBytes5(mem.arrayBuffers)} handles=${handleCount} requests=${requestCount} db=${dbHealth}`;
+  const logLine = `[daemon] diagnostics: uptime=${formatUptime5(uptime)} rss=${formatBytes5(mem.rss)} heap=${formatBytes5(mem.heapUsed)}/${formatBytes5(mem.heapTotal)} external=${formatBytes5(mem.external)} arrayBuffers=${formatBytes5(mem.arrayBuffers)} handles=${handleCount} requests=${requestCount} db=${dbHealth}`;
   console.log(logLine);
 }
 function maskToken(token) {
@@ -135560,7 +136613,7 @@ __export(desktop_exports, {
 import { spawn as spawn4 } from "node:child_process";
 import { once as once2 } from "node:events";
 import { join as join51 } from "node:path";
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 function runCommand(command, args, cwd) {
   return new Promise((resolve29, reject2) => {
     const child = spawn4(command, args, {
@@ -135623,7 +136676,7 @@ function resolveElectronBinary() {
   if (process.env.FUSION_ELECTRON_BINARY) {
     return process.env.FUSION_ELECTRON_BINARY;
   }
-  return require2("electron");
+  return require3("electron");
 }
 function terminateProcess(child, signal = "SIGTERM") {
   if (!child || child.killed) {
@@ -135681,13 +136734,13 @@ async function runDesktop(options = {}) {
     void shutdown(code ?? 0);
   });
 }
-var require2;
+var require3;
 var init_desktop = __esm({
   "src/commands/desktop.ts"() {
     "use strict";
     init_src();
     init_src3();
-    require2 = createRequire(import.meta.url);
+    require3 = createRequire2(import.meta.url);
   }
 });
 
@@ -135720,7 +136773,7 @@ __export(task_exports, {
   runTaskUnpause: () => runTaskUnpause,
   runTaskUpdate: () => runTaskUpdate
 });
-import { createInterface as createInterface3 } from "node:readline/promises";
+import { createInterface as createInterface4 } from "node:readline/promises";
 import { watchFile, unwatchFile, statSync as statSync7, existsSync as existsSync35, readFileSync as readFileSync14 } from "node:fs";
 import { join as join52 } from "node:path";
 function asLocalProjectContext(store) {
@@ -135789,7 +136842,7 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName)
   let description = descriptionArg;
   const projectContext = await getProjectContext(projectName);
   if (!description) {
-    const rl = createInterface3({ input: process.stdin, output: process.stdout });
+    const rl = createInterface4({ input: process.stdin, output: process.stdout });
     description = await rl.question("Task description: ");
     rl.close();
   }
@@ -135890,11 +136943,11 @@ async function runTaskLog(id, message, outcome, projectName) {
   console.log(`  \u2713 ${id}: logged "${message}"`);
   console.log();
 }
-function formatTimestamp3(timestamp) {
+function formatTimestamp4(timestamp) {
   return new Date(timestamp).toLocaleTimeString();
 }
 function formatLogEntry(entry) {
-  const ts = formatTimestamp3(entry.timestamp);
+  const ts = formatTimestamp4(entry.timestamp);
   const agent = entry.agent ? `[${entry.agent.toUpperCase()}] ` : "";
   switch (entry.type) {
     case "text":
@@ -136126,7 +137179,7 @@ async function runTaskRefine(id, feedbackArg, projectName) {
   const store = await getStore(projectName);
   let feedback = feedbackArg;
   if (feedback === void 0) {
-    const rl = createInterface3({ input: process.stdin, output: process.stdout });
+    const rl = createInterface4({ input: process.stdin, output: process.stdout });
     feedback = await rl.question("What needs to be refined? ");
     rl.close();
   }
@@ -136198,7 +137251,7 @@ async function runTaskDelete(id, force, projectName) {
     return;
   }
   if (!force) {
-    const rl = createInterface3({ input: process.stdin, output: process.stdout });
+    const rl = createInterface4({ input: process.stdin, output: process.stdout });
     const answer = await rl.question(`Are you sure you want to delete ${id}? [y/N] `);
     rl.close();
     const trimmed = answer.trim().toLowerCase();
@@ -136262,7 +137315,7 @@ async function runTaskImportGitHubInteractive(ownerRepo, options = {}, projectNa
     console.log(`  ${i + 1}. #${issue.number} ${issue.title.slice(0, 80)}${issue.title.length > 80 ? "\u2026" : ""}${status}`);
   }
   console.log();
-  const rl = createInterface3({ input: process.stdin, output: process.stdout });
+  const rl = createInterface4({ input: process.stdin, output: process.stdout });
   let selectedIndices = [];
   let validInput = false;
   while (!validInput) {
@@ -136405,7 +137458,7 @@ async function runTaskComment(id, message, author = "user", projectName) {
   const store = await getStore(projectName);
   let text = message;
   if (text === void 0) {
-    const rl = createInterface3({ input: process.stdin, output: process.stdout });
+    const rl = createInterface4({ input: process.stdin, output: process.stdout });
     text = await rl.question("Comment: ");
     rl.close();
   }
@@ -136448,7 +137501,7 @@ async function runTaskSteer(id, message, projectName) {
   const store = await getStore(projectName);
   let text = message;
   if (text === void 0) {
-    const rl = createInterface3({ input: process.stdin, output: process.stdout });
+    const rl = createInterface4({ input: process.stdin, output: process.stdout });
     text = await rl.question("Message: ");
     rl.close();
   }
@@ -136578,7 +137631,7 @@ async function promptText(question) {
     console.log(`  ${question.description}`);
   }
   console.log("  (Enter your response. Type DONE on its own line when finished):\n");
-  const rl = createInterface3({ input: process.stdin, output: process.stdout });
+  const rl = createInterface4({ input: process.stdin, output: process.stdout });
   const lines = [];
   return new Promise((resolve29) => {
     const askLine = () => {
@@ -136612,7 +137665,7 @@ async function promptSingleSelect(question) {
       console.log(`     ${opt.description}`);
     }
   }
-  const rl = createInterface3({ input: process.stdin, output: process.stdout });
+  const rl = createInterface4({ input: process.stdin, output: process.stdout });
   while (true) {
     const answer = await rl.question("\n  Select (1-" + question.options.length + "): ");
     const num = parseInt(answer.trim(), 10);
@@ -136640,7 +137693,7 @@ async function promptMultiSelect(question) {
       console.log(`     ${opt.description}`);
     }
   }
-  const rl = createInterface3({ input: process.stdin, output: process.stdout });
+  const rl = createInterface4({ input: process.stdin, output: process.stdout });
   while (true) {
     const answer = await rl.question("\n  Select (comma-separated): ");
     const nums = answer.split(",").map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n));
@@ -136663,7 +137716,7 @@ async function promptConfirm(question) {
   if (question.description) {
     console.log(`  ${question.description}`);
   }
-  const rl = createInterface3({ input: process.stdin, output: process.stdout });
+  const rl = createInterface4({ input: process.stdin, output: process.stdout });
   const answer = await rl.question("\n  [Y/n]: ");
   rl.close();
   const trimmed = answer.trim().toLowerCase();
@@ -136728,7 +137781,7 @@ function wrapText(text, width) {
 async function runTaskPlan(initialPlanArg, yesFlag = false, projectName) {
   let initialPlan = initialPlanArg;
   if (!initialPlan) {
-    const rl = createInterface3({ input: process.stdin, output: process.stdout });
+    const rl = createInterface4({ input: process.stdin, output: process.stdout });
     console.log("\n  Let's plan your task. What would you like to accomplish?\n");
     initialPlan = await rl.question("  Describe your idea: ");
     rl.close();
@@ -136829,7 +137882,7 @@ async function runTaskPlan(initialPlanArg, yesFlag = false, projectName) {
         displaySummary(result.data);
         let confirmed = yesFlag;
         if (!yesFlag) {
-          const rl = createInterface3({ input: process.stdin, output: process.stdout });
+          const rl = createInterface4({ input: process.stdin, output: process.stdout });
           const answer = await rl.question("  Create this task? [Y/n]: ");
           rl.close();
           const trimmed = answer.trim().toLowerCase();
@@ -137313,7 +138366,7 @@ __export(git_exports, {
 });
 import { exec as exec10 } from "node:child_process";
 import { promisify as promisify12 } from "node:util";
-import { createInterface as createInterface4 } from "node:readline/promises";
+import { createInterface as createInterface5 } from "node:readline/promises";
 async function resolveGitCwd(projectName) {
   if (projectName) {
     return (await resolveProject(projectName)).projectPath;
@@ -137501,7 +138554,7 @@ async function runGitPull(options = {}) {
     console.log();
     console.log("  \u26A0 Warning: You have uncommitted changes.");
     console.log(`  Branch: ${status.branch}`);
-    const rl = createInterface4({ input: process.stdin, output: process.stdout });
+    const rl = createInterface5({ input: process.stdin, output: process.stdout });
     const answer = await rl.question("  Continue with pull? [y/N] ");
     rl.close();
     const trimmed = answer.trim().toLowerCase();
@@ -137552,7 +138605,7 @@ async function runGitPush(options = {}) {
   }
   if (!options.skipConfirm) {
     console.log();
-    const rl = createInterface4({ input: process.stdin, output: process.stdout });
+    const rl = createInterface5({ input: process.stdin, output: process.stdout });
     const answer = await rl.question(`  Push branch ${status.branch} to remote? [Y/n] `);
     rl.close();
     const trimmed = answer.trim().toLowerCase();
@@ -137689,7 +138742,7 @@ var init_backup2 = __esm({
 // src/project-resolver.ts
 import { existsSync as existsSync37, statSync as statSync8 } from "node:fs";
 import { dirname as dirname18, resolve as resolve24, normalize as normalize4 } from "node:path";
-import { createInterface as createInterface5 } from "node:readline/promises";
+import { createInterface as createInterface6 } from "node:readline/promises";
 async function getCentralCore() {
   if (!centralCoreInstance) {
     centralCoreInstance = new CentralCore();
@@ -137720,7 +138773,7 @@ function findKbDir(startPath) {
   return null;
 }
 async function promptProjectSelection(projects, message = "Select a project:") {
-  const rl = createInterface5({ input: process.stdin, output: process.stdout });
+  const rl = createInterface6({ input: process.stdin, output: process.stdout });
   console.log(`
   ${message}`);
   for (let i = 0; i < projects.length; i++) {
@@ -137737,7 +138790,7 @@ async function promptProjectSelection(projects, message = "Select a project:") {
   }
 }
 async function promptConfirm2(message, defaultYes = false) {
-  const rl = createInterface5({ input: process.stdin, output: process.stdout });
+  const rl = createInterface6({ input: process.stdin, output: process.stdout });
   const prompt = defaultYes ? "[Y/n]" : "[y/N]";
   const answer = await rl.question(`  ${message} ${prompt}: `);
   rl.close();
@@ -137797,7 +138850,7 @@ Run \`fn project remove ` + match.name + "` to clean up the registry entry.",
   Found fn project at ${kbDir} but it's not registered.`);
       const shouldRegister = await promptConfirm2("Register this project now?", true);
       if (shouldRegister) {
-        const rl = createInterface5({ input: process.stdin, output: process.stdout });
+        const rl = createInterface6({ input: process.stdin, output: process.stdout });
         const defaultName = kbDir.split("/").pop() || "unnamed";
         const name = await rl.question(`  Project name [${defaultName}]: `);
         rl.close();
@@ -137958,12 +139011,12 @@ __export(mission_exports, {
   runMissionShow: () => runMissionShow,
   runSliceAdd: () => runSliceAdd
 });
-import { createInterface as createInterface6 } from "node:readline/promises";
+import { createInterface as createInterface7 } from "node:readline/promises";
 async function promptForTitleAndDescription(titleArg, titlePrompt, descriptionPrompt) {
   let title = titleArg;
   let description;
   if (!title) {
-    const rl = createInterface6({ input: process.stdin, output: process.stdout });
+    const rl = createInterface7({ input: process.stdin, output: process.stdout });
     title = await rl.question(titlePrompt);
     if (!title?.trim()) {
       rl.close();
@@ -138092,7 +139145,7 @@ async function runMissionDelete(id, force, projectName) {
     process.exit(1);
   }
   if (!force) {
-    const rl = createInterface6({ input: process.stdin, output: process.stdout });
+    const rl = createInterface7({ input: process.stdin, output: process.stdout });
     const answer = await rl.question(`Are you sure you want to delete ${id}: "${mission.title}"? [y/N] `);
     rl.close();
     const trimmed = answer.trim().toLowerCase();
@@ -138193,7 +139246,7 @@ async function runFeatureAdd(sliceId, titleArg, descriptionArg, acceptanceCriter
   let description = descriptionArg?.trim() || void 0;
   let acceptanceCriteria = acceptanceCriteriaArg?.trim() || void 0;
   if (!title) {
-    const rl = createInterface6({ input: process.stdin, output: process.stdout });
+    const rl = createInterface7({ input: process.stdin, output: process.stdout });
     title = await rl.question("Feature title: ");
     if (!title?.trim()) {
       rl.close();
@@ -138287,7 +139340,7 @@ __export(project_exports, {
 });
 import { resolve as resolve25, isAbsolute as isAbsolute13, relative as relative11, basename as basename11 } from "node:path";
 import { existsSync as existsSync38, statSync as statSync9 } from "node:fs";
-import { createInterface as createInterface7 } from "node:readline/promises";
+import { createInterface as createInterface8 } from "node:readline/promises";
 function formatDisplayPath(projectPath) {
   const rel = relative11(process.cwd(), projectPath);
   if (rel && !rel.startsWith("..") && rel !== "") {
@@ -138408,7 +139461,7 @@ async function runProjectAdd(name, path4, options = {}) {
     let projectName = name;
     let projectPath = path4;
     if (!projectName || !projectPath || options.interactive) {
-      const rl = createInterface7({ input: process.stdin, output: process.stdout });
+      const rl = createInterface8({ input: process.stdin, output: process.stdout });
       if (!projectPath) {
         const defaultPath = process.cwd();
         const pathInput = await rl.question(`  Project path [${defaultPath}]: `);
@@ -138533,7 +139586,7 @@ async function runProjectRemove(name, options = {}) {
       process.exit(1);
     }
     if (!options.force) {
-      const rl = createInterface7({ input: process.stdin, output: process.stdout });
+      const rl = createInterface8({ input: process.stdin, output: process.stdout });
       const answer = await rl.question(`Unregister project '${project.name}'? [y/N] `);
       rl.close();
       if (answer.trim().toLowerCase() !== "y") {
@@ -139505,7 +140558,7 @@ __export(plugin_exports, {
 import { existsSync as existsSync41 } from "node:fs";
 import { join as join55 } from "node:path";
 import { readFile as readFile23 } from "node:fs/promises";
-import * as readline from "node:readline";
+import * as readline2 from "node:readline";
 async function getProjectPath6(projectName) {
   if (projectName) {
     const context = await resolveProject(projectName);
@@ -139645,7 +140698,7 @@ async function runPluginUninstall(id, options) {
     console.log(`  This will stop and remove the plugin.`);
     console.log();
     const response = await new Promise((resolve29) => {
-      const rl = readline.createInterface({
+      const rl = readline2.createInterface({
         input: process.stdin,
         output: process.stdout
       });
@@ -140163,7 +141216,7 @@ var init_native_patch = __esm({
 
 // src/bin.ts
 import { existsSync as existsSync44, mkdtempSync as mkdtempSync2, readFileSync as readFileSync17, symlinkSync as symlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire as createRequire3 } from "node:module";
 import { join as join58, dirname as dirname20 } from "node:path";
 import { tmpdir as tmpdir4 } from "node:os";
 var isBunBinary3 = typeof Bun !== "undefined" && !!Bun.embeddedFiles;
@@ -140178,8 +141231,8 @@ function configurePiPackage() {
     type: "module"
   };
   try {
-    const require3 = createRequire2(import.meta.url);
-    const piPackagePath = require3.resolve("@mariozechner/pi-coding-agent/package.json");
+    const require4 = createRequire3(import.meta.url);
+    const piPackagePath = require4.resolve("@mariozechner/pi-coding-agent/package.json");
     const piPackageDir = dirname20(piPackagePath);
     packageJson = JSON.parse(readFileSync17(piPackagePath, "utf-8"));
     for (const entry of ["dist", "docs", "examples", "README.md", "CHANGELOG.md"]) {