@runfusion/fusion 0.14.2 → 0.14.3

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,
@@ -3290,6 +3291,12 @@ CREATE INDEX IF NOT EXISTS idxTodoItemsSortOrder ON todo_items(listId, sortOrder
         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 });
         }
@@ -6016,6 +6023,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.
@@ -36342,12 +36350,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");
@@ -37665,7 +37677,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 +37710,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 +49585,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 +49908,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);
@@ -65008,6 +65020,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 +65066,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 +65220,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 +65253,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 +65301,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 +65558,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 +65612,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 +65627,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 +65642,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 +65672,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 +65684,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 +65711,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 +65719,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 +65843,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 +65861,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 +65879,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 +65947,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 +66392,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 +66424,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 +66779,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 +66818,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 +66852,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 +66979,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 +67009,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 +67104,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 +67465,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 +68061,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 +68078,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 +68146,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 +68314,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 +68387,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 +70134,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 +75280,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 +75349,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 +75358,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 +75506,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 +75539,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 +75668,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 +75872,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 +76030,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 +76845,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 +77202,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 +78962,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 +78999,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 +79391,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 +79566,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 +83444,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 +83474,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) {