@runfusion/fusion 0.14.2 → 0.15.0

package/dist/bin.js

@@ -77,6 +77,7 @@ var init_settings_schema = __esm({
       favoriteModels: void 0,
       openrouterModelSync: true,
       updateCheckEnabled: true,
+      fnBinaryCheckEnabled: true,
       updateCheckFrequency: "daily",
       showGitHubStarButton: true,
       modelOnboardingComplete: void 0,
@@ -241,7 +242,8 @@ var init_settings_schema = __esm({
       maxPostReviewFixes: 1,
       maxSpawnedAgentsPerParent: 5,
       maxSpawnedAgentsGlobal: 20,
-      maintenanceIntervalMs: 9e5,
+      // Run maintenance (including WAL checkpointing) every 5 minutes by default.
+      maintenanceIntervalMs: 3e5,
       autoArchiveDoneTasksEnabled: true,
       autoArchiveDoneAfterMs: 48 * 60 * 60 * 1e3,
       archiveAgentLogMode: "compact",
@@ -2652,6 +2654,7 @@ var init_sqlite_adapter = __esm({
 // ../core/src/db.ts
 import { isAbsolute, join as join2 } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
 function toJson(value) {
   if (value === void 0 || value === null) return "[]";
   if (Array.isArray(value) && value.length === 0) return "[]";
@@ -3283,15 +3286,24 @@ CREATE INDEX IF NOT EXISTS idxTodoItemsSortOrder ON todo_items(listId, sortOrder
     Database = class {
       db;
       dbPath;
+      inMemory;
+      corruptionDetected = false;
       /** Tracks transaction nesting depth for savepoint-based nested transactions. */
       transactionDepth = 0;
       _fts5Available;
       constructor(fusionDir, options) {
         const inMemory = options?.inMemory === true;
+        this.inMemory = inMemory;
         this.dbPath = inMemory ? ":memory:" : join2(fusionDir, "fusion.db");
         if (!inMemory && !isAbsolute(fusionDir)) {
           throw new Error(`[fusion] Database constructor requires an absolute fusionDir path, got: ${fusionDir}`);
         }
+        if (!inMemory && /\.fusion[\\/]\.fusion(?:[\\/]|$)/.test(fusionDir)) {
+          throw new Error(
+            `[fusion] Refusing to open Database at nested .fusion/.fusion path: ${fusionDir}
+This means a caller passed a .fusion directory where a project root was expected. Audit the call site for an extra \`join(rootDir, '.fusion')\` step.`
+          );
+        }
         if (!inMemory && !existsSync(fusionDir)) {
           mkdirSync(fusionDir, { recursive: true });
         }
@@ -3303,8 +3315,13 @@ CREATE INDEX IF NOT EXISTS idxTodoItemsSortOrder ON todo_items(listId, sortOrder
         }
         if (!inMemory) {
           this.db.exec("PRAGMA journal_mode = WAL");
+          this.db.exec("PRAGMA busy_timeout = 5000");
+          this.db.exec("PRAGMA synchronous = NORMAL");
+          this.db.exec("PRAGMA wal_autocheckpoint = 100");
+          this.db.exec("PRAGMA journal_size_limit = 4194304");
+        } else {
+          this.db.exec("PRAGMA busy_timeout = 5000");
         }
-        this.db.exec("PRAGMA busy_timeout = 5000");
         this.db.exec("PRAGMA foreign_keys = ON");
         this._fts5Available = probeFts5(this.db);
       }
@@ -3385,6 +3402,35 @@ CREATE INDEX IF NOT EXISTS idxTodoItemsSortOrder ON todo_items(listId, sortOrder
           return false;
         }
       }
+      integrityCheck() {
+        if (this.inMemory) {
+          return { ok: true };
+        }
+        const rows = this.db.prepare("PRAGMA integrity_check(100)").all();
+        const errors = rows.map((row) => row.integrity_check).filter((value) => typeof value === "string" && value !== "ok");
+        if (errors.length > 0) {
+          return { ok: false, errors };
+        }
+        return { ok: true };
+      }
+      recoverDatabase(outputPath) {
+        if (this.inMemory) {
+          return false;
+        }
+        const recoveredSql = spawnSync("sqlite3", ["-cmd", ".recover main", this.dbPath], {
+          encoding: "utf-8",
+          maxBuffer: 50 * 1024 * 1024
+        });
+        if (recoveredSql.status !== 0 || !recoveredSql.stdout) {
+          return false;
+        }
+        const rebuilt = spawnSync("sqlite3", [outputPath], {
+          input: recoveredSql.stdout,
+          encoding: "utf-8",
+          maxBuffer: 50 * 1024 * 1024
+        });
+        return rebuilt.status === 0;
+      }
       /**
        * Initialize the database: create tables if they don't exist
        * and seed meta values.
@@ -3403,6 +3449,11 @@ CREATE INDEX IF NOT EXISTS idxTodoItemsSortOrder ON todo_items(listId, sortOrder
         this.db.exec(
           `INSERT OR IGNORE INTO config (id, nextId, nextWorkflowStepId, settings, workflowSteps, updatedAt) VALUES (1, 1, 1, '${JSON.stringify(DEFAULT_PROJECT_SETTINGS)}', '[]', '${configNow}')`
         );
+        const integrity = this.integrityCheck();
+        if (!integrity.ok) {
+          this.corruptionDetected = true;
+          console.warn("[fusion:db] Database integrity check FAILED \u2014 corruption detected");
+        }
       }
       /**
        * Run incremental schema migrations based on the stored schema version.
@@ -6018,6 +6069,7 @@ var init_agent_store = __esm({
         };
         const line = JSON.stringify(safeEntry) + "\n";
         await appendFile(this.runLogPath(agentId, runId), line, "utf-8");
+        this.emit("run:log", agentId, runId, safeEntry);
       }
       /**
        * Read all log entries for a given run from its JSONL file.
@@ -19071,7 +19123,7 @@ __export(migration_exports, {
   MigrationCoordinator: () => MigrationCoordinator,
   ProjectRequiredError: () => ProjectRequiredError
 });
-import { existsSync as existsSync9, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync2, realpathSync as realpathSync2 } from "node:fs";
 import { homedir as homedir2, tmpdir } from "node:os";
 import { isAbsolute as isAbsolute3, join as join12, resolve as resolve5, basename as basename3, dirname as dirname4 } from "node:path";
 function getHomeDir2() {
@@ -19172,12 +19224,30 @@ var init_migration = __esm({
         const projects = [];
         const visited = /* @__PURE__ */ new Set();
         let current = resolve5(startDir);
-        const home = getHomeDir2();
+        const home = resolve5(getHomeDir2());
         const root = dirname4(current) === current ? current : "/";
         const systemTmp = resolve5(tmpdir());
-        while (current !== home && current !== root && current !== systemTmp) {
+        const normalizePath2 = (path5) => {
+          try {
+            return realpathSync2(path5);
+          } catch {
+            return resolve5(path5);
+          }
+        };
+        const normalizedHome = normalizePath2(home);
+        const normalizedSystemTmp = normalizePath2(systemTmp);
+        const normalizedStartDir = normalizePath2(current);
+        while (true) {
           if (visited.has(current)) break;
           visited.add(current);
+          const normalizedCurrent = normalizePath2(current);
+          const isRootBoundary = current === root;
+          const isHomeBoundary = normalizedCurrent === normalizedHome;
+          const isTmpBoundary = normalizedCurrent === normalizedSystemTmp;
+          const isStopBoundary = isRootBoundary || isHomeBoundary || isTmpBoundary;
+          if (isRootBoundary || isTmpBoundary || isHomeBoundary && normalizedCurrent !== normalizedStartDir) {
+            break;
+          }
           if (this.hasFusionProject(current)) {
             const name = await this.generateProjectName(current);
             projects.push({
@@ -19187,6 +19257,9 @@ var init_migration = __esm({
             });
             break;
           }
+          if (isStopBoundary) {
+            break;
+          }
           const parent2 = dirname4(current);
           if (parent2 === current) break;
           current = parent2;
@@ -34495,6 +34568,39 @@ ${task.description}
         this.db.bumpLastModified();
         this.emit("agent:log", entry);
       }
+      async appendAgentLogBatch(entries) {
+        if (entries.length === 0) {
+          return;
+        }
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const stmt = this.db.prepare(`
+      INSERT INTO agentLogEntries (taskId, timestamp, text, type, detail, agent)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+        this.db.transaction(() => {
+          for (const entry of entries) {
+            stmt.run(
+              entry.taskId,
+              timestamp,
+              entry.text,
+              entry.type,
+              entry.detail ?? null,
+              entry.agent ?? null
+            );
+          }
+        });
+        this.db.bumpLastModified();
+        for (const entry of entries) {
+          this.emit("agent:log", {
+            timestamp,
+            taskId: entry.taskId,
+            text: entry.text,
+            type: entry.type,
+            ...entry.detail !== void 0 && { detail: entry.detail },
+            ...entry.agent !== void 0 && { agent: entry.agent }
+          });
+        }
+      }
       mapAgentLogRow(row) {
         return {
           timestamp: row.timestamp,
@@ -36344,12 +36450,16 @@ var init_gh_cli = __esm({
 
 // ../core/src/fn-binary.ts
 import { spawn as spawn2 } from "node:child_process";
-import { platform as platform2 } from "node:os";
+import { platform as platform2, tmpdir as tmpdir2 } from "node:os";
 function runProbe(command, args, timeoutMs) {
   return new Promise((resolve42) => {
     let stdout = "";
     let stderr = "";
-    const child = spawn2(command, args, { stdio: ["ignore", "pipe", "pipe"], shell: false });
+    const child = spawn2(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false,
+      cwd: tmpdir2()
+    });
     const timer = setTimeout(() => {
       try {
         child.kill("SIGKILL");
@@ -37480,6 +37590,20 @@ var init_plugin_loader = __esm({
         }
         return slots;
       }
+      /**
+       * Get all top-level dashboard view definitions from loaded plugins.
+       */
+      getPluginDashboardViews() {
+        const views = [];
+        for (const [pluginId, plugin4] of this.plugins) {
+          if (plugin4.dashboardViews) {
+            for (const view of plugin4.dashboardViews) {
+              views.push({ pluginId, view });
+            }
+          }
+        }
+        return views;
+      }
       /**
        * Get all runtime registrations from loaded plugins.
        * Returns plugin ownership metadata along with the runtime registration.
@@ -37667,7 +37791,7 @@ async function syncBackupAutomation(automationStore, settings) {
   if (!AutomationStore2.isValidCron(schedule)) {
     throw new Error(`Invalid backup schedule: ${schedule}`);
   }
-  const command = "npx runfusion.ai backup --create";
+  const command = "fn backup --create";
   if (existingSchedule) {
     return await automationStore.updateSchedule(existingSchedule.id, {
       scheduleType: "custom",
@@ -37700,7 +37824,7 @@ async function syncBackupRoutine(routineStore, settings) {
   if (!RoutineStore2.isValidCron(schedule)) {
     throw new Error(`Invalid backup schedule: ${schedule}`);
   }
-  const command = "npx runfusion.ai backup --create";
+  const command = "fn backup --create";
   const input = {
     name: BACKUP_SCHEDULE_NAME,
     description: "Automatic database backup based on project settings",
@@ -49575,7 +49699,7 @@ var require_dist3 = __commonJS({
 
 // ../core/src/agent-companies-parser.ts
 import { existsSync as existsSync17, mkdtempSync, readdirSync as readdirSync2, readFileSync as readFileSync4, rmSync, statSync as statSync4 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
+import { tmpdir as tmpdir3 } from "node:os";
 import { join as join20, resolve as resolve9 } from "node:path";
 function slugifyAgentReference(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
@@ -49898,7 +50022,7 @@ async function extractTarArchive(archivePath, outputDir) {
 }
 async function parseCompanyArchive(archivePath) {
   const resolvedArchivePath = resolve9(archivePath);
-  const tempDir = mkdtempSync(join20(tmpdir2(), "agent-companies-"));
+  const tempDir = mkdtempSync(join20(tmpdir3(), "agent-companies-"));
   try {
     if (resolvedArchivePath.endsWith(".tar.gz") || resolvedArchivePath.endsWith(".tgz")) {
       await extractTarArchive(resolvedArchivePath, tempDir);
@@ -51975,18 +52099,21 @@ function summarizeToolArgs(name, args) {
   }
   return void 0;
 }
-var FLUSH_SIZE_BYTES, FLUSH_INTERVAL_MS, AgentLogger;
+var FLUSH_SIZE_BYTES, FLUSH_INTERVAL_MS, ENTRY_BATCH_SIZE, AgentLogger;
 var init_agent_logger = __esm({
   "../engine/src/agent-logger.ts"() {
     "use strict";
     init_logger2();
     FLUSH_SIZE_BYTES = 1024;
     FLUSH_INTERVAL_MS = 500;
+    ENTRY_BATCH_SIZE = 50;
     AgentLogger = class {
       textBuffer = "";
       thinkingBuffer = "";
       flushTimer = null;
       thinkingFlushTimer = null;
+      entryFlushTimer = null;
+      pendingEntries = [];
       flushSizeBytes;
       flushIntervalMs;
       store;
@@ -52091,8 +52218,13 @@ var init_agent_logger = __esm({
           clearTimeout(this.thinkingFlushTimer);
           this.thinkingFlushTimer = null;
         }
+        if (this.entryFlushTimer) {
+          clearTimeout(this.entryFlushTimer);
+          this.entryFlushTimer = null;
+        }
         await this.flushTextBuffer();
         await this.flushThinkingBuffer();
+        await this.flushPendingEntries();
       }
       // ── Internal helpers ───────────────────────────────────────────────
       /**
@@ -52101,7 +52233,7 @@ var init_agent_logger = __esm({
        * When only `appendLogCb` is set (no store/taskId), only the callback is used.
        * @param storeWarnMsg - Warning message prefix used when the task-store write fails.
        */
-      writeEntry(text, type, detail, storeWarnMsg) {
+      writeEntry(text, type, detail, _storeWarnMsg, immediate = false) {
         const entry = {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           taskId: this.taskId,
@@ -52110,72 +52242,38 @@ var init_agent_logger = __esm({
           ...detail !== void 0 && { detail },
           ...this.agent !== void 0 && { agent: this.agent }
         };
-        if (this.store && this.taskId) {
-          this.store.appendAgentLog(this.taskId, text, type, detail, this.agent).catch((err) => {
-            this.log.warn(`${storeWarnMsg}: ${err instanceof Error ? err.message : String(err)}`);
-          });
+        this.pendingEntries.push(entry);
+        if (immediate || type !== "text" && type !== "thinking") {
+          if (this.entryFlushTimer) {
+            clearTimeout(this.entryFlushTimer);
+            this.entryFlushTimer = null;
+          }
+          void this.flushPendingEntries();
+          return;
         }
-        if (this.appendLogCb) {
-          this.appendLogCb(entry).catch((err) => {
-            this.log.warn(`appendLog callback failed for entry (${type}): ${err instanceof Error ? err.message : String(err)}`);
-          });
+        if (this.pendingEntries.length >= ENTRY_BATCH_SIZE) {
+          if (this.entryFlushTimer) {
+            clearTimeout(this.entryFlushTimer);
+            this.entryFlushTimer = null;
+          }
+          void this.flushPendingEntries();
+          return;
         }
+        this.scheduleEntryFlush();
       }
       flushTextBuffer() {
         if (this.textBuffer.length === 0) return Promise.resolve();
         const chunk = this.textBuffer;
         this.textBuffer = "";
-        const entry = {
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          taskId: this.taskId,
-          text: chunk,
-          type: "text",
-          ...this.agent !== void 0 && { agent: this.agent }
-        };
-        const promises = [];
-        if (this.store && this.taskId) {
-          promises.push(
-            this.store.appendAgentLog(this.taskId, chunk, "text", void 0, this.agent).catch((err) => {
-              this.log.warn(`Failed to flush text buffer for ${this.taskId}: ${err instanceof Error ? err.message : String(err)}`);
-            })
-          );
-        }
-        if (this.appendLogCb) {
-          promises.push(
-            this.appendLogCb(entry).catch((err) => {
-              this.log.warn(`appendLog callback failed for text flush: ${err instanceof Error ? err.message : String(err)}`);
-            })
-          );
-        }
-        return Promise.all(promises).then(() => void 0);
+        this.writeEntry(chunk, "text", void 0, `Failed to flush text buffer for ${this.taskId}`, true);
+        return this.flushPendingEntries();
       }
       flushThinkingBuffer() {
         if (this.thinkingBuffer.length === 0) return Promise.resolve();
         const chunk = this.thinkingBuffer;
         this.thinkingBuffer = "";
-        const entry = {
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          taskId: this.taskId,
-          text: chunk,
-          type: "thinking",
-          ...this.agent !== void 0 && { agent: this.agent }
-        };
-        const promises = [];
-        if (this.store && this.taskId) {
-          promises.push(
-            this.store.appendAgentLog(this.taskId, chunk, "thinking", void 0, this.agent).catch((err) => {
-              this.log.warn(`Failed to flush thinking buffer for ${this.taskId}: ${err instanceof Error ? err.message : String(err)}`);
-            })
-          );
-        }
-        if (this.appendLogCb) {
-          promises.push(
-            this.appendLogCb(entry).catch((err) => {
-              this.log.warn(`appendLog callback failed for thinking flush: ${err instanceof Error ? err.message : String(err)}`);
-            })
-          );
-        }
-        return Promise.all(promises).then(() => void 0);
+        this.writeEntry(chunk, "thinking", void 0, `Failed to flush thinking buffer for ${this.taskId}`, true);
+        return this.flushPendingEntries();
       }
       scheduleFlush() {
         if (this.flushTimer) return;
@@ -52191,6 +52289,52 @@ var init_agent_logger = __esm({
           this.flushThinkingBuffer();
         }, this.flushIntervalMs);
       }
+      scheduleEntryFlush() {
+        if (this.entryFlushTimer) return;
+        this.entryFlushTimer = setTimeout(() => {
+          this.entryFlushTimer = null;
+          void this.flushPendingEntries();
+        }, this.flushIntervalMs);
+      }
+      async flushPendingEntries() {
+        if (this.pendingEntries.length === 0) {
+          return;
+        }
+        const entries = this.pendingEntries;
+        this.pendingEntries = [];
+        if (this.store && this.taskId) {
+          if (typeof this.store.appendAgentLogBatch === "function") {
+            await this.store.appendAgentLogBatch(
+              entries.map((entry) => ({
+                taskId: entry.taskId,
+                text: entry.text,
+                type: entry.type,
+                detail: entry.detail,
+                agent: entry.agent
+              }))
+            ).catch((err) => {
+              this.log.warn(`Failed to flush agent log batch for ${this.taskId}: ${err instanceof Error ? err.message : String(err)}`);
+            });
+          } else {
+            await Promise.all(
+              entries.map(
+                (entry) => this.store.appendAgentLog(entry.taskId, entry.text, entry.type, entry.detail, entry.agent).catch((err) => {
+                  this.log.warn(`Failed to flush agent log entry for ${this.taskId}: ${err instanceof Error ? err.message : String(err)}`);
+                })
+              )
+            );
+          }
+        }
+        if (this.appendLogCb) {
+          await Promise.all(
+            entries.map(
+              (entry) => this.appendLogCb(entry).catch((err) => {
+                this.log.warn(`appendLog callback failed for entry (${entry.type}): ${err instanceof Error ? err.message : String(err)}`);
+              })
+            )
+          );
+        }
+      }
     };
   }
 });
@@ -65767,6 +65911,20 @@ The tool prevents your session from being killed by the inactivity watchdog duri
               );
               this.activeStepExecutors.delete(task.id);
             }
+            if (this.activeWorkflowStepSessions.has(task.id)) {
+              executorLog.log(`${task.id} moved from in-progress to ${to} \u2014 terminating workflow step session`);
+              this.pausedAborted.add(task.id);
+              this.options.stuckTaskDetector?.untrackTask(task.id);
+              const workflowSession = this.activeWorkflowStepSessions.get(task.id);
+              const sessionWithAbort = workflowSession;
+              if (typeof sessionWithAbort.abort === "function") {
+                void sessionWithAbort.abort().catch((err) => {
+                  executorLog.warn(`Failed to abort workflow step session for ${task.id}: ${err}`);
+                });
+              }
+              workflowSession.dispose();
+              this.activeWorkflowStepSessions.delete(task.id);
+            }
             this.disposeSubagentsForTask(task.id, `parent moved from in-progress to ${to}`);
             this.loopRecoveryState.delete(task.id);
             this.spawnedAgents.delete(task.id);
@@ -65799,8 +65957,42 @@ The tool prevents your session from being killed by the inactivity watchdog duri
               this.disposeSubagentsForTask(task.id, "task paused");
               return;
             }
-            if (!task.paused && task.column === "in-progress" && !this.activeSessions.has(task.id) && !this.activeStepExecutors.has(task.id)) {
+            if (task.paused && this.activeWorkflowStepSessions.has(task.id)) {
+              executorLog.log(`Pausing ${task.id} \u2014 terminating workflow step session`);
+              this.pausedAborted.add(task.id);
+              this.options.stuckTaskDetector?.untrackTask(task.id);
+              const workflowSession = this.activeWorkflowStepSessions.get(task.id);
+              const sessionWithAbort = workflowSession;
+              if (typeof sessionWithAbort.abort === "function") {
+                await sessionWithAbort.abort().catch(
+                  (err) => executorLog.warn(`Failed to abort workflow step session for pause ${task.id}: ${err}`)
+                );
+              }
+              workflowSession.dispose();
+              this.activeWorkflowStepSessions.delete(task.id);
+              this.loopRecoveryState.delete(task.id);
+              this.spawnedAgents.delete(task.id);
+              this.stuckAborted.delete(task.id);
+              this.disposeSubagentsForTask(task.id, "task paused");
+              return;
+            }
+            if (!task.paused && task.column === "in-progress" && !this.activeSessions.has(task.id) && !this.activeStepExecutors.has(task.id) && !this.activeWorkflowStepSessions.has(task.id)) {
               if (!this.executing.has(task.id) && !this.resumingUnpaused.has(task.id) && !this.recoveringCompleted.has(task.id)) {
+                const pauseLabel = await this.getExecutionPauseLabel();
+                if (pauseLabel) {
+                  executorLog.log(`Skipping unpause resume for ${task.id} \u2014 ${pauseLabel} active`);
+                  return;
+                }
+                if (this.isTaskWorkComplete(task) && !task.mergeDetails) {
+                  this.recoveringCompleted.add(task.id);
+                  executorLog.log(`${task.id} unpaused with completed work and no session \u2014 recovering directly to in-review`);
+                  void this.recoverCompletedTask(task).catch(
+                    (err) => executorLog.error(`Failed to recover completed unpaused task ${task.id}:`, err)
+                  ).finally(() => {
+                    this.recoveringCompleted.delete(task.id);
+                  });
+                  return;
+                }
                 this.resumingUnpaused.add(task.id);
                 executorLog.log(`Unpaused ${task.id} in-progress with no session \u2014 resuming execution`);
                 try {
@@ -65919,6 +66111,22 @@ The tool prevents your session from being killed by the inactivity watchdog duri
               this.spawnedAgents.delete(taskId);
               this.stuckAborted.delete(taskId);
             }
+            for (const [taskId, workflowSession] of this.activeWorkflowStepSessions) {
+              executorLog.log(`Global pause \u2014 terminating workflow step session for ${taskId}`);
+              this.pausedAborted.add(taskId);
+              this.options.stuckTaskDetector?.untrackTask(taskId);
+              const sessionWithAbort = workflowSession;
+              if (typeof sessionWithAbort.abort === "function") {
+                void sessionWithAbort.abort().catch((err) => {
+                  executorLog.warn(`Failed to abort workflow step session for ${taskId}: ${err}`);
+                });
+              }
+              workflowSession.dispose();
+              this.activeWorkflowStepSessions.delete(taskId);
+              this.loopRecoveryState.delete(taskId);
+              this.spawnedAgents.delete(taskId);
+              this.stuckAborted.delete(taskId);
+            }
           }
         });
       }
@@ -65936,6 +66144,8 @@ The tool prevents your session from being killed by the inactivity watchdog duri
       activeSessions = /* @__PURE__ */ new Map();
       /** Active step-session executors per task (mutually exclusive with activeSessions). */
       activeStepExecutors = /* @__PURE__ */ new Map();
+      /** Active pre-merge workflow step sessions per task. */
+      activeWorkflowStepSessions = /* @__PURE__ */ new Map();
       /**
        * Reviewer subagent sessions per task. Reviewers (`reviewer.ts`) create their
        * own AgentSessions that aren't part of `activeSessions`/`activeStepExecutors`,
@@ -65982,6 +66192,69 @@ The tool prevents your session from being killed by the inactivity watchdog duri
         await this.store.mergeTask(taskId);
         return "merged";
       }
+      async getExecutionPauseLabel() {
+        const settings = await this.store.getSettings();
+        if (settings.globalPause) return "global pause";
+        if (settings.enginePaused) return "engine pause";
+        return null;
+      }
+      async shouldDeferCompletionForGlobalPause(taskId, context) {
+        const settings = await this.store.getSettings();
+        if (!settings.globalPause) {
+          return false;
+        }
+        this.clearCompletedTaskWatchdog(taskId);
+        executorLog.log(`${taskId}: completion handoff deferred \u2014 global pause active (${context})`);
+        await this.store.logEntry(
+          taskId,
+          `Completion handoff deferred \u2014 global pause active (${context})`,
+          void 0,
+          this.currentRunContext
+        ).catch(() => void 0);
+        return true;
+      }
+      async shouldDeferWorkflowStepCompletion(taskId, context) {
+        let latestTask = null;
+        try {
+          latestTask = await this.store.getTask(taskId);
+        } catch {
+          latestTask = null;
+        }
+        if (latestTask?.paused || this.pausedAborted.has(taskId)) {
+          this.clearCompletedTaskWatchdog(taskId);
+          executorLog.log(`${taskId}: completion handoff deferred \u2014 task paused (${context})`);
+          await this.store.logEntry(
+            taskId,
+            `Completion handoff deferred \u2014 task paused (${context})`,
+            void 0,
+            this.currentRunContext
+          ).catch(() => void 0);
+          return true;
+        }
+        return this.shouldDeferCompletionForGlobalPause(taskId, context);
+      }
+      async parkTaskAfterWorkflowStepPause(taskId) {
+        let latestTask = null;
+        try {
+          latestTask = await this.store.getTask(taskId);
+        } catch {
+          latestTask = null;
+        }
+        if (!latestTask?.paused) {
+          return false;
+        }
+        executorLog.log(`${taskId}: workflow step interrupted by task pause \u2014 moving to todo`);
+        await this.store.logEntry(
+          taskId,
+          "Execution paused during pre-merge workflow step \u2014 moved to todo",
+          void 0,
+          this.currentRunContext
+        ).catch(() => void 0);
+        if (latestTask.column === "in-progress") {
+          await this.store.moveTask(taskId, "todo", { preserveResumeState: true });
+        }
+        return true;
+      }
       /** Child agent sessions keyed by agent ID. Used for termination. */
       childSessions = /* @__PURE__ */ new Map();
       /** Total count of currently spawned agents (across all parents). */
@@ -66176,11 +66449,15 @@ The tool prevents your session from being killed by the inactivity watchdog duri
         this.clearCompletedTaskWatchdog(taskId);
         const handle = setTimeout(async () => {
           this.completedTaskWatchdogs.delete(taskId);
-          if (this.recoveringCompleted.has(taskId) || this.executing.has(taskId) || this.activeSessions.has(taskId) || this.activeStepExecutors.has(taskId) || this.resumingUnpaused.has(taskId)) {
+          if (this.recoveringCompleted.has(taskId) || this.executing.has(taskId) || this.activeSessions.has(taskId) || this.activeStepExecutors.has(taskId) || this.activeWorkflowStepSessions.has(taskId) || this.resumingUnpaused.has(taskId)) {
             return;
           }
           this.recoveringCompleted.add(taskId);
           try {
+            const pauseLabel = await this.getExecutionPauseLabel();
+            if (pauseLabel) {
+              return;
+            }
             let currentTask = null;
             try {
               currentTask = await this.store.getTask(taskId);
@@ -66226,6 +66503,11 @@ The tool prevents your session from being killed by the inactivity watchdog duri
        *   stuck.
        */
       async performWorkflowRerunBounce(taskId, worktreePath, preserveResumeState = true) {
+        const pauseLabel = await this.getExecutionPauseLabel();
+        if (pauseLabel) {
+          executorLog.log(`${taskId}: workflow rerun deferred \u2014 ${pauseLabel} active`);
+          return "deferred-paused";
+        }
         if (this.workflowRerunPending.has(taskId)) {
           executorLog.warn(`${taskId}: workflow rerun bounce already in flight \u2014 skipping re-entry`);
           return "skipped-pending";
@@ -66236,6 +66518,10 @@ The tool prevents your session from being killed by the inactivity watchdog duri
           if (!latestTask) {
             throw new Error("task missing during workflow rerun bounce");
           }
+          if (latestTask.paused) {
+            executorLog.log(`${taskId}: workflow rerun deferred \u2014 task is paused`);
+            return "deferred-paused";
+          }
           if (latestTask.column === "in-progress") {
             const originalExecutionStartedAt = latestTask.executionStartedAt;
             if (preserveResumeState) {
@@ -66247,11 +66533,21 @@ The tool prevents your session from being killed by the inactivity watchdog duri
               worktree: worktreePath,
               executionStartedAt: originalExecutionStartedAt ?? null
             });
+            const pauseLabelAfterTodo = await this.getExecutionPauseLabel();
+            if (pauseLabelAfterTodo) {
+              executorLog.log(`${taskId}: workflow rerun parked in todo \u2014 ${pauseLabelAfterTodo} became active during bounce`);
+              return "deferred-paused";
+            }
             await this.store.moveTask(taskId, "in-progress");
             return "bounced";
           }
           if (latestTask.column === "todo") {
             await this.store.updateTask(taskId, { worktree: worktreePath });
+            const pauseLabelBeforeResume = await this.getExecutionPauseLabel();
+            if (pauseLabelBeforeResume) {
+              executorLog.log(`${taskId}: workflow rerun parked in todo \u2014 ${pauseLabelBeforeResume} became active before resume`);
+              return "deferred-paused";
+            }
             await this.store.moveTask(taskId, "in-progress");
             return "bounced";
           }
@@ -66267,8 +66563,10 @@ The tool prevents your session from being killed by the inactivity watchdog duri
             const outcome = await this.performWorkflowRerunBounce(taskId, worktreePath, preserveResumeState);
             if (outcome === "bounced") {
               executorLog.log(successMessage);
-            } else {
+            } else if (outcome === "skipped-pending") {
               executorLog.warn(`${taskId}: rerun bounce skipped \u2014 another bounce already in flight`);
+            } else {
+              executorLog.log(`${taskId}: rerun bounce deferred while pause is active`);
             }
           } catch (err) {
             const errorMessage = err instanceof Error ? err.message : String(err);
@@ -66277,6 +66575,11 @@ The tool prevents your session from being killed by the inactivity watchdog duri
         }, 0);
         const watchdog = setTimeout(async () => {
           this.workflowRerunWatchdogs.delete(taskId);
+          const pauseLabel = await this.getExecutionPauseLabel();
+          if (pauseLabel) {
+            executorLog.log(`${taskId}: workflow rerun watchdog skipped \u2014 ${pauseLabel} active`);
+            return;
+          }
           let currentTask = null;
           try {
             currentTask = await this.store.getTask(taskId);
@@ -66299,7 +66602,7 @@ The tool prevents your session from being killed by the inactivity watchdog duri
             const outcome = await this.performWorkflowRerunBounce(taskId, worktreePath, preserveResumeState);
             if (outcome === "bounced") {
               executorLog.warn(`${taskId}: workflow rerun watchdog retry succeeded`);
-            } else {
+            } else if (outcome === "skipped-pending") {
               executorLog.error(
                 `${taskId}: workflow rerun watchdog retry skipped \u2014 original bounce still in flight after ${WORKFLOW_RERUN_WATCHDOG_MS / 1e3}s; task may be stuck`
               );
@@ -66307,6 +66610,8 @@ The tool prevents your session from being killed by the inactivity watchdog duri
                 taskId,
                 `Workflow rerun watchdog retry skipped \u2014 original bounce still in flight after ${WORKFLOW_RERUN_WATCHDOG_MS / 1e3}s; task may be stuck`
               ).catch(() => void 0);
+            } else {
+              executorLog.log(`${taskId}: workflow rerun watchdog retry deferred while pause is active`);
             }
           } catch (err) {
             const errorMessage = err instanceof Error ? err.message : String(err);
@@ -66429,11 +66734,17 @@ The tool prevents your session from being killed by the inactivity watchdog duri
        */
       async recoverCompletedTask(task) {
         try {
-          if (this.executing.has(task.id) || this.activeSessions.has(task.id) || this.activeStepExecutors.has(task.id) || this.resumingUnpaused.has(task.id)) {
+          if (this.executing.has(task.id) || this.activeSessions.has(task.id) || this.activeStepExecutors.has(task.id) || this.activeWorkflowStepSessions.has(task.id) || this.resumingUnpaused.has(task.id)) {
             executorLog.log(`${task.id}: skipping recoverCompletedTask \u2014 task has active execution in flight`);
             return false;
           }
           const settings = await this.store.getSettings();
+          if (settings.globalPause || settings.enginePaused) {
+            executorLog.log(
+              `${task.id}: skipping recoverCompletedTask \u2014 ${settings.globalPause ? "global pause" : "engine pause"} active`
+            );
+            return false;
+          }
           if (task.worktree && existsSync27(task.worktree)) {
             const modifiedFiles = await this.captureModifiedFiles(task.worktree, task.baseCommitSha);
             if (modifiedFiles.length > 0) {
@@ -66441,7 +66752,16 @@ The tool prevents your session from being killed by the inactivity watchdog duri
               executorLog.log(`${task.id}: recovered ${modifiedFiles.length} modified files`);
             }
             if (task.executionMode !== "fast") {
+              if (await this.shouldDeferCompletionForGlobalPause(task.id, "before workflow steps during completed-task recovery")) {
+                return false;
+              }
               const workflowResult = await this.runWorkflowSteps(task, task.worktree, settings);
+              if (workflowResult === "deferred-paused") {
+                if (this.pausedAborted.has(task.id)) {
+                  this.pausedAborted.delete(task.id);
+                }
+                return false;
+              }
               if (!workflowResult.allPassed) {
                 await this.sendTaskBackForFix(task, task.worktree, workflowResult.feedback, workflowResult.stepName || "Unknown", "Workflow step failed during recovery", false);
                 return true;
@@ -66450,6 +66770,9 @@ The tool prevents your session from being killed by the inactivity watchdog duri
               executorLog.log(`${task.id}: fast mode \u2014 skipping workflow steps on auto-recovery`);
             }
           }
+          if (await this.shouldDeferCompletionForGlobalPause(task.id, "before in-review transition during completed-task recovery")) {
+            return false;
+          }
           await this.persistTokenUsage(task.id);
           await this.store.moveTask(task.id, "in-review");
           this.clearCompletedTaskWatchdog(task.id);
@@ -66515,6 +66838,13 @@ The tool prevents your session from being killed by the inactivity watchdog duri
        * directly to in-review without spawning a new agent session.
        */
       async resumeOrphaned() {
+        const settings = await this.store.getSettings();
+        if (settings.globalPause || settings.enginePaused) {
+          executorLog.log(
+            `resumeOrphaned skipped \u2014 ${settings.globalPause ? "global pause" : "engine pause"} is active`
+          );
+          return;
+        }
         const tasks = await this.store.listTasks({ slim: true, column: "in-progress" });
         const inProgress = tasks.filter(
           (t) => t.column === "in-progress" && !this.executing.has(t.id) && !t.paused
@@ -66953,8 +67283,21 @@ The tool prevents your session from being killed by the inactivity watchdog duri
                   await audit.filesystem({ type: "file:capture-modified", target: task.id, metadata: { files: modifiedFiles } });
                 }
                 this.scheduleCompletedTaskWatchdog(task.id, "step-session completion");
+                if (await this.shouldDeferCompletionForGlobalPause(task.id, "before workflow steps after step-session completion")) {
+                  return;
+                }
                 if (executionMode !== "fast") {
                   const workflowResult = await this.runWorkflowSteps(task, worktreePath, settings);
+                  if (workflowResult === "deferred-paused") {
+                    if (await this.parkTaskAfterWorkflowStepPause(task.id)) {
+                      this.pausedAborted.delete(task.id);
+                      return;
+                    }
+                    if (this.pausedAborted.has(task.id)) {
+                      this.pausedAborted.delete(task.id);
+                    }
+                    return;
+                  }
                   if (!workflowResult.allPassed) {
                     if (workflowResult.revisionRequested) {
                       await this.handleWorkflowRevisionRequest(task, worktreePath, workflowResult.feedback, workflowResult.stepName);
@@ -66972,6 +67315,9 @@ The tool prevents your session from being killed by the inactivity watchdog duri
                   await this.store.logEntry(task.id, "Fast mode \u2014 pre-merge workflow steps skipped", void 0, this.currentRunContext);
                 }
                 await this.store.updateTask(task.id, { workflowStepRetries: void 0, taskDoneRetryCount: null });
+                if (await this.shouldDeferCompletionForGlobalPause(task.id, "before in-review transition after step-session completion")) {
+                  return;
+                }
                 await this.store.moveTask(task.id, "in-review");
                 this.clearCompletedTaskWatchdog(task.id);
                 await audit.database({ type: "task:move", target: task.id, metadata: { to: "in-review" } });
@@ -67324,6 +67670,9 @@ The tool prevents your session from being killed by the inactivity watchdog duri
                 this.pausedAborted.delete(task.id);
                 wasPaused = true;
                 if (await this.shouldFinalizeCompletedTask(task.id, taskDone)) {
+                  if (await this.shouldDeferCompletionForGlobalPause(task.id, "paused after completion")) {
+                    return;
+                  }
                   executorLog.log(`${task.id} paused after completion (graceful session exit) \u2014 finalizing to in-review`);
                   await this.store.logEntry(task.id, "Execution paused after completion \u2014 finalizing to in-review");
                   await this.persistTokenUsage(task.id);
@@ -67360,8 +67709,23 @@ The tool prevents your session from being killed by the inactivity watchdog duri
                   executorLog.log(`${task.id}: captured ${modifiedFiles.length} modified files`);
                 }
                 this.scheduleCompletedTaskWatchdog(task.id, "task completion");
+                if (await this.shouldDeferCompletionForGlobalPause(task.id, "before workflow steps after task completion")) {
+                  return;
+                }
                 if (executionMode !== "fast") {
                   const workflowResult = await this.runWorkflowSteps(task, worktreePath, settings);
+                  if (workflowResult === "deferred-paused") {
+                    if (await this.parkTaskAfterWorkflowStepPause(task.id)) {
+                      this.pausedAborted.delete(task.id);
+                      wasPaused = true;
+                      return;
+                    }
+                    if (this.pausedAborted.has(task.id)) {
+                      this.pausedAborted.delete(task.id);
+                      wasPaused = true;
+                    }
+                    return;
+                  }
                   if (!workflowResult.allPassed) {
                     if (workflowResult.revisionRequested) {
                       await this.handleWorkflowRevisionRequest(task, worktreePath, workflowResult.feedback, workflowResult.stepName);
@@ -67379,6 +67743,9 @@ The tool prevents your session from being killed by the inactivity watchdog duri
                   await this.store.logEntry(task.id, "Fast mode \u2014 pre-merge workflow steps skipped", void 0, this.currentRunContext);
                 }
                 await this.store.updateTask(task.id, { workflowStepRetries: void 0, taskDoneRetryCount: null });
+                if (await this.shouldDeferCompletionForGlobalPause(task.id, "before in-review transition after task completion")) {
+                  return;
+                }
                 await this.persistTokenUsage(task.id);
                 await this.store.moveTask(task.id, "in-review");
                 this.clearCompletedTaskWatchdog(task.id);
@@ -67503,8 +67870,23 @@ The tool prevents your session from being killed by the inactivity watchdog duri
                     executorLog.log(`${task.id}: captured ${modifiedFiles.length} modified files`);
                   }
                   this.scheduleCompletedTaskWatchdog(task.id, "task completion retry");
+                  if (await this.shouldDeferCompletionForGlobalPause(task.id, "before workflow steps after task completion retry")) {
+                    return;
+                  }
                   if (executionMode !== "fast") {
                     const workflowResult = await this.runWorkflowSteps(task, worktreePath, settings);
+                    if (workflowResult === "deferred-paused") {
+                      if (await this.parkTaskAfterWorkflowStepPause(task.id)) {
+                        this.pausedAborted.delete(task.id);
+                        wasPaused = true;
+                        return;
+                      }
+                      if (this.pausedAborted.has(task.id)) {
+                        this.pausedAborted.delete(task.id);
+                        wasPaused = true;
+                      }
+                      return;
+                    }
                     if (!workflowResult.allPassed) {
                       if (workflowResult.revisionRequested) {
                         await this.handleWorkflowRevisionRequest(task, worktreePath, workflowResult.feedback, workflowResult.stepName);
@@ -67518,6 +67900,9 @@ The tool prevents your session from being killed by the inactivity watchdog duri
                     await this.store.logEntry(task.id, "Fast mode \u2014 pre-merge workflow steps skipped", void 0, this.currentRunContext);
                   }
                   await this.store.updateTask(task.id, { workflowStepRetries: void 0, taskDoneRetryCount: null });
+                  if (await this.shouldDeferCompletionForGlobalPause(task.id, "before in-review transition after task completion retry")) {
+                    return;
+                  }
                   await this.persistTokenUsage(task.id);
                   await this.store.moveTask(task.id, "in-review");
                   this.clearCompletedTaskWatchdog(task.id);
@@ -67610,6 +67995,9 @@ The tool prevents your session from being killed by the inactivity watchdog duri
           } else if (this.pausedAborted.has(task.id)) {
             this.pausedAborted.delete(task.id);
             if (await this.shouldFinalizeCompletedTask(task.id, taskDone)) {
+              if (await this.shouldDeferCompletionForGlobalPause(task.id, "paused after completion")) {
+                return;
+              }
               executorLog.log(`${task.id} paused after completion \u2014 finalizing to in-review`);
               await this.store.logEntry(task.id, "Execution paused after completion \u2014 finalizing to in-review", void 0, this.currentRunContext);
               await this.persistTokenUsage(task.id);
@@ -67968,22 +68356,28 @@ The tool prevents your session from being killed by the inactivity watchdog duri
             if (params.summary) {
               await store.updateTask(taskId, { summary: params.summary });
             }
-            await store.updateTask(taskId, { paused: false, status: null });
+            const settings = await store.getSettings();
+            const hardPauseActive = Boolean(task.paused || settings.globalPause);
+            if (hardPauseActive) {
+              await store.updateTask(taskId, { status: null });
+            } else {
+              await store.updateTask(taskId, { paused: false, status: null });
+            }
             await store.logEntry(taskId, "Task marked done by agent");
             const latestTask = await store.getTask(taskId);
             let latestColumn = latestTask.column;
             if (latestColumn === "todo") {
               await store.logEntry(
                 taskId,
-                "fn_task_done called while task was in todo \u2014 promoting to in-progress before completion handoff"
+                hardPauseActive ? "fn_task_done called while task was in todo during pause \u2014 promoting to in-progress for deferred completion handoff" : "fn_task_done called while task was in todo \u2014 promoting to in-progress before completion handoff"
               );
               await store.moveTask(taskId, "in-progress");
               latestColumn = "in-progress";
             }
-            if (latestColumn === "in-progress") {
+            if (latestColumn === "in-progress" && !hardPauseActive) {
               this.scheduleCompletedTaskWatchdog(taskId, "fn_task_done");
             }
-            const successMessage = params.summary ? "Task marked complete with summary. All steps done. Moving to in-review." : "Task marked complete. All steps done. Moving to in-review.";
+            const successMessage = hardPauseActive ? "Task marked complete. Completion handoff deferred until pause is cleared." : params.summary ? "Task marked complete with summary. All steps done. Moving to in-review." : "Task marked complete. All steps done. Moving to in-review.";
             return {
               content: [{ type: "text", text: successMessage }],
               details: {}
@@ -68558,6 +68952,9 @@ ${failureFeedback}
             await this.store.updateTask(task.id, { workflowStepResults: results });
             continue;
           }
+          if (await this.shouldDeferWorkflowStepCompletion(task.id, `before workflow step '${ws.name}'`)) {
+            return "deferred-paused";
+          }
           await this.store.logEntry(task.id, `[pre-merge] Starting workflow step: ${ws.name} (${stepMode} mode)`);
           executorLog.log(`${task.id} \u2014 [pre-merge] running workflow step: ${ws.name} (${stepMode} mode)`);
           const startedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -68572,6 +68969,9 @@ ${failureFeedback}
           await this.store.updateTask(task.id, { workflowStepResults: results });
           try {
             const result = stepMode === "script" ? await this.executeScriptWorkflowStep(task, ws, worktreePath, settings) : await this.executeWorkflowStep(task, ws, worktreePath, settings);
+            if (await this.shouldDeferWorkflowStepCompletion(task.id, `workflow step '${ws.name}'`)) {
+              return "deferred-paused";
+            }
             const completedAt = (/* @__PURE__ */ new Date()).toISOString();
             if (result.success) {
               await this.store.logEntry(task.id, `[timing] Workflow step '${ws.name}' completed in ${Date.now() - stepStartedAtMs}ms`);
@@ -68637,6 +69037,9 @@ ${failureFeedback}
               };
             }
           } catch (err) {
+            if (await this.shouldDeferWorkflowStepCompletion(task.id, `workflow step '${ws.name}'`)) {
+              return "deferred-paused";
+            }
             const { message: errorMessage, detail: errorDetail, stack: errorStack } = formatError(err);
             const completedAt = (/* @__PURE__ */ new Date()).toISOString();
             await this.store.logEntry(
@@ -68802,6 +69205,7 @@ and show an appropriate message to the user.\`
             task.id,
             `Workflow step '${workflowStep.name}' using model: ${describeModel(session)}${useOverride && attemptLabel === "primary" ? " (workflow step override)" : ""}${attemptLabel === "fallback" ? " (fallback after timeout)" : ""}`
           );
+          this.activeWorkflowStepSessions.set(task.id, session);
           let output = "";
           session.subscribe((event) => {
             if (event.type === "message_update") {
@@ -68874,6 +69278,10 @@ Review the work done in this worktree and evaluate it against the criteria in yo
             return { success: false, error: errorMessage };
           } finally {
             if (timeoutHandle) clearTimeout(timeoutHandle);
+            const activeWorkflowStepSession = this.activeWorkflowStepSessions.get(task.id);
+            if (activeWorkflowStepSession === session) {
+              this.activeWorkflowStepSessions.delete(task.id);
+            }
             void timedOut;
           }
         };
@@ -70617,6 +71025,15 @@ var init_scheduler = __esm({
               schedulerLog.log(`Task ${task.id} is paused \u2014 skipping dispatch`);
               continue;
             }
+            const latestSettings = await this.store.getSettings();
+            if (latestSettings.globalPause) {
+              schedulerLog.log(`Task ${task.id} dispatch aborted \u2014 globalPause became active mid-pass`);
+              continue;
+            }
+            if (latestSettings.enginePaused) {
+              schedulerLog.log(`Task ${task.id} dispatch aborted \u2014 enginePaused became active mid-pass`);
+              continue;
+            }
             let effectiveNode = resolveEffectiveNode(freshTask, settings);
             schedulerLog.log(`Task ${task.id} routed to node=${effectiveNode.nodeId ?? "local"} (source=${effectiveNode.source})`);
             if (effectiveNode.nodeId !== void 0 && this.options.nodeHealthMonitor) {
@@ -75754,6 +76171,36 @@ function execCommand(command, options) {
     });
   });
 }
+function isInProcessBackupCommand(command) {
+  if (!command) return false;
+  const trimmed = command.trim();
+  if (!trimmed) return false;
+  if (SHELL_METACHARACTERS_REGEX.test(trimmed)) return false;
+  const tokens = trimmed.split(/\s+/).map((tok) => tok.toLowerCase());
+  let cursor = 0;
+  if (tokens[cursor] === "npx") {
+    cursor += 1;
+    while (cursor < tokens.length) {
+      const tok = tokens[cursor];
+      if (tok === void 0 || !tok.startsWith("-")) break;
+      const takesValue = (tok === "-p" || tok === "--package") && cursor + 1 < tokens.length && tokens[cursor + 1] !== void 0 && !tokens[cursor + 1].startsWith("-");
+      cursor += takesValue ? 2 : 1;
+    }
+  }
+  const binary = tokens[cursor];
+  if (!binary || !FUSION_BINARY_TOKENS.has(binary)) return false;
+  cursor += 1;
+  if (tokens[cursor] !== "backup") return false;
+  cursor += 1;
+  if (tokens[cursor] !== "--create") return false;
+  cursor += 1;
+  for (; cursor < tokens.length; cursor += 1) {
+    const tok = tokens[cursor];
+    if (!tok) continue;
+    if (!tok.startsWith("-")) return false;
+  }
+  return true;
+}
 async function createAiPromptExecutor(cwd) {
   const disposeLog = createLogger2("cron-runner");
   return async (prompt, modelProvider, modelId) => {
@@ -75793,7 +76240,7 @@ function truncateOutput(stdout, stderr) {
   }
   return combined;
 }
-var log14, DEFAULT_TIMEOUT_MS6, MAX_BUFFER, MAX_OUTPUT_LENGTH, DEFAULT_POLL_INTERVAL_MS, MIN_POLL_INTERVAL_MS, CronRunner, AI_AUTOMATION_SYSTEM_PROMPT;
+var log14, FUSION_BINARY_TOKENS, SHELL_METACHARACTERS_REGEX, DEFAULT_TIMEOUT_MS6, MAX_BUFFER, MAX_OUTPUT_LENGTH, DEFAULT_POLL_INTERVAL_MS, MIN_POLL_INTERVAL_MS, CronRunner, AI_AUTOMATION_SYSTEM_PROMPT;
 var init_cron_runner = __esm({
   "../engine/src/cron-runner.ts"() {
     "use strict";
@@ -75802,6 +76249,14 @@ var init_cron_runner = __esm({
     init_shell_utils();
     init_pi();
     log14 = createLogger2("cron-runner");
+    FUSION_BINARY_TOKENS = /* @__PURE__ */ new Set([
+      "fn",
+      "fusion",
+      "runfusion",
+      "runfusion.ai",
+      "@runfusion/fusion"
+    ]);
+    SHELL_METACHARACTERS_REGEX = /[&|;<>`$()]/;
     DEFAULT_TIMEOUT_MS6 = 5 * 60 * 1e3;
     MAX_BUFFER = 1024 * 1024;
     MAX_OUTPUT_LENGTH = 10 * 1024;
@@ -75942,6 +76397,9 @@ var init_cron_runner = __esm({
        */
       async executeLegacyCommand(schedule, startedAt) {
         log14.log(`Executing ${schedule.name} (${schedule.id}): ${schedule.command}`);
+        if (isInProcessBackupCommand(schedule.command)) {
+          return this.executeBackupInProcess(schedule, startedAt);
+        }
         try {
           const timeoutMs = schedule.timeoutMs ?? DEFAULT_TIMEOUT_MS6;
           const { stdout, stderr } = await execCommand(schedule.command, {
@@ -75972,6 +76430,47 @@ var init_cron_runner = __esm({
           };
         }
       }
+      /**
+       * Run an auto-backup schedule in-process via the engine's open TaskStore,
+       * bypassing the shell-out that would otherwise invoke an outdated fusion
+       * binary on PATH. See `isInProcessBackupCommand` for the matching contract.
+       */
+      async executeBackupInProcess(schedule, startedAt) {
+        const action = await this.runBackupActionInProcess();
+        if (action.success) {
+          log14.log(`\u2713 ${schedule.name} completed in-process`);
+        } else {
+          log14.warn(`\u2717 ${schedule.name} in-process backup ${action.error ? `threw: ${action.error}` : `reported failure: ${action.output}`}`);
+        }
+        return {
+          success: action.success,
+          output: action.output,
+          error: action.error,
+          startedAt,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      /**
+       * Shared in-process backup execution used by both the legacy-command path
+       * and the command-step path. Returns the success/output/error tuple in
+       * a shape that callers can wrap into either a run or a step result.
+       */
+      async runBackupActionInProcess() {
+        try {
+          const { runBackupCommand: runBackupCommand2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+          const fusionDir = this.store.getFusionDir();
+          const settings = await this.store.getSettings();
+          const result = await runBackupCommand2(fusionDir, settings);
+          return {
+            success: result.success,
+            output: truncateOutput(result.output ?? "", ""),
+            error: result.success ? void 0 : result.output
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return { success: false, output: "", error: message };
+        }
+      }
       /**
        * Execute multiple steps sequentially.
        * Aggregates per-step results into an overall AutomationRunResult.
@@ -76060,6 +76559,19 @@ var init_cron_runner = __esm({
             completedAt: (/* @__PURE__ */ new Date()).toISOString()
           };
         }
+        if (isInProcessBackupCommand(step.command)) {
+          const action = await this.runBackupActionInProcess();
+          return {
+            stepId: step.id,
+            stepName: step.name,
+            stepIndex,
+            success: action.success,
+            output: action.output,
+            error: action.error,
+            startedAt,
+            completedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
         try {
           const { stdout, stderr } = await execCommand(step.command, {
             timeout: timeoutMs,
@@ -76251,6 +76763,7 @@ var init_routine_runner = __esm({
   "../engine/src/routine-runner.ts"() {
     "use strict";
     import_cron_parser4 = __toESM(require_dist2(), 1);
+    init_cron_runner();
     init_logger2();
     init_shell_utils();
     log15 = createLogger2("routine-runner");
@@ -76408,6 +76921,30 @@ var init_routine_runner = __esm({
         return this.executeCommand(routine.command ?? "", routine.timeoutMs, startedAt);
       }
       async executeCommand(command, timeoutMs, startedAt) {
+        if (isInProcessBackupCommand(command) && this.options.taskStore) {
+          try {
+            const { runBackupCommand: runBackupCommand2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+            const fusionDir = this.options.taskStore.getFusionDir();
+            const settings = await this.options.taskStore.getSettings();
+            const result = await runBackupCommand2(fusionDir, settings);
+            return {
+              success: result.success,
+              output: truncateOutput2(result.output ?? "", ""),
+              error: result.success ? void 0 : result.output,
+              startedAt,
+              completedAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+              success: false,
+              output: "",
+              error: message,
+              startedAt,
+              completedAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+          }
+        }
         try {
           const { stdout, stderr } = await execAsync6(command, {
             timeout: timeoutMs ?? DEFAULT_TIMEOUT_MS7,
@@ -77199,6 +77736,13 @@ var init_self_healing = __esm({
        * stale in-progress/planning tasks that no longer have a live worker.
        */
       async runStartupRecovery() {
+        const settings = await this.store.getSettings();
+        if (settings.globalPause || settings.enginePaused) {
+          log16.log(
+            `Startup recovery skipped \u2014 ${settings.globalPause ? "global pause" : "engine pause"} is active`
+          );
+          return;
+        }
         const steps = [
           { name: "no-progress-no-task-done", fn: () => this.recoverNoProgressNoTaskDoneFailures().then(() => void 0) },
           { name: "completed-tasks", fn: () => this.recoverCompletedTasks().then(() => void 0) },
@@ -77549,27 +78093,34 @@ var init_self_healing = __esm({
               log16.error(`Maintenance batch 1 step "${fn.name}" failed: ${stepErr instanceof Error ? stepErr.message : String(stepErr)}`);
             }
           }
-          const batch2Fns = [
-            { name: "recover-completed-tasks", fn: () => this.recoverCompletedTasks() },
-            { name: "recover-stale-incomplete-review", fn: () => this.recoverStaleIncompleteReviewTasks() },
-            { name: "recover-failed-pre-merge-steps", fn: () => this.recoverReviewTasksWithFailedPreMergeSteps() },
-            { name: "recover-interrupted-merging", fn: () => this.recoverInterruptedMergingTasks() },
-            { name: "recover-mergeable-review", fn: () => this.recoverMergeableReviewTasks() },
-            { name: "recover-merged-review", fn: () => this.recoverMergedReviewTasks() },
-            { name: "recover-misclassified-failures", fn: () => this.recoverMisclassifiedFailures() },
-            { name: "recover-no-progress-no-task-done", fn: () => this.recoverNoProgressNoTaskDoneFailures() },
-            { name: "recover-partial-progress-no-task-done", fn: () => this.recoverPartialProgressNoTaskDoneFailures() },
-            { name: "recover-orphaned-executions", fn: () => this.recoverOrphanedExecutions() },
-            { name: "recover-approved-triage", fn: () => this.recoverApprovedTriageTasks() },
-            { name: "recover-orphaned-planning", fn: () => this.recoverOrphanedPlanningTasks() },
-            { name: "recover-ghost-review", fn: () => this.recoverGhostReviewTasks() }
-          ];
-          for (const fn of batch2Fns) {
-            try {
-              await fn.fn();
-              log16.log(`Maintenance batch 2 step "${fn.name}" succeeded`);
-            } catch (stepErr) {
-              log16.error(`Maintenance batch 2 step "${fn.name}" failed: ${stepErr instanceof Error ? stepErr.message : String(stepErr)}`);
+          const recoverySettings = await this.store.getSettings();
+          if (recoverySettings.globalPause || recoverySettings.enginePaused) {
+            log16.log(
+              `Maintenance batch 2 skipped \u2014 ${recoverySettings.globalPause ? "global pause" : "engine pause"} is active`
+            );
+          } else {
+            const batch2Fns = [
+              { name: "recover-completed-tasks", fn: () => this.recoverCompletedTasks() },
+              { name: "recover-stale-incomplete-review", fn: () => this.recoverStaleIncompleteReviewTasks() },
+              { name: "recover-failed-pre-merge-steps", fn: () => this.recoverReviewTasksWithFailedPreMergeSteps() },
+              { name: "recover-interrupted-merging", fn: () => this.recoverInterruptedMergingTasks() },
+              { name: "recover-mergeable-review", fn: () => this.recoverMergeableReviewTasks() },
+              { name: "recover-merged-review", fn: () => this.recoverMergedReviewTasks() },
+              { name: "recover-misclassified-failures", fn: () => this.recoverMisclassifiedFailures() },
+              { name: "recover-no-progress-no-task-done", fn: () => this.recoverNoProgressNoTaskDoneFailures() },
+              { name: "recover-partial-progress-no-task-done", fn: () => this.recoverPartialProgressNoTaskDoneFailures() },
+              { name: "recover-orphaned-executions", fn: () => this.recoverOrphanedExecutions() },
+              { name: "recover-approved-triage", fn: () => this.recoverApprovedTriageTasks() },
+              { name: "recover-orphaned-planning", fn: () => this.recoverOrphanedPlanningTasks() },
+              { name: "recover-ghost-review", fn: () => this.recoverGhostReviewTasks() }
+            ];
+            for (const fn of batch2Fns) {
+              try {
+                await fn.fn();
+                log16.log(`Maintenance batch 2 step "${fn.name}" succeeded`);
+              } catch (stepErr) {
+                log16.error(`Maintenance batch 2 step "${fn.name}" failed: ${stepErr instanceof Error ? stepErr.message : String(stepErr)}`);
+              }
             }
           }
           const batch3Fns = [
@@ -79302,6 +79853,10 @@ var init_in_process_runtime = __esm({
        * before `start()` via `setMergeEnqueuer`.
        */
       mergeEnqueuer;
+      /** Tracks whether startup recovery was intentionally deferred due to pause state. */
+      startupRecoveryDeferred = false;
+      /** Prevent duplicate unpause recovery dispatches from racing each other. */
+      resumeAfterUnpauseRunning = false;
       /**
        * Start the runtime and initialize all subsystems.
        *
@@ -79335,7 +79890,7 @@ var init_in_process_runtime = __esm({
             runtimeLog.log(`TaskStore initialized for project ${this.config.projectId}`);
           }
           this.messageStore = new MessageStoreClass(this.taskStore.getDatabase());
-          this.pluginStore = new PluginStoreClass(this.taskStore.getFusionDir());
+          this.pluginStore = new PluginStoreClass(this.config.workingDirectory);
           await this.pluginStore.init();
           this.pluginLoader = new PluginLoaderClass({
             pluginStore: this.pluginStore,
@@ -79727,11 +80282,16 @@ var init_in_process_runtime = __esm({
           this.selfHealingManager.start();
           this.stuckTaskDetector.start();
           this.setupEventForwarding();
-          await this.selfHealingManager.recoverNoProgressNoTaskDoneFailures();
-          await this.executor.resumeOrphaned();
-          void this.selfHealingManager.runStartupRecovery().catch((err) => {
-            runtimeLog.error("Self-healing startup recovery failed:", err);
-          });
+          const startupSettings = await this.taskStore.getSettings();
+          if (startupSettings.globalPause || startupSettings.enginePaused) {
+            this.startupRecoveryDeferred = true;
+            runtimeLog.log(
+              `Startup recovery deferred \u2014 ${startupSettings.globalPause ? "global pause" : "engine pause"} is active`
+            );
+          } else {
+            this.startupRecoveryDeferred = false;
+            await this.resumeStartupRecoverySequence();
+          }
           this.scheduler.start();
           this.triageProcessor?.start();
           this.missionExecutionLoop = missionExecutionLoop;
@@ -79897,6 +80457,45 @@ var init_in_process_runtime = __esm({
       setMergeEnqueuer(enqueueMerge) {
         this.mergeEnqueuer = enqueueMerge;
       }
+      /**
+       * Resume executor/self-healing activity after an unpause transition.
+       *
+       * When startup recovery had been deferred, this replays the original startup
+       * ordering so orphan resume and self-healing cannot race each other.
+       */
+      async resumeAfterUnpause() {
+        if (!this.taskStore || !this.executor || !this.selfHealingManager) {
+          return;
+        }
+        if (this.resumeAfterUnpauseRunning) {
+          return;
+        }
+        this.resumeAfterUnpauseRunning = true;
+        try {
+          const settings = await this.taskStore.getSettings();
+          if (settings.globalPause || settings.enginePaused) {
+            runtimeLog.log(
+              `Unpause recovery still blocked \u2014 ${settings.globalPause ? "global pause" : "engine pause"} remains active`
+            );
+            return;
+          }
+          if (this.startupRecoveryDeferred) {
+            await this.resumeStartupRecoverySequence();
+            this.startupRecoveryDeferred = false;
+            return;
+          }
+          await this.executor.resumeOrphaned();
+        } finally {
+          this.resumeAfterUnpauseRunning = false;
+        }
+      }
+      async resumeStartupRecoverySequence() {
+        await this.selfHealingManager.recoverNoProgressNoTaskDoneFailures();
+        await this.executor.resumeOrphaned();
+        void this.selfHealingManager.runStartupRecovery().catch((err) => {
+          runtimeLog.error("Self-healing startup recovery failed:", err);
+        });
+      }
       /**
        * Get the project's TaskStore instance.
        * @throws Error if runtime has not been started
@@ -83736,13 +84335,13 @@ ${detail}`
           if (prev.globalPause && !s.globalPause) {
             runtimeLog.log("Global unpause \u2014 resuming agentic activity");
             try {
-              const executor = this.runtime.executor;
-              executor?.resumeOrphaned?.().catch(
-                (err) => runtimeLog.error("Failed to resume orphaned tasks on unpause:", err)
+              const runtime = this.runtime;
+              runtime.resumeAfterUnpause?.().catch(
+                (err) => runtimeLog.error("Failed to resume agentic activity on unpause:", err)
               );
             } catch (err) {
               runtimeLog.warn(
-                `Global unpause: failed to dispatch resumeOrphaned: ${err instanceof Error ? err.message : String(err)}`
+                `Global unpause: failed to dispatch resumeAfterUnpause: ${err instanceof Error ? err.message : String(err)}`
               );
             }
             if (s.autoMerge) {
@@ -83766,13 +84365,13 @@ ${detail}`
           if (prev.enginePaused && !s.enginePaused) {
             runtimeLog.log("Engine unpaused \u2014 resuming agentic activity");
             try {
-              const executor = this.runtime.executor;
-              executor?.resumeOrphaned?.().catch(
-                (err) => runtimeLog.error("Failed to resume orphaned tasks on engine unpause:", err)
+              const runtime = this.runtime;
+              runtime.resumeAfterUnpause?.().catch(
+                (err) => runtimeLog.error("Failed to resume agentic activity on engine unpause:", err)
               );
             } catch (err) {
               runtimeLog.warn(
-                `Engine unpause: failed to dispatch resumeOrphaned: ${err instanceof Error ? err.message : String(err)}`
+                `Engine unpause: failed to dispatch resumeAfterUnpause: ${err instanceof Error ? err.message : String(err)}`
               );
             }
             if (s.autoMerge) {
@@ -88894,7 +89493,7 @@ var init_src3 = __esm({
 });
 
 // ../../plugins/fusion-plugin-hermes-runtime/dist/cli-spawn.js
-import { spawn as spawn6, spawnSync } from "node:child_process";
+import { spawn as spawn6, spawnSync as spawnSync2 } from "node:child_process";
 import os2 from "node:os";
 import path, { sep as PATH_SEP } from "node:path";
 function resolveBinaryForSpawn(binary) {
@@ -88907,7 +89506,7 @@ function resolveBinaryForSpawn(binary) {
   if (cached)
     return cached;
   try {
-    const result = spawnSync("where", [binary], { encoding: "utf-8" });
+    const result = spawnSync2("where", [binary], { encoding: "utf-8" });
     if (result.status === 0) {
       const first = (result.stdout ?? "").trim().split(/\r?\n/)[0];
       if (first?.length) {
@@ -123889,7 +124488,7 @@ var require_commonjs4 = __commonJS({
     var node_url_1 = __require("node:url");
     var fs_1 = __require("fs");
     var actualFS = __importStar(__require("node:fs"));
-    var realpathSync2 = fs_1.realpathSync.native;
+    var realpathSync3 = fs_1.realpathSync.native;
     var promises_1 = __require("node:fs/promises");
     var minipass_1 = require_commonjs3();
     var defaultFS = {
@@ -123897,7 +124496,7 @@ var require_commonjs4 = __commonJS({
       readdir: fs_1.readdir,
       readdirSync: fs_1.readdirSync,
       readlinkSync: fs_1.readlinkSync,
-      realpathSync: realpathSync2,
+      realpathSync: realpathSync3,
       promises: {
         lstat: promises_1.lstat,
         readdir: promises_1.readdir,
@@ -136670,7 +137269,7 @@ Rules:
 // ../dashboard/src/routes/register-agent-import-export-generation-routes.ts
 import { createWriteStream } from "node:fs";
 import * as fsPromises2 from "node:fs/promises";
-import { tmpdir as tmpdir3 } from "node:os";
+import { tmpdir as tmpdir4 } from "node:os";
 import { join as join45, resolve as resolve22 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline as streamPipeline } from "node:stream/promises";
@@ -136712,7 +137311,7 @@ function registerAgentImportExportRoutes(ctx) {
       } else if (typeof outputDir === "string") {
         throw badRequest("outputDir cannot be empty");
       } else {
-        resolvedOutputDir = await mkdtemp(join45(tmpdir3(), "fusion-agent-export-"));
+        resolvedOutputDir = await mkdtemp(join45(tmpdir4(), "fusion-agent-export-"));
       }
       const result = await exportAgentsToDirectory2(agentsToExport, resolvedOutputDir, {
         companyName: typeof companyName === "string" ? companyName : void 0,
@@ -137027,7 +137626,7 @@ ${body}`;
         const archiveUrl = `https://github.com/${repoOwner}/${repoName}/archive/refs/heads/main.tar.gz`;
         let tempDir = null;
         try {
-          tempDir = await mkdtemp(join45(tmpdir3(), `fn-agent-import-${importCompanySlug}-`));
+          tempDir = await mkdtemp(join45(tmpdir4(), `fn-agent-import-${importCompanySlug}-`));
           const archivePath = join45(tempDir, "archive.tar.gz");
           const downloadController = new AbortController();
           const downloadTimeout = setTimeout(() => downloadController.abort(), 3e4);
@@ -141554,6 +142153,21 @@ ${stderr}`;
     });
   });
 }
+function buildSkippedStatusPayload(expectedVersion) {
+  return {
+    binary: {
+      installed: false,
+      invocation: FN_INSTALL_NPM
+    },
+    expectedVersion,
+    state: "skipped",
+    install: {
+      npm: FN_INSTALL_NPM,
+      curl: FN_INSTALL_CURL,
+      package: FN_NPM_PACKAGE
+    }
+  };
+}
 var INSTALL_TIMEOUT_MS, MAX_OUTPUT_BYTES2, registerFnBinaryRoutes;
 var init_register_fn_binary_routes = __esm({
   "../dashboard/src/routes/register-fn-binary-routes.ts"() {
@@ -141564,11 +142178,23 @@ var init_register_fn_binary_routes = __esm({
     INSTALL_TIMEOUT_MS = 18e4;
     MAX_OUTPUT_BYTES2 = 64 * 1024;
     registerFnBinaryRoutes = (ctx) => {
-      const { router, rethrowAsApiError: rethrowAsApiError8 } = ctx;
+      const { router, rethrowAsApiError: rethrowAsApiError8, store } = ctx;
+      async function isCheckEnabled() {
+        try {
+          const settings = await store.getSettings();
+          return settings.fnBinaryCheckEnabled !== false;
+        } catch {
+          return true;
+        }
+      }
       router.get("/system/fn-binary/status", async (_req, res) => {
         try {
-          const binary = await detectFnBinary();
           const expectedVersion = getCliPackageVersion();
+          if (!await isCheckEnabled()) {
+            res.json(buildSkippedStatusPayload(expectedVersion));
+            return;
+          }
+          const binary = await detectFnBinary();
           res.json(buildStatusPayload(binary, expectedVersion));
         } catch (err) {
           if (err instanceof ApiError) throw err;
@@ -141577,6 +142203,13 @@ var init_register_fn_binary_routes = __esm({
       });
       router.post("/system/fn-binary/install", async (_req, res) => {
         try {
+          if (!await isCheckEnabled()) {
+            throw new ApiError(
+              409,
+              "fn-binary checks are disabled in global settings (fnBinaryCheckEnabled=false). Re-enable them to install via the dashboard.",
+              { code: "FN_BINARY_CHECK_DISABLED" }
+            );
+          }
           const installResult = await runNpmInstall();
           const binary = await detectFnBinary();
           const expectedVersion = getCliPackageVersion();
@@ -149386,6 +150019,10 @@ Description: ${step.description}`
     const slots = options?.pluginLoader?.getPluginUiSlots() ?? [];
     res.json(slots);
   });
+  router.get("/plugins/dashboard-views", async (_req, res) => {
+    const views = options?.pluginLoader?.getPluginDashboardViews() ?? [];
+    res.json(views);
+  });
   router.get("/plugins/runtimes", async (_req, res) => {
     const runtimes2 = options?.pluginLoader?.getPluginRuntimes() ?? [];
     const installed = runtimes2.map(({ pluginId, runtime }) => ({
@@ -155723,6 +156360,43 @@ data: ${JSON.stringify(entry)}
       scopedStore.off("agent:log", onAgentLog);
     });
   });
+  app.get("/api/agents/:id/runs/:runId/logs/stream", async (req, res) => {
+    const agentId = req.params.id;
+    const runId = req.params.runId;
+    const projectId = typeof req.query.projectId === "string" ? req.query.projectId : void 0;
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    res.write(": connected\n\n");
+    const engineManager = options?.engineManager;
+    const engine2 = engineManager && projectId ? engineManager.getEngine(projectId) : options?.engine;
+    const agentStore = engine2?.getAgentStore();
+    if (!agentStore) {
+      res.write(`event: error
+data: ${JSON.stringify({ message: "No active engine for project" })}
+
+`);
+      res.end();
+      return;
+    }
+    const onRunLog = (eventAgentId, eventRunId, entry) => {
+      if (eventAgentId !== agentId || eventRunId !== runId) return;
+      res.write(`event: agent:log
+data: ${JSON.stringify(entry)}
+
+`);
+    };
+    agentStore.on("run:log", onRunLog);
+    const heartbeat = setInterval(() => {
+      res.write(": heartbeat\n\n");
+    }, 3e4);
+    req.on("close", () => {
+      clearInterval(heartbeat);
+      agentStore.off("run:log", onRunLog);
+    });
+  });
   app.get("/api/terminal/sessions/:id/stream", rateLimit(RATE_LIMITS.sse), (req, res) => {
     const sessionId = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
     res.setHeader("Content-Type", "text/event-stream");
@@ -157556,7 +158230,8 @@ async function clearDefaultProject(globalDir) {
   await globalStore.updateSettings(rest);
 }
 async function detectProjectFromCwd(cwd, central) {
-  let currentDir = resolve27(cwd);
+  const startDir = resolve27(cwd);
+  let currentDir = startDir;
   while (true) {
     const kbPath = resolve27(currentDir, ".fusion", "fusion.db");
     if (isValidSqliteDatabaseFile(kbPath)) {
@@ -157564,11 +158239,13 @@ async function detectProjectFromCwd(cwd, central) {
       if (project) {
         return project;
       }
-      return {
-        id: "",
-        name: basename16(currentDir) || "current-project",
-        path: currentDir
-      };
+      if (currentDir === startDir) {
+        return {
+          id: "",
+          name: basename16(currentDir) || "current-project",
+          path: currentDir
+        };
+      }
     }
     const parentDir = dirname21(currentDir);
     if (parentDir === currentDir) {
@@ -158348,7 +159025,7 @@ var app_exports = {};
 __export(app_exports, {
   DashboardApp: () => DashboardApp
 });
-import { useState as useState2, useSyncExternalStore, useCallback as useCallback2, useEffect as useEffect2 } from "react";
+import { useState as useState2, useSyncExternalStore, useCallback as useCallback2, useEffect as useEffect2, useRef } from "react";
 import { Box, Text, useInput, useApp, useStdout } from "ink";
 import Spinner from "ink-spinner";
 import TextInput from "ink-text-input";
@@ -159130,7 +159807,8 @@ function formatLogTime(iso) {
 function TaskDetailScreen({
   task,
   projectPath,
-  interactiveData
+  interactiveData,
+  controller
 }) {
   const { stdout } = useStdout();
   const cols = stdout?.columns ?? 80;
@@ -159195,6 +159873,27 @@ function TaskDetailScreen({
   useEffect2(() => {
     if (autoFollow) setLogScrollOffset(0);
   }, [autoFollow, logCount]);
+  const WHEEL_STEP = 3;
+  const logCountRef = useRef(logCount);
+  const logPaneRowsRef = useRef(logPaneRows);
+  logCountRef.current = logCount;
+  logPaneRowsRef.current = logPaneRows;
+  useEffect2(() => {
+    return controller.onWheel((dir2) => {
+      const maxOffset = Math.max(0, logCountRef.current - logPaneRowsRef.current);
+      if (maxOffset === 0) return;
+      if (dir2 === "up") {
+        setAutoFollow(false);
+        setLogScrollOffset((o) => Math.min(maxOffset, o + WHEEL_STEP));
+      } else {
+        setLogScrollOffset((o) => {
+          const next = Math.max(0, o - WHEEL_STEP);
+          if (next === 0) setAutoFollow(true);
+          return next;
+        });
+      }
+    });
+  }, [controller]);
   useInput((input, key) => {
     if (detail && detail !== "unavailable" && detail.recentLogs.length > 0) {
       const maxOffset = Math.max(0, detail.recentLogs.length - logPaneRows);
@@ -159565,7 +160264,8 @@ function BoardView({ state, controller }) {
       {
         task: selectedTask,
         projectPath: selectedProject?.path ?? null,
-        interactiveData: state.interactiveData
+        interactiveData: state.interactiveData,
+        controller
       }
     ) }) : tasksState.loading ? /* @__PURE__ */ jsxs(Box, { justifyContent: "center", alignItems: "center", flexGrow: 1, gap: 1, children: [
       /* @__PURE__ */ jsx(Text, { color: "white", children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
@@ -160387,7 +161087,7 @@ function PushModal({
     }
   );
 }
-function GitView({ state }) {
+function GitView({ state, controller }) {
   const { stdout } = useStdout();
   const cols = stdout?.columns ?? 80;
   const data = state.interactiveData;
@@ -160575,6 +161275,23 @@ function GitView({ state }) {
       }
     }
   });
+  const gitWheelRef = useRef({ activePane, commits, branches, worktrees });
+  gitWheelRef.current = { activePane, commits, branches, worktrees };
+  useEffect2(() => {
+    if (state.interactiveView !== "git") return;
+    return controller.onWheel((dir2) => {
+      const { activePane: pane, commits: cs, branches: bs, worktrees: ws } = gitWheelRef.current;
+      const STEP = 3;
+      const delta = dir2 === "up" ? -STEP : STEP;
+      if (pane === "commits") {
+        setCommitIndex((i) => Math.max(0, Math.min(cs.length - 1, i + delta)));
+      } else if (pane === "branches") {
+        setBranchIndex((i) => Math.max(0, Math.min(bs.length - 1, i + delta)));
+      } else if (pane === "worktrees") {
+        setWorktreeIndex((i) => Math.max(0, Math.min(ws.length - 1, i + delta)));
+      }
+    });
+  }, [controller, state.interactiveView]);
   const isNarrow = cols < NARROW_THRESHOLD;
   const leftWidth = Math.max(24, Math.floor(cols * 0.35));
   const rightWidth = cols - leftWidth - 1;
@@ -160916,7 +161633,7 @@ function entriesToNodes(entries, depth) {
   const files = filtered.filter((e) => !e.isDirectory).sort((a, b) => a.name.localeCompare(b.name));
   return [...dirs, ...files].map((e) => ({ entry: e, depth, expanded: false, children: void 0 }));
 }
-function FilesView({ state }) {
+function FilesView({ state, controller }) {
   const { stdout } = useStdout();
   const cols = stdout?.columns ?? 80;
   const data = state.interactiveData;
@@ -161124,6 +161841,23 @@ function FilesView({ state }) {
       }
     }
   }, { isActive: state.interactiveView === "files" });
+  const filesWheelRef = useRef({ focusedPane, flatNodes, previewResult, previewHeight });
+  filesWheelRef.current = { focusedPane, flatNodes, previewResult, previewHeight };
+  useEffect2(() => {
+    if (state.interactiveView !== "files") return;
+    return controller.onWheel((dir2) => {
+      const { focusedPane: pane, flatNodes: nodes, previewResult: pr, previewHeight: ph } = filesWheelRef.current;
+      const STEP = 3;
+      const delta = dir2 === "up" ? -STEP : STEP;
+      if (pane === "tree") {
+        setSelectedIndex((i) => Math.max(0, Math.min(nodes.length - 1, i + delta)));
+      } else {
+        const lineCount = pr?.lineCount ?? 0;
+        const maxScroll = Math.max(0, lineCount - ph);
+        setPreviewScroll((s) => Math.max(0, Math.min(maxScroll, s + delta)));
+      }
+    });
+  }, [controller, state.interactiveView]);
   const isNarrow = cols < NARROW_THRESHOLD;
   const treeWidth = isNarrow ? Math.max(20, cols - 2) : Math.max(20, Math.floor(cols * 0.38));
   const previewEntry = selectedNode && !selectedNode.entry.isDirectory ? selectedNode.entry : null;
@@ -161287,8 +162021,8 @@ function InteractiveMode({ state, controller }) {
       state.interactiveView === "board" && /* @__PURE__ */ jsx(BoardView, { state, controller }),
       state.interactiveView === "agents" && /* @__PURE__ */ jsx(AgentsView, { state }),
       state.interactiveView === "settings" && /* @__PURE__ */ jsx(SettingsInteractiveView, { state, controller }),
-      state.interactiveView === "git" && /* @__PURE__ */ jsx(GitView, { state }),
-      state.interactiveView === "files" && /* @__PURE__ */ jsx(FilesView, { state })
+      state.interactiveView === "git" && /* @__PURE__ */ jsx(GitView, { state, controller }),
+      state.interactiveView === "files" && /* @__PURE__ */ jsx(FilesView, { state, controller })
     ] })
   ] });
 }
@@ -161319,6 +162053,23 @@ function DashboardApp({ controller }) {
     useCallback2((cb) => controller.subscribe(cb), [controller]),
     useCallback2(() => controller.getSnapshot(), [controller])
   );
+  const wheelStateRef = useRef(state);
+  wheelStateRef.current = state;
+  useEffect2(() => {
+    return controller.onWheel((dir2) => {
+      const s = wheelStateRef.current;
+      if (s.activeSection !== "logs") return;
+      const filtered = controller.getFilteredLogEntries();
+      if (filtered.length === 0) return;
+      const WHEEL_STEP = 3;
+      const cur = s.selectedLogIndex;
+      if (dir2 === "up") {
+        controller.setSelectedLogIndex(Math.max(0, cur - WHEEL_STEP));
+      } else {
+        controller.setSelectedLogIndex(Math.min(filtered.length - 1, cur + WHEEL_STEP));
+      }
+    });
+  }, [controller]);
   const [qrOverlay, setQrOverlay] = useState2(null);
   useInput((input, key) => {
     if ((input === "q" || input === "Q") && !key.ctrl || key.ctrl && input === "c") {
@@ -161701,6 +162452,15 @@ var init_controller = __esm({
       // no remote API is wired up).
       remoteStatus = null;
       remoteStatusTimer = null;
+      // Mouse-wheel handling. We enable xterm SGR mouse mode in start() so the
+      // terminal sends button reports for wheel up/down (buttons 64/65). A
+      // parallel `data` listener parses those reports and dispatches to wheel
+      // handlers. Ink's own keypress parser ignores SGR mouse sequences so
+      // long as the full sequence (including the leading ESC) arrives in one
+      // chunk — which it does once raw mode is enabled before mouse mode is
+      // requested. (See ink#222 / @zenobius/ink-mouse for prior art.)
+      wheelHandlers = /* @__PURE__ */ new Set();
+      mouseStdinListener = null;
       constructor() {
         this.logBuffer = new LogRingBuffer();
       }
@@ -161709,6 +162469,15 @@ var init_controller = __esm({
         this.subscribers.add(callback);
         return () => this.subscribers.delete(callback);
       }
+      /**
+       * Subscribe to mouse-wheel events. Direction is "up" (scroll back/older
+       * content) or "down" (scroll forward/newer content). Only fires while the
+       * dashboard is running and the terminal supports xterm mouse reporting.
+       */
+      onWheel(handler) {
+        this.wheelHandlers.add(handler);
+        return () => this.wheelHandlers.delete(handler);
+      }
       getSnapshot() {
         if (this.cachedSnapshot) return this.cachedSnapshot;
         this.cachedSnapshot = {
@@ -162093,6 +162862,10 @@ var init_controller = __esm({
         this.inkInstance = render(
           createElement(DashboardApp2, { controller: this })
         );
+        if (process.stdin?.isTTY) {
+          process.stdout.write("\x1B[?1000h\x1B[?1006h");
+          this.installMouseListener();
+        }
         this.resizeListener = () => {
           if (this.resizeDebounceTimer) clearTimeout(this.resizeDebounceTimer);
           this.resizeDebounceTimer = setTimeout(() => {
@@ -162199,10 +162972,48 @@ var init_controller = __esm({
           this.inkInstance = null;
         }
         if (process.stdout?.isTTY && typeof process.stdout.write === "function") {
+          this.uninstallMouseListener();
+          process.stdout.write("\x1B[?1006l\x1B[?1000l");
           process.stdout.write("\x1B[?1049l");
         }
       }
       // ── Private helpers ────────────────────────────────────────────────────────
+      // Attach a parallel `data` listener that decodes xterm SGR mouse
+      // sequences and dispatches wheel events. Ink's own listener is also
+      // attached; SGR sequences arrive as a single chunk that Ink's keypress
+      // parser silently ignores, so we don't need to (and shouldn't) strip
+      // them from the stream.
+      installMouseListener() {
+        if (this.mouseStdinListener) return;
+        const mouseRe = /\x1b\[<(\d+);\d+;\d+[Mm]/g;
+        const listener = (chunk) => {
+          const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+          if (text.indexOf("\x1B[<") === -1) return;
+          mouseRe.lastIndex = 0;
+          let m;
+          while ((m = mouseRe.exec(text)) !== null) {
+            const btn = Number.parseInt(m[1] ?? "", 10);
+            if (btn === 64) this.dispatchWheel("up");
+            else if (btn === 65) this.dispatchWheel("down");
+          }
+        };
+        this.mouseStdinListener = listener;
+        process.stdin.on("data", listener);
+      }
+      uninstallMouseListener() {
+        if (!this.mouseStdinListener) return;
+        process.stdin.off("data", this.mouseStdinListener);
+        this.mouseStdinListener = null;
+      }
+      dispatchWheel(direction) {
+        for (const handler of this.wheelHandlers) {
+          try {
+            handler(direction);
+          } catch (err) {
+            tuiDebug2("wheel-handler-error", { err: String(err) });
+          }
+        }
+      }
       clampSelectedLogIndex(entries) {
         if (entries.length === 0) {
           this.selectedLogIndex = 0;
@@ -170806,7 +171617,7 @@ __export(native_patch_exports, {
 });
 import { join as join68, basename as basename21, dirname as dirname28 } from "node:path";
 import { existsSync as existsSync51, copyFileSync, mkdirSync as mkdirSync12, symlinkSync as symlinkSync2, rmSync as rmSync5, lstatSync as lstatSync3, readlinkSync as readlinkSync2 } from "node:fs";
-import { tmpdir as tmpdir4 } from "node:os";
+import { tmpdir as tmpdir5 } from "node:os";
 function findStagedNativeDir2() {
   const platform4 = process.platform === "darwin" ? "darwin" : process.platform === "linux" ? "linux" : process.platform === "win32" ? "win32" : "unknown";
   const arch = process.arch === "arm64" ? "arm64" : process.arch === "x64" ? "x64" : "unknown";
@@ -170851,7 +171662,7 @@ function setupNativeResolution() {
     process.env.NODE_PTY_SPAWN_HELPER_DIR = nativeDir;
   }
   process.env.FUSION_NATIVE_ASSETS_PATH = nativeDir;
-  const tmpRoot = join68(tmpdir4(), `fn-bunfs-${process.pid}`);
+  const tmpRoot = join68(tmpdir5(), `fn-bunfs-${process.pid}`);
   const fnDir = join68(tmpRoot, "fn");
   const prebuildsDir = join68(fnDir, "prebuilds");
   const platformDir = join68(prebuildsDir, basename21(nativeDir));
@@ -170939,7 +171750,7 @@ var init_native_patch = __esm({
 import { existsSync as existsSync52, mkdtempSync as mkdtempSync2, readFileSync as readFileSync24, symlinkSync as symlinkSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
 import { join as join69, dirname as dirname29, resolve as resolve41 } from "node:path";
-import { tmpdir as tmpdir5 } from "node:os";
+import { tmpdir as tmpdir6 } from "node:os";
 import { performance as performance3 } from "node:perf_hooks";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 var isBunBinary3 = typeof Bun !== "undefined" && !!Bun.embeddedFiles;
@@ -170947,7 +171758,7 @@ function configurePiPackage() {
   if (process.env.PI_PACKAGE_DIR) {
     return;
   }
-  const tmp = mkdtempSync2(join69(tmpdir5(), "fn-pkg-"));
+  const tmp = mkdtempSync2(join69(tmpdir6(), "fn-pkg-"));
   let packageJson = {
     name: "pi",
     version: "0.1.0",