@runfusion/fusion 0.14.2 → 0.15.0

package/dist/extension.js

@@ -75,6 +75,7 @@ var init_settings_schema = __esm({
       favoriteModels: void 0,
       openrouterModelSync: true,
       updateCheckEnabled: true,
+      fnBinaryCheckEnabled: true,
       updateCheckFrequency: "daily",
       showGitHubStarButton: true,
       modelOnboardingComplete: void 0,
@@ -239,7 +240,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",
@@ -2650,6 +2652,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 "[]";
@@ -3281,15 +3284,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 });
         }
@@ -3301,8 +3313,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);
       }
@@ -3383,6 +3400,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.
@@ -3401,6 +3447,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.
@@ -6016,6 +6067,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.
@@ -19069,7 +19121,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() {
@@ -19170,12 +19222,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 = (path2) => {
+          try {
+            return realpathSync2(path2);
+          } catch {
+            return resolve5(path2);
+          }
+        };
+        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({
@@ -19185,6 +19255,9 @@ var init_migration = __esm({
             });
             break;
           }
+          if (isStopBoundary) {
+            break;
+          }
           const parent = dirname4(current);
           if (parent === current) break;
           current = parent;
@@ -34493,6 +34566,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,
@@ -36342,12 +36448,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((resolve19) => {
     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");
@@ -37478,6 +37588,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.
@@ -37665,7 +37789,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",
@@ -37698,7 +37822,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",
@@ -49573,7 +49697,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, "");
@@ -49896,7 +50020,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);
@@ -51216,18 +51340,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;
@@ -51332,8 +51459,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 ───────────────────────────────────────────────
       /**
@@ -51342,7 +51474,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,
@@ -51351,72 +51483,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;
@@ -51432,6 +51530,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)}`);
+              })
+            )
+          );
+        }
+      }
     };
   }
 });
@@ -65008,6 +65152,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);
@@ -65040,8 +65198,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 {
@@ -65160,6 +65352,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);
+            }
           }
         });
       }
@@ -65177,6 +65385,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`,
@@ -65223,6 +65433,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). */
@@ -65417,11 +65690,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);
@@ -65467,6 +65744,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";
@@ -65477,6 +65759,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) {
@@ -65488,11 +65774,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";
           }
@@ -65508,8 +65804,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);
@@ -65518,6 +65816,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);
@@ -65540,7 +65843,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`
               );
@@ -65548,6 +65851,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);
@@ -65670,11 +65975,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) {
@@ -65682,7 +65993,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;
@@ -65691,6 +66011,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);
@@ -65756,6 +66079,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
@@ -66194,8 +66524,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);
@@ -66213,6 +66556,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" } });
@@ -66565,6 +66911,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);
@@ -66601,8 +66950,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);
@@ -66620,6 +66984,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);
@@ -66744,8 +67111,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);
@@ -66759,6 +67141,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);
@@ -66851,6 +67236,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);
@@ -67209,22 +67597,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: {}
@@ -67799,6 +68193,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();
@@ -67813,6 +68210,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`);
@@ -67878,6 +68278,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(
@@ -68043,6 +68446,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") {
@@ -68115,6 +68519,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;
           }
         };
@@ -69858,6 +70266,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) {
@@ -74995,6 +75412,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) => {
@@ -75034,7 +75481,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";
@@ -75043,6 +75490,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;
@@ -75183,6 +75638,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, {
@@ -75213,6 +75671,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.
@@ -75301,6 +75800,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,
@@ -75492,6 +76004,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");
@@ -75649,6 +76162,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,
@@ -76440,6 +76977,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) },
@@ -76790,27 +77334,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 = [
@@ -78543,6 +79094,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.
        *
@@ -78576,7 +79131,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,
@@ -78968,11 +79523,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;
@@ -79138,6 +79698,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
@@ -82977,13 +83576,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) {
@@ -83007,13 +83606,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) {
@@ -85733,7 +86332,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) {
@@ -85746,7 +86345,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) {
@@ -98615,7 +99214,8 @@ async function clearDefaultProject(globalDir) {
   await globalStore.updateSettings(rest);
 }
 async function detectProjectFromCwd(cwd, central) {
-  let currentDir = resolve17(cwd);
+  const startDir = resolve17(cwd);
+  let currentDir = startDir;
   while (true) {
     const kbPath = resolve17(currentDir, ".fusion", "fusion.db");
     if (isValidSqliteDatabaseFile(kbPath)) {
@@ -98623,11 +99223,13 @@ async function detectProjectFromCwd(cwd, central) {
       if (project) {
         return project;
       }
-      return {
-        id: "",
-        name: basename9(currentDir) || "current-project",
-        path: currentDir
-      };
+      if (currentDir === startDir) {
+        return {
+          id: "",
+          name: basename9(currentDir) || "current-project",
+          path: currentDir
+        };
+      }
     }
     const parentDir = dirname12(currentDir);
     if (parentDir === currentDir) {