@runfusion/fusion 0.14.1 → 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");
@@ -37491,6 +37503,60 @@ var init_plugin_loader = __esm({
         }
         return runtimes;
       }
+      /**
+       * Get all skill contributions from loaded plugins.
+       */
+      getPluginSkills() {
+        const skills = [];
+        for (const [pluginId, plugin4] of this.plugins) {
+          if (plugin4.skills) {
+            for (const skill of plugin4.skills) {
+              skills.push({ pluginId, skill });
+            }
+          }
+        }
+        return skills;
+      }
+      /**
+       * Get all workflow step contributions from loaded plugins.
+       */
+      getPluginWorkflowSteps() {
+        const steps = [];
+        for (const [pluginId, plugin4] of this.plugins) {
+          if (plugin4.workflowSteps) {
+            for (const step of plugin4.workflowSteps) {
+              steps.push({ pluginId, step });
+            }
+          }
+        }
+        return steps;
+      }
+      /**
+       * Get all prompt contributions from loaded plugins.
+       */
+      getPluginPromptContributions() {
+        const contributions = [];
+        for (const [pluginId, plugin4] of this.plugins) {
+          if (plugin4.promptContributions) {
+            for (const contribution of plugin4.promptContributions.contributions) {
+              contributions.push({ pluginId, contribution, config: plugin4.promptContributions });
+            }
+          }
+        }
+        return contributions;
+      }
+      /**
+       * Get all setup metadata and hooks from loaded plugins.
+       */
+      getPluginSetupInfo() {
+        const setups = [];
+        for (const [pluginId, plugin4] of this.plugins) {
+          if (plugin4.setup) {
+            setups.push({ pluginId, manifest: plugin4.setup.manifest, hooks: plugin4.setup.hooks });
+          }
+        }
+        return setups;
+      }
       /**
        * Get all loaded plugin instances.
        */
@@ -37611,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",
@@ -37644,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",
@@ -49519,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, "");
@@ -49842,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);
@@ -55419,65 +55485,6 @@ ${lines.join("\n")}`
     }
   };
 }
-function createIdentityTool({ agent, resolvedInstructions }) {
-  const identityParams = Type.Object({});
-  return {
-    name: "fn_identity",
-    label: "Identity Check",
-    description: "Return a structured summary of which soul, instructions, and memory are loaded for this heartbeat tick. Call this FIRST before any other tool.",
-    parameters: identityParams,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    execute: async (_id, _params, _signal, _onUpdate, _ctx) => {
-      const PREVIEW_CHARS = 500;
-      const INSTRUCTIONS_PREVIEW_CHARS = 1e3;
-      const MEMORY_PREVIEW_CHARS = 1e3;
-      const soulPresent = typeof agent.soul === "string" && agent.soul.trim().length > 0;
-      const instructionsPresent = resolvedInstructions.trim().length > 0;
-      const memoryPresent = typeof agent.memory === "string" && agent.memory.trim().length > 0;
-      const soulPreview = soulPresent ? agent.soul.slice(0, PREVIEW_CHARS) : "";
-      const instructionsPreview = instructionsPresent ? resolvedInstructions.slice(0, INSTRUCTIONS_PREVIEW_CHARS) : "";
-      const memoryPreview = memoryPresent ? agent.memory.slice(0, MEMORY_PREVIEW_CHARS) : "";
-      const result = {
-        agentId: agent.id,
-        name: agent.name,
-        role: agent.role,
-        soulPresent,
-        instructionsPresent,
-        memoryPresent,
-        soulPreview,
-        instructionsPreview,
-        memoryPreview
-      };
-      const lines = [
-        `agentId: ${result.agentId}`,
-        `name: ${result.name}`,
-        `role: ${result.role}`,
-        `soul: ${result.soulPresent ? "loaded" : "absent"}`,
-        `instructions: ${result.instructionsPresent ? "loaded" : "absent"}`,
-        `memory: ${result.memoryPresent ? "loaded" : "absent"}`
-      ];
-      if (result.soulPresent && result.soulPreview) {
-        lines.push(`
-Soul preview (first ${PREVIEW_CHARS} chars):
-${result.soulPreview}`);
-      }
-      if (result.instructionsPresent && result.instructionsPreview) {
-        lines.push(`
-Instructions preview (first ${INSTRUCTIONS_PREVIEW_CHARS} chars):
-${result.instructionsPreview}`);
-      }
-      if (result.memoryPresent && result.memoryPreview) {
-        lines.push(`
-Memory preview (first ${MEMORY_PREVIEW_CHARS} chars):
-${result.memoryPreview}`);
-      }
-      return {
-        content: [{ type: "text", text: lines.join("\n") }],
-        details: result
-      };
-    }
-  };
-}
 var taskCreateParams, taskLogParams, taskDocumentWriteParams, taskDocumentReadParams, reflectOnPerformanceParams, listAgentsParams, delegateTaskParams, sendMessageParams, readMessagesParams, memorySearchParams, memoryGetParams, researchRunParams, researchListParams, researchGetParams, researchCancelParams, memoryAppendParams, log10, AGENT_MEMORY_ROOT2, AGENT_MEMORY_FILENAME2, AGENT_DREAMS_FILENAME2, agentQmdRefreshState, AGENT_QMD_REFRESH_INTERVAL_MS, DAILY_AGENT_MEMORY_RE2;
 var init_agent_tools = __esm({
   "../engine/src/agent-tools.ts"() {
@@ -65013,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);
@@ -65045,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 {
@@ -65165,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);
+            }
           }
         });
       }
@@ -65182,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`,
@@ -65228,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). */
@@ -65422,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);
@@ -65472,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";
@@ -65482,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) {
@@ -65493,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";
           }
@@ -65513,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);
@@ -65523,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);
@@ -65545,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`
               );
@@ -65553,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);
@@ -65675,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) {
@@ -65687,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;
@@ -65696,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);
@@ -65761,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
@@ -66199,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);
@@ -66218,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" } });
@@ -66570,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);
@@ -66606,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);
@@ -66625,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);
@@ -66749,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);
@@ -66764,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);
@@ -66856,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);
@@ -67214,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: {}
@@ -67804,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();
@@ -67818,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`);
@@ -67883,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(
@@ -68048,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") {
@@ -68120,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;
           }
         };
@@ -69863,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) {
@@ -71983,6 +72263,7 @@ Rules:
 
 // ../engine/src/agent-heartbeat.ts
 import { Type as Type6 } from "@mariozechner/pi-ai";
+import { createHash as createHash5 } from "node:crypto";
 function isBlockedStateDuplicate(current, previous) {
   return current.blockedBy === previous.blockedBy && current.contextHash === previous.contextHash;
 }
@@ -71992,39 +72273,30 @@ function truncatePrompt(text, maxChars) {
 
 ... (truncated, ${text.length} chars)`;
 }
+function shortContentHash(value) {
+  return createHash5("sha256").update(value).digest("hex").slice(0, 8);
+}
 function buildIdentitySnapshot(args) {
   const { agent, resolvedInstructions } = args;
-  const SOUL_PREVIEW = 500;
-  const INSTR_PREVIEW = 1e3;
-  const MEM_PREVIEW = 1e3;
-  const soulPresent = typeof agent.soul === "string" && agent.soul.trim().length > 0;
-  const instrPresent = resolvedInstructions.trim().length > 0;
-  const memPresent = typeof agent.memory === "string" && agent.memory.trim().length > 0;
-  const lines = [
+  const soulTrimmed = typeof agent.soul === "string" ? agent.soul.trim() : "";
+  const instrTrimmed = resolvedInstructions.trim();
+  const memTrimmed = typeof agent.memory === "string" ? agent.memory.trim() : "";
+  const formatField = (trimmed) => {
+    if (!trimmed) return "absent";
+    return `loaded (${trimmed.length} chars, sha256:${shortContentHash(trimmed)})`;
+  };
+  return [
     "## Identity Snapshot",
     "",
-    "Verify these match what you expect. Surface any anomalies in your first text output before acting.",
+    "Full content is in the Custom Instructions section of your system prompt. Surface anomalies in your first text output before acting.",
     "",
     `- agentId: ${agent.id}`,
     `- name: ${agent.name}`,
     `- role: ${agent.role}`,
-    `- soul: ${soulPresent ? "loaded" : "absent"}`,
-    `- instructions: ${instrPresent ? "loaded" : "absent"}`,
-    `- memory: ${memPresent ? "loaded" : "absent"}`
-  ];
-  if (soulPresent) {
-    const preview = agent.soul.trim().slice(0, SOUL_PREVIEW);
-    lines.push("", `### Soul (first ${SOUL_PREVIEW} chars)`, preview);
-  }
-  if (instrPresent) {
-    const preview = resolvedInstructions.trim().slice(0, INSTR_PREVIEW);
-    lines.push("", `### Instructions (first ${INSTR_PREVIEW} chars)`, preview);
-  }
-  if (memPresent) {
-    const preview = agent.memory.trim().slice(0, MEM_PREVIEW);
-    lines.push("", `### Memory (first ${MEM_PREVIEW} chars)`, preview);
-  }
-  return lines.join("\n");
+    `- soul: ${formatField(soulTrimmed)}`,
+    `- instructions: ${formatField(instrTrimmed)}`,
+    `- memory: ${formatField(memTrimmed)}`
+  ].join("\n");
 }
 async function getHeartbeatMemorySettings(taskStore) {
   const maybeGetSettings = taskStore.getSettings;
@@ -72206,9 +72478,8 @@ When sending messages:
 1. **Identity & context** \u2014 review the **Identity Snapshot** at the top of
    this prompt. Confirm your role, soul, instructions, and memory match what
    you expect, and surface any anomalies in your first text output before
-   doing anything else. (If fn_identity is available in your runtime you may
-   also call it for full structured detail; the snapshot above is the
-   authoritative source.)
+   doing anything else. The full content is in the Custom Instructions
+   section of your system prompt.
 2. **Inbox** \u2014 when fn_read_messages is available, call it. Process any pending
    messages first; reply with reply_to_message_id when answering.
 3. **Wake delta** \u2014 read the Wake Delta block above. The wake reason is the
@@ -72234,9 +72505,8 @@ a bug. Do not loop on the same plan across heartbeats without recording why.`;
 1. **Identity & context** \u2014 review the **Identity Snapshot** at the top of
    this prompt. Confirm your role, soul, instructions, and memory match what
    you expect, and surface any anomalies in your first text output before
-   doing anything else. (If fn_identity is available in your runtime you may
-   also call it for full structured detail; the snapshot above is the
-   authoritative source.)
+   doing anything else. The full content is in the Custom Instructions
+   section of your system prompt.
 2. **Inbox** \u2014 when fn_read_messages is available, call it. Process any pending
    messages first; reply with reply_to_message_id when answering.
 3. **Wake delta** \u2014 read the Wake Delta block above. The wake reason is the
@@ -73038,7 +73308,6 @@ not loop on the same plan across heartbeats without recording why.`;
               baseHeartbeatSystemPrompt,
               [resolvedInstructionsForIdentity, memoryInstructions].filter((part) => part.trim()).join("\n\n")
             );
-            heartbeatTools.push(createIdentityTool({ agent, resolvedInstructions: resolvedInstructionsForIdentity }));
             heartbeatTools.push(heartbeatDoneTool);
             if (isNoTaskRun) {
               agentLogger = new AgentLogger({
@@ -75011,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) => {
@@ -75050,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";
@@ -75059,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;
@@ -75199,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, {
@@ -75229,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.
@@ -75317,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,
@@ -75508,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");
@@ -75665,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,
@@ -76456,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) },
@@ -76806,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 = [
@@ -77892,10 +78295,18 @@ var init_plugin_runner = __esm({
       cachedRoutes = null;
       cachedUiSlots = null;
       cachedRuntimes = null;
+      cachedSkills = null;
+      cachedWorkflowSteps = null;
+      cachedPromptContributions = null;
+      cachedSetupInfo = null;
       toolsCacheVersion = 0;
       routesCacheVersion = 0;
       uiSlotsCacheVersion = 0;
       runtimesCacheVersion = 0;
+      skillsCacheVersion = 0;
+      workflowStepsCacheVersion = 0;
+      promptContributionsCacheVersion = 0;
+      setupCacheVersion = 0;
       hookTimeoutMs;
       // Event handler references for cleanup
       handlePluginEnabled;
@@ -77927,6 +78338,10 @@ var init_plugin_runner = __esm({
         this.invalidateRoutesCache();
         this.invalidateUiSlotsCache();
         this.invalidateRuntimesCache();
+        this.invalidateSkillsCache();
+        this.invalidateWorkflowStepsCache();
+        this.invalidatePromptContributionsCache();
+        this.invalidateSetupCache();
       }
       /**
        * Shutdown the plugin runner.
@@ -78007,6 +78422,54 @@ var init_plugin_runner = __esm({
         }
         return this.cachedRuntimes.runtimes;
       }
+      getPluginSkills() {
+        if (!this.cachedSkills || this.cachedSkills.version !== this.skillsCacheVersion) {
+          this.cachedSkills = {
+            skills: this.options.pluginLoader.getPluginSkills(),
+            version: this.skillsCacheVersion
+          };
+        }
+        return this.cachedSkills.skills;
+      }
+      getPluginWorkflowSteps() {
+        if (!this.cachedWorkflowSteps || this.cachedWorkflowSteps.version !== this.workflowStepsCacheVersion) {
+          this.cachedWorkflowSteps = {
+            steps: this.options.pluginLoader.getPluginWorkflowSteps(),
+            version: this.workflowStepsCacheVersion
+          };
+        }
+        return this.cachedWorkflowSteps.steps;
+      }
+      getPluginPromptContributions() {
+        if (!this.cachedPromptContributions || this.cachedPromptContributions.version !== this.promptContributionsCacheVersion) {
+          this.cachedPromptContributions = {
+            contributions: this.options.pluginLoader.getPluginPromptContributions(),
+            version: this.promptContributionsCacheVersion
+          };
+        }
+        return this.cachedPromptContributions.contributions;
+      }
+      getPluginSetupInfo() {
+        if (!this.cachedSetupInfo || this.cachedSetupInfo.version !== this.setupCacheVersion) {
+          this.cachedSetupInfo = {
+            setups: this.options.pluginLoader.getPluginSetupInfo(),
+            version: this.setupCacheVersion
+          };
+        }
+        return this.cachedSetupInfo.setups;
+      }
+      getPromptContributionsForSurface(surface) {
+        return this.getPluginPromptContributions().filter(({ pluginId, contribution, config }) => {
+          const plugin4 = this.options.pluginLoader.getPlugin(pluginId);
+          if (!plugin4 || plugin4.state !== "started") {
+            return false;
+          }
+          if (contribution.surface !== surface) {
+            return false;
+          }
+          return config.enabledByDefault !== false;
+        });
+      }
       /**
        * Get a specific runtime registration by its runtimeId.
        *
@@ -78040,6 +78503,10 @@ var init_plugin_runner = __esm({
         this.invalidateRoutesCache();
         this.invalidateUiSlotsCache();
         this.invalidateRuntimesCache();
+        this.invalidateSkillsCache();
+        this.invalidateWorkflowStepsCache();
+        this.invalidatePromptContributionsCache();
+        this.invalidateSetupCache();
         executorLog.log(`Plugin ${pluginId} reloaded`);
       }
       // ── Event Handlers for Hot-Load/Unload ─────────────────────────
@@ -78051,6 +78518,10 @@ var init_plugin_runner = __esm({
         this.invalidateRoutesCache();
         this.invalidateUiSlotsCache();
         this.invalidateRuntimesCache();
+        this.invalidateSkillsCache();
+        this.invalidateWorkflowStepsCache();
+        this.invalidatePromptContributionsCache();
+        this.invalidateSetupCache();
         try {
           executorLog.log(`Auto-loading enabled plugin: ${plugin4.id}`);
           await this.options.pluginLoader.loadPlugin(plugin4.id);
@@ -78066,6 +78537,10 @@ var init_plugin_runner = __esm({
         this.invalidateRoutesCache();
         this.invalidateUiSlotsCache();
         this.invalidateRuntimesCache();
+        this.invalidateSkillsCache();
+        this.invalidateWorkflowStepsCache();
+        this.invalidatePromptContributionsCache();
+        this.invalidateSetupCache();
         try {
           executorLog.log(`Auto-stopping disabled plugin: ${plugin4.id}`);
           await this.options.pluginLoader.stopPlugin(plugin4.id);
@@ -78081,6 +78556,10 @@ var init_plugin_runner = __esm({
         this.invalidateRoutesCache();
         this.invalidateUiSlotsCache();
         this.invalidateRuntimesCache();
+        this.invalidateSkillsCache();
+        this.invalidateWorkflowStepsCache();
+        this.invalidatePromptContributionsCache();
+        this.invalidateSetupCache();
         try {
           executorLog.log(`Stopping unregistered plugin: ${plugin4.id}`);
           await this.options.pluginLoader.stopPlugin(plugin4.id);
@@ -78097,6 +78576,10 @@ var init_plugin_runner = __esm({
         this.invalidateRoutesCache();
         this.invalidateUiSlotsCache();
         this.invalidateRuntimesCache();
+        this.invalidateSkillsCache();
+        this.invalidateWorkflowStepsCache();
+        this.invalidatePromptContributionsCache();
+        this.invalidateSetupCache();
       }
       /**
        * Handle plugin updates - invalidate caches.
@@ -78106,6 +78589,10 @@ var init_plugin_runner = __esm({
         this.invalidateRoutesCache();
         this.invalidateUiSlotsCache();
         this.invalidateRuntimesCache();
+        this.invalidateSkillsCache();
+        this.invalidateWorkflowStepsCache();
+        this.invalidatePromptContributionsCache();
+        this.invalidateSetupCache();
       }
       /**
        * Handle plugin:loaded event from loader - invalidate caches.
@@ -78115,6 +78602,10 @@ var init_plugin_runner = __esm({
         this.invalidateRoutesCache();
         this.invalidateUiSlotsCache();
         this.invalidateRuntimesCache();
+        this.invalidateSkillsCache();
+        this.invalidateWorkflowStepsCache();
+        this.invalidatePromptContributionsCache();
+        this.invalidateSetupCache();
       }
       /**
        * Handle plugin:unloaded event from loader - invalidate caches.
@@ -78124,6 +78615,10 @@ var init_plugin_runner = __esm({
         this.invalidateRoutesCache();
         this.invalidateUiSlotsCache();
         this.invalidateRuntimesCache();
+        this.invalidateSkillsCache();
+        this.invalidateWorkflowStepsCache();
+        this.invalidatePromptContributionsCache();
+        this.invalidateSetupCache();
       }
       /**
        * Handle plugin:reloaded event from loader - invalidate caches.
@@ -78133,6 +78628,10 @@ var init_plugin_runner = __esm({
         this.invalidateRoutesCache();
         this.invalidateUiSlotsCache();
         this.invalidateRuntimesCache();
+        this.invalidateSkillsCache();
+        this.invalidateWorkflowStepsCache();
+        this.invalidatePromptContributionsCache();
+        this.invalidateSetupCache();
       }
       // ── Tool Conversion ───────────────────────────────────────────────
       /**
@@ -78304,6 +78803,22 @@ var init_plugin_runner = __esm({
         this.runtimesCacheVersion++;
         this.log.log(`Runtimes cache invalidated (version: ${this.runtimesCacheVersion})`);
       }
+      invalidateSkillsCache() {
+        this.skillsCacheVersion++;
+        this.log.log(`Skills cache invalidated (version: ${this.skillsCacheVersion})`);
+      }
+      invalidateWorkflowStepsCache() {
+        this.workflowStepsCacheVersion++;
+        this.log.log(`Workflow steps cache invalidated (version: ${this.workflowStepsCacheVersion})`);
+      }
+      invalidatePromptContributionsCache() {
+        this.promptContributionsCacheVersion++;
+        this.log.log(`Prompt contributions cache invalidated (version: ${this.promptContributionsCacheVersion})`);
+      }
+      invalidateSetupCache() {
+        this.setupCacheVersion++;
+        this.log.log(`Setup cache invalidated (version: ${this.setupCacheVersion})`);
+      }
       // ── Store Event Subscriptions ────────────────────────────────────
       /**
        * Subscribe to TaskStore events for task lifecycle hooks.
@@ -78447,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.
        *
@@ -78480,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,
@@ -78872,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;
@@ -79042,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
@@ -82881,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) {
@@ -82911,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) {
@@ -96746,7 +97309,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash5 } = __require("crypto");
+    var { randomBytes: randomBytes3, createHash: createHash6 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -97406,7 +97969,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash5("sha1").update(key + GUID).digest("base64");
+        const digest = createHash6("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -97773,7 +98336,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter31 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash5 } = __require("crypto");
+    var { createHash: createHash6 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -98074,7 +98637,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash5("sha1").update(key + GUID).digest("base64");
+        const digest = createHash6("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",