@runfusion/fusion 0.14.1 → 0.14.3

package/dist/bin.js

@@ -77,6 +77,7 @@ var init_settings_schema = __esm({
       favoriteModels: void 0,
       openrouterModelSync: true,
       updateCheckEnabled: true,
+      fnBinaryCheckEnabled: true,
       updateCheckFrequency: "daily",
       showGitHubStarButton: true,
       modelOnboardingComplete: void 0,
@@ -3292,6 +3293,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 });
         }
@@ -6018,6 +6025,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.
@@ -36344,12 +36352,16 @@ var init_gh_cli = __esm({
 
 // ../core/src/fn-binary.ts
 import { spawn as spawn2 } from "node:child_process";
-import { platform as platform2 } from "node:os";
+import { platform as platform2, tmpdir as tmpdir2 } from "node:os";
 function runProbe(command, args, timeoutMs) {
   return new Promise((resolve42) => {
     let stdout = "";
     let stderr = "";
-    const child = spawn2(command, args, { stdio: ["ignore", "pipe", "pipe"], shell: false });
+    const child = spawn2(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false,
+      cwd: tmpdir2()
+    });
     const timer = setTimeout(() => {
       try {
         child.kill("SIGKILL");
@@ -37493,6 +37505,60 @@ var init_plugin_loader = __esm({
         }
         return runtimes2;
       }
+      /**
+       * 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.
        */
@@ -37613,7 +37679,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",
@@ -37646,7 +37712,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",
@@ -49521,7 +49587,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, "");
@@ -49844,7 +49910,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);
@@ -56178,65 +56244,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"() {
@@ -65772,6 +65779,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);
@@ -65804,8 +65825,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 {
@@ -65924,6 +65979,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);
+            }
           }
         });
       }
@@ -65941,6 +66012,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`,
@@ -65987,6 +66060,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). */
@@ -66181,11 +66317,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);
@@ -66231,6 +66371,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";
@@ -66241,6 +66386,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) {
@@ -66252,11 +66401,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";
           }
@@ -66272,8 +66431,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);
@@ -66282,6 +66443,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);
@@ -66304,7 +66470,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`
               );
@@ -66312,6 +66478,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);
@@ -66434,11 +66602,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) {
@@ -66446,7 +66620,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;
@@ -66455,6 +66638,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);
@@ -66520,6 +66706,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
@@ -66958,8 +67151,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);
@@ -66977,6 +67183,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" } });
@@ -67329,6 +67538,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);
@@ -67365,8 +67577,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);
@@ -67384,6 +67611,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);
@@ -67508,8 +67738,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);
@@ -67523,6 +67768,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);
@@ -67615,6 +67863,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);
@@ -67973,22 +68224,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: {}
@@ -68563,6 +68820,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();
@@ -68577,6 +68837,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`);
@@ -68642,6 +68905,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(
@@ -68807,6 +69073,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") {
@@ -68879,6 +69146,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;
           }
         };
@@ -70622,6 +70893,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) {
@@ -72742,6 +73022,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;
 }
@@ -72751,39 +73032,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;
@@ -72965,9 +73237,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
@@ -72993,9 +73264,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
@@ -73797,7 +74067,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({
@@ -75770,6 +76039,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) => {
@@ -75809,7 +76108,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";
@@ -75818,6 +76117,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;
@@ -75958,6 +76265,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, {
@@ -75988,6 +76298,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.
@@ -76076,6 +76427,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,
@@ -76267,6 +76631,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");
@@ -76424,6 +76789,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,
@@ -77215,6 +77604,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) },
@@ -77565,27 +77961,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 = [
@@ -78651,10 +79054,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;
@@ -78686,6 +79097,10 @@ var init_plugin_runner = __esm({
         this.invalidateRoutesCache();
         this.invalidateUiSlotsCache();
         this.invalidateRuntimesCache();
+        this.invalidateSkillsCache();
+        this.invalidateWorkflowStepsCache();
+        this.invalidatePromptContributionsCache();
+        this.invalidateSetupCache();
       }
       /**
        * Shutdown the plugin runner.
@@ -78766,6 +79181,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.
        *
@@ -78799,6 +79262,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 ─────────────────────────
@@ -78810,6 +79277,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);
@@ -78825,6 +79296,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);
@@ -78840,6 +79315,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);
@@ -78856,6 +79335,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.
@@ -78865,6 +79348,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.
@@ -78874,6 +79361,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.
@@ -78883,6 +79374,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.
@@ -78892,6 +79387,10 @@ var init_plugin_runner = __esm({
         this.invalidateRoutesCache();
         this.invalidateUiSlotsCache();
         this.invalidateRuntimesCache();
+        this.invalidateSkillsCache();
+        this.invalidateWorkflowStepsCache();
+        this.invalidatePromptContributionsCache();
+        this.invalidateSetupCache();
       }
       // ── Tool Conversion ───────────────────────────────────────────────
       /**
@@ -79063,6 +79562,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.
@@ -79206,6 +79721,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.
        *
@@ -79239,7 +79758,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,
@@ -79631,11 +80150,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;
@@ -79801,6 +80325,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
@@ -83640,13 +84203,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) {
@@ -83670,13 +84233,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) {
@@ -133416,8 +133979,8 @@ var init_register_settings_sync_routes = __esm({
             exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
             version: 1
           };
-          const { createHash: createHash5 } = await import("node:crypto");
-          const checksum = createHash5("sha256").update(JSON.stringify(payload)).digest("hex");
+          const { createHash: createHash6 } = await import("node:crypto");
+          const checksum = createHash6("sha256").update(JSON.stringify(payload)).digest("hex");
           await fetchFromRemoteNode(node, "/api/settings/sync-receive", {
             method: "POST",
             body: { ...payload, checksum }
@@ -133476,7 +134039,7 @@ var init_register_settings_sync_routes = __esm({
             });
             return;
           }
-          const { createHash: createHash5 } = await import("node:crypto");
+          const { createHash: createHash6 } = await import("node:crypto");
           const exportedAt = (/* @__PURE__ */ new Date()).toISOString();
           const payloadWithoutChecksum = {
             global: remoteSettings.global,
@@ -133484,7 +134047,7 @@ var init_register_settings_sync_routes = __esm({
             exportedAt,
             version: 1
           };
-          const checksum = createHash5("sha256").update(JSON.stringify(payloadWithoutChecksum)).digest("hex");
+          const checksum = createHash6("sha256").update(JSON.stringify(payloadWithoutChecksum)).digest("hex");
           const result = await central.applyRemoteSettings({
             ...payloadWithoutChecksum,
             checksum
@@ -136574,7 +137137,7 @@ Rules:
 // ../dashboard/src/routes/register-agent-import-export-generation-routes.ts
 import { createWriteStream } from "node:fs";
 import * as fsPromises2 from "node:fs/promises";
-import { tmpdir as tmpdir3 } from "node:os";
+import { tmpdir as tmpdir4 } from "node:os";
 import { join as join45, resolve as resolve22 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline as streamPipeline } from "node:stream/promises";
@@ -136616,7 +137179,7 @@ function registerAgentImportExportRoutes(ctx) {
       } else if (typeof outputDir === "string") {
         throw badRequest("outputDir cannot be empty");
       } else {
-        resolvedOutputDir = await mkdtemp(join45(tmpdir3(), "fusion-agent-export-"));
+        resolvedOutputDir = await mkdtemp(join45(tmpdir4(), "fusion-agent-export-"));
       }
       const result = await exportAgentsToDirectory2(agentsToExport, resolvedOutputDir, {
         companyName: typeof companyName === "string" ? companyName : void 0,
@@ -136931,7 +137494,7 @@ ${body}`;
         const archiveUrl = `https://github.com/${repoOwner}/${repoName}/archive/refs/heads/main.tar.gz`;
         let tempDir = null;
         try {
-          tempDir = await mkdtemp(join45(tmpdir3(), `fn-agent-import-${importCompanySlug}-`));
+          tempDir = await mkdtemp(join45(tmpdir4(), `fn-agent-import-${importCompanySlug}-`));
           const archivePath = join45(tempDir, "archive.tar.gz");
           const downloadController = new AbortController();
           const downloadTimeout = setTimeout(() => downloadController.abort(), 3e4);
@@ -141458,6 +142021,21 @@ ${stderr}`;
     });
   });
 }
+function buildSkippedStatusPayload(expectedVersion) {
+  return {
+    binary: {
+      installed: false,
+      invocation: FN_INSTALL_NPM
+    },
+    expectedVersion,
+    state: "skipped",
+    install: {
+      npm: FN_INSTALL_NPM,
+      curl: FN_INSTALL_CURL,
+      package: FN_NPM_PACKAGE
+    }
+  };
+}
 var INSTALL_TIMEOUT_MS, MAX_OUTPUT_BYTES2, registerFnBinaryRoutes;
 var init_register_fn_binary_routes = __esm({
   "../dashboard/src/routes/register-fn-binary-routes.ts"() {
@@ -141468,11 +142046,23 @@ var init_register_fn_binary_routes = __esm({
     INSTALL_TIMEOUT_MS = 18e4;
     MAX_OUTPUT_BYTES2 = 64 * 1024;
     registerFnBinaryRoutes = (ctx) => {
-      const { router, rethrowAsApiError: rethrowAsApiError8 } = ctx;
+      const { router, rethrowAsApiError: rethrowAsApiError8, store } = ctx;
+      async function isCheckEnabled() {
+        try {
+          const settings = await store.getSettings();
+          return settings.fnBinaryCheckEnabled !== false;
+        } catch {
+          return true;
+        }
+      }
       router.get("/system/fn-binary/status", async (_req, res) => {
         try {
-          const binary = await detectFnBinary();
           const expectedVersion = getCliPackageVersion();
+          if (!await isCheckEnabled()) {
+            res.json(buildSkippedStatusPayload(expectedVersion));
+            return;
+          }
+          const binary = await detectFnBinary();
           res.json(buildStatusPayload(binary, expectedVersion));
         } catch (err) {
           if (err instanceof ApiError) throw err;
@@ -141481,6 +142071,13 @@ var init_register_fn_binary_routes = __esm({
       });
       router.post("/system/fn-binary/install", async (_req, res) => {
         try {
+          if (!await isCheckEnabled()) {
+            throw new ApiError(
+              409,
+              "fn-binary checks are disabled in global settings (fnBinaryCheckEnabled=false). Re-enable them to install via the dashboard.",
+              { code: "FN_BINARY_CHECK_DISABLED" }
+            );
+          }
           const installResult = await runNpmInstall();
           const binary = await detectFnBinary();
           const expectedVersion = getCliPackageVersion();
@@ -153257,7 +153854,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes4, createHash: createHash5 } = __require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash6 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -153917,7 +154514,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;
@@ -154284,7 +154881,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter37 = __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();
@@ -154585,7 +155182,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",
@@ -155627,6 +156224,43 @@ data: ${JSON.stringify(entry)}
       scopedStore.off("agent:log", onAgentLog);
     });
   });
+  app.get("/api/agents/:id/runs/:runId/logs/stream", async (req, res) => {
+    const agentId = req.params.id;
+    const runId = req.params.runId;
+    const projectId = typeof req.query.projectId === "string" ? req.query.projectId : void 0;
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    res.write(": connected\n\n");
+    const engineManager = options?.engineManager;
+    const engine2 = engineManager && projectId ? engineManager.getEngine(projectId) : options?.engine;
+    const agentStore = engine2?.getAgentStore();
+    if (!agentStore) {
+      res.write(`event: error
+data: ${JSON.stringify({ message: "No active engine for project" })}
+
+`);
+      res.end();
+      return;
+    }
+    const onRunLog = (eventAgentId, eventRunId, entry) => {
+      if (eventAgentId !== agentId || eventRunId !== runId) return;
+      res.write(`event: agent:log
+data: ${JSON.stringify(entry)}
+
+`);
+    };
+    agentStore.on("run:log", onRunLog);
+    const heartbeat = setInterval(() => {
+      res.write(": heartbeat\n\n");
+    }, 3e4);
+    req.on("close", () => {
+      clearInterval(heartbeat);
+      agentStore.off("run:log", onRunLog);
+    });
+  });
   app.get("/api/terminal/sessions/:id/stream", rateLimit(RATE_LIMITS.sse), (req, res) => {
     const sessionId = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
     res.setHeader("Content-Type", "text/event-stream");
@@ -158252,7 +158886,7 @@ var app_exports = {};
 __export(app_exports, {
   DashboardApp: () => DashboardApp
 });
-import { useState as useState2, useSyncExternalStore, useCallback as useCallback2, useEffect as useEffect2 } from "react";
+import { useState as useState2, useSyncExternalStore, useCallback as useCallback2, useEffect as useEffect2, useRef } from "react";
 import { Box, Text, useInput, useApp, useStdout } from "ink";
 import Spinner from "ink-spinner";
 import TextInput from "ink-text-input";
@@ -159034,7 +159668,8 @@ function formatLogTime(iso) {
 function TaskDetailScreen({
   task,
   projectPath,
-  interactiveData
+  interactiveData,
+  controller
 }) {
   const { stdout } = useStdout();
   const cols = stdout?.columns ?? 80;
@@ -159099,6 +159734,27 @@ function TaskDetailScreen({
   useEffect2(() => {
     if (autoFollow) setLogScrollOffset(0);
   }, [autoFollow, logCount]);
+  const WHEEL_STEP = 3;
+  const logCountRef = useRef(logCount);
+  const logPaneRowsRef = useRef(logPaneRows);
+  logCountRef.current = logCount;
+  logPaneRowsRef.current = logPaneRows;
+  useEffect2(() => {
+    return controller.onWheel((dir2) => {
+      const maxOffset = Math.max(0, logCountRef.current - logPaneRowsRef.current);
+      if (maxOffset === 0) return;
+      if (dir2 === "up") {
+        setAutoFollow(false);
+        setLogScrollOffset((o) => Math.min(maxOffset, o + WHEEL_STEP));
+      } else {
+        setLogScrollOffset((o) => {
+          const next = Math.max(0, o - WHEEL_STEP);
+          if (next === 0) setAutoFollow(true);
+          return next;
+        });
+      }
+    });
+  }, [controller]);
   useInput((input, key) => {
     if (detail && detail !== "unavailable" && detail.recentLogs.length > 0) {
       const maxOffset = Math.max(0, detail.recentLogs.length - logPaneRows);
@@ -159469,7 +160125,8 @@ function BoardView({ state, controller }) {
       {
         task: selectedTask,
         projectPath: selectedProject?.path ?? null,
-        interactiveData: state.interactiveData
+        interactiveData: state.interactiveData,
+        controller
       }
     ) }) : tasksState.loading ? /* @__PURE__ */ jsxs(Box, { justifyContent: "center", alignItems: "center", flexGrow: 1, gap: 1, children: [
       /* @__PURE__ */ jsx(Text, { color: "white", children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
@@ -160291,7 +160948,7 @@ function PushModal({
     }
   );
 }
-function GitView({ state }) {
+function GitView({ state, controller }) {
   const { stdout } = useStdout();
   const cols = stdout?.columns ?? 80;
   const data = state.interactiveData;
@@ -160479,6 +161136,23 @@ function GitView({ state }) {
       }
     }
   });
+  const gitWheelRef = useRef({ activePane, commits, branches, worktrees });
+  gitWheelRef.current = { activePane, commits, branches, worktrees };
+  useEffect2(() => {
+    if (state.interactiveView !== "git") return;
+    return controller.onWheel((dir2) => {
+      const { activePane: pane, commits: cs, branches: bs, worktrees: ws } = gitWheelRef.current;
+      const STEP = 3;
+      const delta = dir2 === "up" ? -STEP : STEP;
+      if (pane === "commits") {
+        setCommitIndex((i) => Math.max(0, Math.min(cs.length - 1, i + delta)));
+      } else if (pane === "branches") {
+        setBranchIndex((i) => Math.max(0, Math.min(bs.length - 1, i + delta)));
+      } else if (pane === "worktrees") {
+        setWorktreeIndex((i) => Math.max(0, Math.min(ws.length - 1, i + delta)));
+      }
+    });
+  }, [controller, state.interactiveView]);
   const isNarrow = cols < NARROW_THRESHOLD;
   const leftWidth = Math.max(24, Math.floor(cols * 0.35));
   const rightWidth = cols - leftWidth - 1;
@@ -160820,7 +161494,7 @@ function entriesToNodes(entries, depth) {
   const files = filtered.filter((e) => !e.isDirectory).sort((a, b) => a.name.localeCompare(b.name));
   return [...dirs, ...files].map((e) => ({ entry: e, depth, expanded: false, children: void 0 }));
 }
-function FilesView({ state }) {
+function FilesView({ state, controller }) {
   const { stdout } = useStdout();
   const cols = stdout?.columns ?? 80;
   const data = state.interactiveData;
@@ -161028,6 +161702,23 @@ function FilesView({ state }) {
       }
     }
   }, { isActive: state.interactiveView === "files" });
+  const filesWheelRef = useRef({ focusedPane, flatNodes, previewResult, previewHeight });
+  filesWheelRef.current = { focusedPane, flatNodes, previewResult, previewHeight };
+  useEffect2(() => {
+    if (state.interactiveView !== "files") return;
+    return controller.onWheel((dir2) => {
+      const { focusedPane: pane, flatNodes: nodes, previewResult: pr, previewHeight: ph } = filesWheelRef.current;
+      const STEP = 3;
+      const delta = dir2 === "up" ? -STEP : STEP;
+      if (pane === "tree") {
+        setSelectedIndex((i) => Math.max(0, Math.min(nodes.length - 1, i + delta)));
+      } else {
+        const lineCount = pr?.lineCount ?? 0;
+        const maxScroll = Math.max(0, lineCount - ph);
+        setPreviewScroll((s) => Math.max(0, Math.min(maxScroll, s + delta)));
+      }
+    });
+  }, [controller, state.interactiveView]);
   const isNarrow = cols < NARROW_THRESHOLD;
   const treeWidth = isNarrow ? Math.max(20, cols - 2) : Math.max(20, Math.floor(cols * 0.38));
   const previewEntry = selectedNode && !selectedNode.entry.isDirectory ? selectedNode.entry : null;
@@ -161191,8 +161882,8 @@ function InteractiveMode({ state, controller }) {
       state.interactiveView === "board" && /* @__PURE__ */ jsx(BoardView, { state, controller }),
       state.interactiveView === "agents" && /* @__PURE__ */ jsx(AgentsView, { state }),
       state.interactiveView === "settings" && /* @__PURE__ */ jsx(SettingsInteractiveView, { state, controller }),
-      state.interactiveView === "git" && /* @__PURE__ */ jsx(GitView, { state }),
-      state.interactiveView === "files" && /* @__PURE__ */ jsx(FilesView, { state })
+      state.interactiveView === "git" && /* @__PURE__ */ jsx(GitView, { state, controller }),
+      state.interactiveView === "files" && /* @__PURE__ */ jsx(FilesView, { state, controller })
     ] })
   ] });
 }
@@ -161223,6 +161914,23 @@ function DashboardApp({ controller }) {
     useCallback2((cb) => controller.subscribe(cb), [controller]),
     useCallback2(() => controller.getSnapshot(), [controller])
   );
+  const wheelStateRef = useRef(state);
+  wheelStateRef.current = state;
+  useEffect2(() => {
+    return controller.onWheel((dir2) => {
+      const s = wheelStateRef.current;
+      if (s.activeSection !== "logs") return;
+      const filtered = controller.getFilteredLogEntries();
+      if (filtered.length === 0) return;
+      const WHEEL_STEP = 3;
+      const cur = s.selectedLogIndex;
+      if (dir2 === "up") {
+        controller.setSelectedLogIndex(Math.max(0, cur - WHEEL_STEP));
+      } else {
+        controller.setSelectedLogIndex(Math.min(filtered.length - 1, cur + WHEEL_STEP));
+      }
+    });
+  }, [controller]);
   const [qrOverlay, setQrOverlay] = useState2(null);
   useInput((input, key) => {
     if ((input === "q" || input === "Q") && !key.ctrl || key.ctrl && input === "c") {
@@ -161605,6 +162313,15 @@ var init_controller = __esm({
       // no remote API is wired up).
       remoteStatus = null;
       remoteStatusTimer = null;
+      // Mouse-wheel handling. We enable xterm SGR mouse mode in start() so the
+      // terminal sends button reports for wheel up/down (buttons 64/65). A
+      // parallel `data` listener parses those reports and dispatches to wheel
+      // handlers. Ink's own keypress parser ignores SGR mouse sequences so
+      // long as the full sequence (including the leading ESC) arrives in one
+      // chunk — which it does once raw mode is enabled before mouse mode is
+      // requested. (See ink#222 / @zenobius/ink-mouse for prior art.)
+      wheelHandlers = /* @__PURE__ */ new Set();
+      mouseStdinListener = null;
       constructor() {
         this.logBuffer = new LogRingBuffer();
       }
@@ -161613,6 +162330,15 @@ var init_controller = __esm({
         this.subscribers.add(callback);
         return () => this.subscribers.delete(callback);
       }
+      /**
+       * Subscribe to mouse-wheel events. Direction is "up" (scroll back/older
+       * content) or "down" (scroll forward/newer content). Only fires while the
+       * dashboard is running and the terminal supports xterm mouse reporting.
+       */
+      onWheel(handler) {
+        this.wheelHandlers.add(handler);
+        return () => this.wheelHandlers.delete(handler);
+      }
       getSnapshot() {
         if (this.cachedSnapshot) return this.cachedSnapshot;
         this.cachedSnapshot = {
@@ -161997,6 +162723,10 @@ var init_controller = __esm({
         this.inkInstance = render(
           createElement(DashboardApp2, { controller: this })
         );
+        if (process.stdin?.isTTY) {
+          process.stdout.write("\x1B[?1000h\x1B[?1006h");
+          this.installMouseListener();
+        }
         this.resizeListener = () => {
           if (this.resizeDebounceTimer) clearTimeout(this.resizeDebounceTimer);
           this.resizeDebounceTimer = setTimeout(() => {
@@ -162103,10 +162833,48 @@ var init_controller = __esm({
           this.inkInstance = null;
         }
         if (process.stdout?.isTTY && typeof process.stdout.write === "function") {
+          this.uninstallMouseListener();
+          process.stdout.write("\x1B[?1006l\x1B[?1000l");
           process.stdout.write("\x1B[?1049l");
         }
       }
       // ── Private helpers ────────────────────────────────────────────────────────
+      // Attach a parallel `data` listener that decodes xterm SGR mouse
+      // sequences and dispatches wheel events. Ink's own listener is also
+      // attached; SGR sequences arrive as a single chunk that Ink's keypress
+      // parser silently ignores, so we don't need to (and shouldn't) strip
+      // them from the stream.
+      installMouseListener() {
+        if (this.mouseStdinListener) return;
+        const mouseRe = /\x1b\[<(\d+);\d+;\d+[Mm]/g;
+        const listener = (chunk) => {
+          const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+          if (text.indexOf("\x1B[<") === -1) return;
+          mouseRe.lastIndex = 0;
+          let m;
+          while ((m = mouseRe.exec(text)) !== null) {
+            const btn = Number.parseInt(m[1] ?? "", 10);
+            if (btn === 64) this.dispatchWheel("up");
+            else if (btn === 65) this.dispatchWheel("down");
+          }
+        };
+        this.mouseStdinListener = listener;
+        process.stdin.on("data", listener);
+      }
+      uninstallMouseListener() {
+        if (!this.mouseStdinListener) return;
+        process.stdin.off("data", this.mouseStdinListener);
+        this.mouseStdinListener = null;
+      }
+      dispatchWheel(direction) {
+        for (const handler of this.wheelHandlers) {
+          try {
+            handler(direction);
+          } catch (err) {
+            tuiDebug2("wheel-handler-error", { err: String(err) });
+          }
+        }
+      }
       clampSelectedLogIndex(entries) {
         if (entries.length === 0) {
           this.selectedLogIndex = 0;
@@ -170710,7 +171478,7 @@ __export(native_patch_exports, {
 });
 import { join as join68, basename as basename21, dirname as dirname28 } from "node:path";
 import { existsSync as existsSync51, copyFileSync, mkdirSync as mkdirSync12, symlinkSync as symlinkSync2, rmSync as rmSync5, lstatSync as lstatSync3, readlinkSync as readlinkSync2 } from "node:fs";
-import { tmpdir as tmpdir4 } from "node:os";
+import { tmpdir as tmpdir5 } from "node:os";
 function findStagedNativeDir2() {
   const platform4 = process.platform === "darwin" ? "darwin" : process.platform === "linux" ? "linux" : process.platform === "win32" ? "win32" : "unknown";
   const arch = process.arch === "arm64" ? "arm64" : process.arch === "x64" ? "x64" : "unknown";
@@ -170755,7 +171523,7 @@ function setupNativeResolution() {
     process.env.NODE_PTY_SPAWN_HELPER_DIR = nativeDir;
   }
   process.env.FUSION_NATIVE_ASSETS_PATH = nativeDir;
-  const tmpRoot = join68(tmpdir4(), `fn-bunfs-${process.pid}`);
+  const tmpRoot = join68(tmpdir5(), `fn-bunfs-${process.pid}`);
   const fnDir = join68(tmpRoot, "fn");
   const prebuildsDir = join68(fnDir, "prebuilds");
   const platformDir = join68(prebuildsDir, basename21(nativeDir));
@@ -170843,7 +171611,7 @@ var init_native_patch = __esm({
 import { existsSync as existsSync52, mkdtempSync as mkdtempSync2, readFileSync as readFileSync24, symlinkSync as symlinkSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
 import { join as join69, dirname as dirname29, resolve as resolve41 } from "node:path";
-import { tmpdir as tmpdir5 } from "node:os";
+import { tmpdir as tmpdir6 } from "node:os";
 import { performance as performance3 } from "node:perf_hooks";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 var isBunBinary3 = typeof Bun !== "undefined" && !!Bun.embeddedFiles;
@@ -170851,7 +171619,7 @@ function configurePiPackage() {
   if (process.env.PI_PACKAGE_DIR) {
     return;
   }
-  const tmp = mkdtempSync2(join69(tmpdir5(), "fn-pkg-"));
+  const tmp = mkdtempSync2(join69(tmpdir6(), "fn-pkg-"));
   let packageJson = {
     name: "pi",
     version: "0.1.0",