@runfusion/fusion 0.20.0 → 0.22.0

package/dist/extension.js

@@ -1183,6 +1183,7 @@ function agentToConfigSnapshot(agent) {
     role: agent.role,
     title: agent.title,
     icon: agent.icon,
+    imageUrl: agent.imageUrl,
     reportsTo: agent.reportsTo,
     runtimeConfig: agent.runtimeConfig ? { ...agent.runtimeConfig } : void 0,
     permissions: agent.permissions ? { ...agent.permissions } : void 0,
@@ -1204,6 +1205,7 @@ function diffConfigSnapshots(before, after) {
     "role",
     "title",
     "icon",
+    "imageUrl",
     "reportsTo",
     "runtimeConfig",
     "permissions",
@@ -1574,12 +1576,10 @@ Output Requirements:
     };
     AGENT_VALID_TRANSITIONS = {
       idle: ["active"],
-      active: ["running", "paused", "terminated"],
-      running: ["active", "paused", "error", "terminated"],
-      paused: ["active", "terminated"],
-      error: ["active", "terminated"],
-      terminated: ["idle", "active", "running"]
-      // Can be restarted or reset
+      active: ["idle", "running", "paused", "error"],
+      running: ["idle", "active", "paused", "error"],
+      paused: ["idle", "active"],
+      error: ["idle", "active"]
     };
     AGENT_PERMISSIONS = [
       "tasks:assign",
@@ -3813,6 +3813,7 @@ This means a caller passed a .fusion directory where a project root was expected
         );
         this.migrate();
         this.ensureRoutinesSchemaCompatibility();
+        this.ensureInsightRunsSchemaCompatibility();
         const configNow = (/* @__PURE__ */ new Date()).toISOString();
         this.db.exec(
           `INSERT OR IGNORE INTO config (id, nextId, nextWorkflowStepId, settings, workflowSteps, updatedAt) VALUES (1, 1, 1, '${JSON.stringify(DEFAULT_PROJECT_SETTINGS)}', '[]', '${configNow}')`
@@ -3860,6 +3861,23 @@ This means a caller passed a .fusion directory where a project root was expected
         this.db.exec("CREATE INDEX IF NOT EXISTS idxRoutinesEnabled ON routines(enabled)");
         this.db.exec("CREATE INDEX IF NOT EXISTS idxRoutinesScope ON routines(scope)");
       }
+      /**
+       * Applies idempotent compatibility fixes for the project_insight_runs table.
+       *
+       * The `lifecycle` and `cancelledAt` columns were added to SCHEMA_SQL and
+       * retroactively inserted into migration v33's CREATE TABLE, with a safety-net
+       * in migration v59.  However, databases that were already at v59+ when the
+       * commit landed never re-run v59, leaving the columns missing.  Running this
+       * unconditionally on every init guarantees the columns exist.
+       */
+      ensureInsightRunsSchemaCompatibility() {
+        if (!this.hasTable("project_insight_runs")) {
+          return;
+        }
+        this.addColumnIfMissing("project_insight_runs", "lifecycle", "TEXT");
+        this.addColumnIfMissing("project_insight_runs", "cancelledAt", "TEXT");
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idxInsightRunsProjectTriggerStatus ON project_insight_runs(projectId, trigger, status)`);
+      }
       migrate() {
         const version = this.getSchemaVersion() || 1;
         if (version >= SCHEMA_VERSION) return;
@@ -5537,6 +5555,7 @@ var init_agent_store = __esm({
           metadata,
           ...input.title && { title: input.title },
           ...input.icon && { icon: input.icon },
+          ...input.imageUrl && { imageUrl: input.imageUrl },
           ...input.reportsTo && { reportsTo: input.reportsTo },
           ...runtimeConfig && { runtimeConfig },
           ...input.permissions && { permissions: input.permissions },
@@ -5920,6 +5939,7 @@ var init_agent_store = __esm({
             updatedAt,
             ..."title" in updates && { title: updates.title },
             ..."icon" in updates && { icon: updates.icon },
+            ..."imageUrl" in updates && { imageUrl: updates.imageUrl },
             ..."reportsTo" in updates && { reportsTo: updates.reportsTo },
             ..."runtimeConfig" in updates && { runtimeConfig: updates.runtimeConfig },
             ..."pauseReason" in updates && { pauseReason: updates.pauseReason },
@@ -6045,7 +6065,9 @@ var init_agent_store = __esm({
             state: newState,
             updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
             // Clear lastError when transitioning away from terminated
-            ...currentState === "terminated" && newState !== "terminated" && { lastError: void 0 }
+            // Clear lastError when an agent re-enters an actionable state so
+            // a resumed agent does not carry stale "Error" badges.
+            ...(newState === "active" || newState === "running") && { lastError: void 0 }
           };
           await this.writeAgent(updated);
           this.emit("agent:stateChanged", agentId, currentState, newState);
@@ -6260,9 +6282,6 @@ var init_agent_store = __esm({
         if (activeRun) {
           await this.endHeartbeatRun(activeRun.id, "terminated");
         }
-        if (agent.state !== "idle" && agent.state !== "terminated") {
-          agent = await this.updateAgentState(agentId, "terminated");
-        }
         if (agent.state !== "idle") {
           agent = await this.updateAgentState(agentId, "idle");
         }
@@ -6849,6 +6868,7 @@ var init_agent_store = __esm({
           role: snapshot.role,
           title: snapshot.title,
           icon: snapshot.icon,
+          imageUrl: snapshot.imageUrl,
           reportsTo: snapshot.reportsTo,
           runtimeConfig: snapshot.runtimeConfig ? { ...snapshot.runtimeConfig } : void 0,
           permissions: snapshot.permissions ? { ...snapshot.permissions } : void 0,
@@ -7072,6 +7092,7 @@ var init_agent_store = __esm({
           metadata: data.metadata ?? {},
           title: data.title,
           icon: data.icon,
+          imageUrl: data.imageUrl,
           reportsTo: data.reportsTo,
           runtimeConfig: data.runtimeConfig,
           pauseReason: data.pauseReason,
@@ -7100,6 +7121,7 @@ var init_agent_store = __esm({
           metadata: agent.metadata,
           title: agent.title,
           icon: agent.icon,
+          imageUrl: agent.imageUrl,
           reportsTo: agent.reportsTo,
           runtimeConfig: agent.runtimeConfig,
           pauseReason: agent.pauseReason,
@@ -32528,20 +32550,17 @@ This project has OpenClaw-style memory files:
 
 **At the end of execution (before calling \`fn_task_done()\`):**
 1. Review what you learned during this task that would genuinely benefit future runs
-2. Write durable decisions, conventions, and pitfalls to \`.fusion/memory/MEMORY.md\`
-3. Write running observations, unresolved context, and open loops to today's \`.fusion/memory/YYYY-MM-DD.md\`
-4. **If nothing durable was learned, skip the memory update entirely** \u2014 do not append trivial or task-specific notes
-5. Only write when you have genuinely durable, reusable insights such as:
-   - New architectural patterns or module boundaries discovered
-   - Conventions or standards that should be followed
-   - Pitfalls or anti-patterns to avoid in future work
-   - Important constraints or context that affects implementation decisions
-6. **Avoid** writing task-specific trivia such as:
-   - Per-task implementation logs or changelog entries
-   - Transient failures resolved without broader lessons
-   - One-off file paths, variable names, or minor code changes
-   - Notes about what you did rather than what future agents should know
-7. **Consolidate when possible**: If an existing entry already covers a concept, update or refine it rather than adding a duplicate. Delete entries that are no longer accurate.
+2. Choose scope intentionally:
+   - Use \`fn_memory_append(scope="agent")\` for your private operating context (personal checklists, delegation habits, temporary playbooks, self-improvement notes)
+   - Use \`fn_memory_append(scope="project")\` for repository-wide durable knowledge any future agent should know
+3. Choose layer intentionally:
+   - \`layer="long-term"\` for durable conventions/decisions/pitfalls
+   - \`layer="daily"\` for running observations, unresolved context, and open loops
+4. If using project scope with file backend, write long-term memory to \`.fusion/memory/MEMORY.md\` and daily notes to today's \`.fusion/memory/YYYY-MM-DD.md\`
+5. **If nothing durable was learned, skip the memory update entirely** \u2014 do not append trivial or task-specific notes
+6. Only write to **project** memory when the insight is genuinely reusable across the workspace (architecture patterns, shared conventions, durable pitfalls, cross-task constraints)
+7. **Do not** write private/ephemeral items to project memory, such as personal TODOs, one-off scratch notes, or preferences that only help you as an individual agent
+8. **Consolidate when possible**: If an existing entry already covers a concept, update or refine it rather than adding a duplicate. Delete entries that are no longer accurate.
 
 **Format for additions:** Add bullet points under the relevant section heading:
 - Use \`- \` prefix for list items
@@ -32561,18 +32580,15 @@ This project has a memory system that stores durable project learnings accumulat
 
 **At the end of execution (before calling \`fn_task_done()\`):**
 1. Review what you learned during this task that would genuinely benefit future runs
-2. **If nothing durable was learned, skip the memory update entirely** \u2014 do not append trivial or task-specific notes
-3. Only write when you have genuinely durable, reusable insights such as:
-   - New architectural patterns or module boundaries discovered
-   - Conventions or standards that should be followed
-   - Pitfalls or anti-patterns to avoid in future work
-   - Important constraints or context that affects implementation decisions
-4. **Avoid** writing task-specific trivia such as:
-   - Per-task implementation logs or changelog entries
-   - Transient failures resolved without broader lessons
-   - One-off file paths, variable names, or minor code changes
-   - Notes about what you did rather than what future agents should know
-5. Consolidate when possible: refine an existing memory entry instead of adding duplicates.
+2. Choose scope intentionally:
+   - Use \`fn_memory_append(scope="agent")\` for your private operating context
+   - Use \`fn_memory_append(scope="project")\` only for repo-wide durable knowledge
+3. Choose layer intentionally:
+   - \`layer="long-term"\` for durable conventions/decisions/pitfalls
+   - \`layer="daily"\` for running observations and open loops
+4. **If nothing durable was learned, skip the memory update entirely** \u2014 do not append trivial or task-specific notes
+5. **Avoid task-specific trivia** in project scope (for example: personal reminders, one-off scratch thoughts, individual communication preferences)
+6. Consolidate when possible: refine an existing memory entry instead of adding duplicates.
 `;
 }
 function buildReviewerMemoryInstructions(rootDir, settings) {
@@ -56322,8 +56338,12 @@ function createFusionAuthStorage() {
   const primary = AuthStorage.create(getFusionAuthPath());
   let supplementalCredentials = readSupplementalCredentials();
   let modelsJsonApiKeys = readModelsJsonApiKeys();
+  const loggedOutProviders = /* @__PURE__ */ new Set();
   const syncSupplementalOauthCredentials = () => {
     for (const [provider, credential] of Object.entries(supplementalCredentials)) {
+      if (loggedOutProviders.has(provider)) {
+        continue;
+      }
       const current = primary.get(provider);
       if (!shouldHydrateStoredCredential(current, credential)) {
         continue;
@@ -56344,6 +56364,24 @@ function createFusionAuthStorage() {
       return true;
     },
     get(target, prop, receiver) {
+      if (prop === "logout") {
+        return (provider) => {
+          target.logout(provider);
+          loggedOutProviders.add(provider);
+        };
+      }
+      if (prop === "remove") {
+        return (provider) => {
+          target.remove(provider);
+          loggedOutProviders.add(provider);
+        };
+      }
+      if (prop === "set") {
+        return (provider, credential) => {
+          target.set(provider, credential);
+          loggedOutProviders.delete(provider);
+        };
+      }
       if (prop === "reload") {
         return () => {
           target.reload();
@@ -56353,25 +56391,43 @@ function createFusionAuthStorage() {
         };
       }
       if (prop === "get") {
-        return (provider) => choosePreferredStoredCredential(
-          target.get(provider),
-          supplementalCredentials[provider]
-        );
+        return (provider) => {
+          if (loggedOutProviders.has(provider)) {
+            return void 0;
+          }
+          return choosePreferredStoredCredential(
+            target.get(provider),
+            supplementalCredentials[provider]
+          );
+        };
       }
       if (prop === "has") {
-        return (provider) => target.has(provider) || provider in supplementalCredentials || modelsJsonApiKeys.has(provider);
+        return (provider) => {
+          if (loggedOutProviders.has(provider)) {
+            return false;
+          }
+          return target.has(provider) || provider in supplementalCredentials || modelsJsonApiKeys.has(provider);
+        };
       }
       if (prop === "hasAuth") {
-        return (provider) => target.hasAuth(provider) || Boolean(supplementalCredentials[provider]) || modelsJsonApiKeys.has(provider);
+        return (provider) => {
+          if (loggedOutProviders.has(provider)) {
+            return false;
+          }
+          return target.hasAuth(provider) || Boolean(supplementalCredentials[provider]) || modelsJsonApiKeys.has(provider);
+        };
       }
       if (prop === "getAll") {
         return () => {
           const providerIds = /* @__PURE__ */ new Set([
-            ...Object.keys(supplementalCredentials),
-            ...Object.keys(target.getAll())
+            ...Object.keys(target.getAll()),
+            ...loggedOutProviders.size > 0 ? Object.keys(supplementalCredentials).filter((p) => !loggedOutProviders.has(p)) : Object.keys(supplementalCredentials)
           ]);
           const merged = {};
           for (const providerId of providerIds) {
+            if (loggedOutProviders.has(providerId)) {
+              continue;
+            }
             const credential = choosePreferredStoredCredential(
               target.get(providerId),
               supplementalCredentials[providerId]
@@ -56384,10 +56440,26 @@ function createFusionAuthStorage() {
         };
       }
       if (prop === "list") {
-        return () => Array.from(/* @__PURE__ */ new Set([...Object.keys(supplementalCredentials), ...target.list(), ...modelsJsonApiKeys.keys()]));
+        return () => {
+          const providers = /* @__PURE__ */ new Set([...target.list()]);
+          for (const p of modelsJsonApiKeys.keys()) {
+            if (!loggedOutProviders.has(p)) {
+              providers.add(p);
+            }
+          }
+          for (const p of Object.keys(supplementalCredentials)) {
+            if (!loggedOutProviders.has(p)) {
+              providers.add(p);
+            }
+          }
+          return Array.from(providers).filter((p) => !loggedOutProviders.has(p));
+        };
       }
       if (prop === "getApiKey") {
         return async (provider) => {
+          if (loggedOutProviders.has(provider)) {
+            return void 0;
+          }
           const primaryKey = await target.getApiKey(provider);
           if (primaryKey) return primaryKey;
           const supplementalKey = resolveStoredCredentialApiKey(provider, supplementalCredentials[provider]);
@@ -56641,7 +56713,8 @@ async function flushMemoryBeforeSessionCompaction(session) {
   }
   const flushPrompt = [
     "Before context compaction, preserve only unresolved durable memory if needed.",
-    "If fn_memory_append is available and you learned reusable project decisions, conventions, pitfalls, or open loops that are not already saved, append them now.",
+    "If fn_memory_append is available and you learned reusable project decisions/conventions/pitfalls/open loops or private operating context that is not already saved, append it now.",
+    'Use scope="project" for shared workspace knowledge and scope="agent" for private operating context.',
     'Use layer="long-term" for durable facts and layer="daily" for running notes/open loops.',
     "If there is nothing durable to save, reply exactly: NONE."
   ].join("\n");
@@ -57135,7 +57208,10 @@ async function createFnAgent2(options) {
     if (selectionResult.diagnostics.length > 0) {
       const purpose = effectiveSkillSelection.sessionPurpose ?? "skills";
       for (const diag of selectionResult.diagnostics) {
-        piLog.warn(`[skills] [${purpose}] ${diag.type}: ${diag.message}`);
+        const msg = `[skills] [${purpose}] ${diag.type}: ${diag.message}`;
+        if (diag.type === "error") piLog.error(msg);
+        else if (diag.type === "warning") piLog.warn(msg);
+        else piLog.log(msg);
       }
     }
     skillsOverrideFn = createSkillsOverrideFromSelection(selectionResult, {
@@ -58601,6 +58677,33 @@ function buildSystemPromptWithInstructions(basePrompt, instructions) {
 
 ${instructions}`;
 }
+function buildPluginPromptSection(surface, pluginRunner) {
+  if (!pluginRunner) {
+    return "";
+  }
+  const contributions = pluginRunner.getPromptContributionsForSurface(surface);
+  if (contributions.length === 0) {
+    return "";
+  }
+  const prependByPlugin = /* @__PURE__ */ new Map();
+  const appendByPlugin = /* @__PURE__ */ new Map();
+  for (const { pluginId, contribution } of contributions) {
+    const target = contribution.position === "prepend" ? prependByPlugin : appendByPlugin;
+    const existing = target.get(pluginId) ?? [];
+    existing.push(contribution.content);
+    target.set(pluginId, existing);
+  }
+  const toSections = (group) => {
+    return Array.from(group.entries()).map(([pluginId, contents]) => {
+      return `## Plugin: ${pluginId}
+
+${contents.join("\n\n")}`;
+    });
+  };
+  const sections = [...toSections(prependByPlugin), ...toSections(appendByPlugin)];
+  log11.log(`Applied ${contributions.length} prompt contributions for surface '${surface}'`);
+  return sections.join("\n\n");
+}
 var log11, MAX_INSTRUCTIONS_PATH_LENGTH, MAX_INSTRUCTIONS_TEXT_LENGTH, MAX_SOUL_LENGTH, MAX_MEMORY_LENGTH;
 var init_agent_instructions = __esm({
   "../engine/src/agent-instructions.ts"() {
@@ -59155,7 +59258,7 @@ function createMemoryAppendTool(rootDir, settings, options) {
   return {
     name: "fn_memory_append",
     label: "Append Memory",
-    description: "Append concise Markdown to project memory. Use long-term only for durable conventions/decisions/pitfalls; use daily for running observations and open loops. Skip this tool when there is no reusable memory.",
+    description: 'Append concise Markdown to memory. Use scope="agent" for private operating context and scope="project" for workspace-wide durable knowledge. Use layer="long-term" for durable conventions/decisions/pitfalls and layer="daily" for running observations/open loops.',
     parameters: memoryAppendParams,
     execute: async (_id, params) => {
       const content = params.content.trim();
@@ -61314,6 +61417,17 @@ async function reviewStep(cwd, taskId, stepNumber, stepName, reviewType, promptC
     reviewerBasePrompt + memorySection,
     reviewerInstructions
   );
+  const reviewerContributions = options.pluginRunner?.getPromptContributionsForSurface("reviewer") ?? [];
+  if (reviewerContributions.length > 0) {
+    reviewerLog.log(`applied ${reviewerContributions.length} plugin prompt contributions for reviewer surface`);
+  }
+  const reviewerPluginContributions = buildPluginPromptSection(
+    "reviewer",
+    options.pluginRunner
+  );
+  const reviewerSystemPromptFinal = reviewerPluginContributions ? `${reviewerSystemPrompt}
+
+${reviewerPluginContributions}` : reviewerSystemPrompt;
   let skillContext = void 0;
   if (options.agentStore && options.rootDir) {
     try {
@@ -61359,7 +61473,7 @@ async function reviewStep(cwd, taskId, stepNumber, stepName, reviewType, promptC
       runtimeHint: extractRuntimeHint(memoryAgent?.runtimeConfig),
       pluginRunner: options.pluginRunner,
       cwd,
-      systemPrompt: reviewerSystemPrompt,
+      systemPrompt: reviewerSystemPromptFinal,
       tools: "readonly",
       customTools: memoryTools,
       onText: agentLogger ? agentLogger.onText : (delta) => options.onText?.(delta),
@@ -62619,23 +62733,7 @@ Write the PROMPT.md directly using the write tool, then call \`fn_review_spec()\
         this.options = options;
         store.on("settings:updated", ({ settings, previous }) => {
           if (settings.globalPause && !previous.globalPause) {
-            for (const taskId of [...this.activeSubagentSessions.keys()]) {
-              this.disposeSubagentsForTask(taskId, "global pause");
-            }
-            for (const [taskId, session] of this.activeSessions) {
-              planLog.log(
-                `Global pause \u2014 terminating triage session for ${taskId}`
-              );
-              this.pauseAborted.add(taskId);
-              this.options.stuckTaskDetector?.untrackTask(taskId);
-              const sessionWithAbort = session;
-              if (typeof sessionWithAbort.abort === "function") {
-                void sessionWithAbort.abort().catch((err) => {
-                  planLog.warn(`Failed to abort triage session for ${taskId}: ${err}`);
-                });
-              }
-              session.dispose();
-            }
+            this.abortAndDisposeActiveSessions("global pause");
           }
         });
         store.on("settings:updated", ({ settings, previous }) => {
@@ -62704,8 +62802,35 @@ Write the PROMPT.md directly using the write tool, then call \`fn_review_spec()\
           this.pollInterval = null;
           this.activePollMs = null;
         }
+        this.abortAndDisposeActiveSessions("engine stop");
         planLog.log("Processor stopped");
       }
+      /**
+       * Abort and dispose every active specify session and reviewer subagent.
+       * Used by the global-pause handler and by `stop()`.
+       *
+       * Reviewer subagents are torn down first so they don't keep streaming
+       * verdicts while the main triage session is being disposed. abort()
+       * interrupts any in-flight LLM stream / tool call; dispose() then
+       * releases session resources.
+       */
+      abortAndDisposeActiveSessions(reason) {
+        for (const taskId of [...this.activeSubagentSessions.keys()]) {
+          this.disposeSubagentsForTask(taskId, reason);
+        }
+        for (const [taskId, session] of this.activeSessions) {
+          planLog.log(`${reason} \u2014 terminating triage session for ${taskId}`);
+          this.pauseAborted.add(taskId);
+          this.options.stuckTaskDetector?.untrackTask(taskId);
+          const sessionWithAbort = session;
+          if (typeof sessionWithAbort.abort === "function") {
+            void sessionWithAbort.abort().catch((err) => {
+              planLog.warn(`Failed to abort triage session for ${taskId}: ${err}`);
+            });
+          }
+          session.dispose();
+        }
+      }
       /**
        * Mark a task as stuck-aborted so the catch block knows not to treat
        * the disposed session as a genuine failure.
@@ -62999,6 +63124,17 @@ Write the PROMPT.md directly using the write tool, then call \`fn_review_spec()\
               resolveAgentPrompt("triage", settings.agentPrompts) || (isFast ? FAST_TRIAGE_SYSTEM_PROMPT : TRIAGE_SYSTEM_PROMPT),
               triageInstructions
             );
+            const triageContributions = this.options.pluginRunner?.getPromptContributionsForSurface("triage") ?? [];
+            if (triageContributions.length > 0) {
+              planLog.log(`${task.id}: applied ${triageContributions.length} plugin prompt contributions for triage surface`);
+            }
+            const triagePluginContributions = buildPluginPromptSection(
+              "triage",
+              this.options.pluginRunner
+            );
+            const triageSystemPromptFinal = triagePluginContributions ? `${triageSystemPrompt}
+
+${triagePluginContributions}` : triageSystemPrompt;
             const skillContext = await buildSessionSkillContext({
               agentStore: this.options.agentStore,
               task,
@@ -63011,7 +63147,7 @@ Write the PROMPT.md directly using the write tool, then call \`fn_review_spec()\
               runtimeHint: triageRuntimeHint,
               pluginRunner: this.options.pluginRunner,
               cwd: this.rootDir,
-              systemPrompt: triageSystemPrompt,
+              systemPrompt: triageSystemPromptFinal,
               tools: "coding",
               customTools,
               onText: agentLogger.onText,
@@ -63175,7 +63311,7 @@ Write the PROMPT.md directly using the write tool, then call \`fn_review_spec()\
                   runtimeHint: triageRuntimeHint,
                   pluginRunner: this.options.pluginRunner,
                   cwd: this.rootDir,
-                  systemPrompt: triageSystemPrompt,
+                  systemPrompt: triageSystemPromptFinal,
                   tools: "coding",
                   customTools,
                   onText: agentLogger.onText,
@@ -64749,6 +64885,7 @@ Do not refactor, rename broadly, or make opportunistic improvements.
         taskTitle: taskForSkillContext?.title
       })
     });
+    options.onSession?.(session);
     const runId = mergeRunContext?.runId;
     const agentId = mergeRunContext?.agentId ?? "merger";
     await store.logEntry(
@@ -64849,50 +64986,322 @@ function resetMergeWithWarn(rootDir, taskId, label) {
     mergerLog.warn(`${taskId}: git reset --merge cleanup failed during ${label}: ${msg}`);
   }
 }
-async function stashUnrelatedRootDirChanges(rootDir, taskId) {
+async function listOrphanedAutostashes(rootDir) {
   try {
-    const dirty = await snapshotDirtyFiles(rootDir);
-    if (dirty.size === 0) return null;
-    const label = `fusion-merger-autostash:${taskId}:${Date.now()}`;
-    await execAsync2(
-      `git stash push -u -m "${label}"`,
-      { cwd: rootDir }
-    );
     const { stdout } = await execAsync2(
-      `git stash list --format="%gd %s"`,
+      `git stash list --format="%H %gd %s"`,
       { cwd: rootDir, encoding: "utf-8" }
     );
-    const lines = String(stdout).split("\n");
-    const match = lines.find((line) => line.includes(label));
-    if (!match) {
+    const lines = String(stdout).split("\n").map((l) => l.trim()).filter(Boolean);
+    const orphans = [];
+    for (const line of lines) {
+      const idx = line.indexOf(AUTOSTASH_LABEL_PREFIX);
+      if (idx === -1) continue;
+      const parts = line.split(/\s+/);
+      const sha = parts[0] ?? "";
+      const ref = parts[1] ?? "";
+      const label = line.slice(idx);
+      if (sha && ref) orphans.push({ sha, ref, label });
+    }
+    return orphans;
+  } catch {
+    return [];
+  }
+}
+async function stashUnrelatedRootDirChanges(rootDir, taskId) {
+  try {
+    const orphans = await listOrphanedAutostashes(rootDir);
+    if (orphans.length > 0) {
+      const refs = orphans.map((o) => `${o.ref}@${o.sha.slice(0, 7)}`).join(", ");
       mergerLog.warn(
-        `${taskId}: created autostash but could not locate it in stash list \u2014 leaving in place to avoid data loss`
+        `${taskId}: ${orphans.length} orphaned fusion-merger-autostash entry(ies) in stash list (${refs}) \u2014 these are uncommitted dev changes from prior merges whose restore failed. Recover with: cd ${rootDir} && git stash list && git stash apply <sha>`
       );
+    }
+  } catch {
+  }
+  try {
+    const dirty = await snapshotDirtyFiles(rootDir);
+    if (dirty.size === 0) return null;
+    const label = `${AUTOSTASH_LABEL_PREFIX}${taskId}:${Date.now()}`;
+    await execAsync2("git add -A", { cwd: rootDir });
+    const { stdout: createOut } = await execAsync2("git stash create", {
+      cwd: rootDir,
+      encoding: "utf-8"
+    });
+    const sha = String(createOut).trim();
+    if (!sha) {
+      await execAsync2("git reset", { cwd: rootDir }).catch(() => void 0);
       return null;
     }
-    const ref = match.split(/\s+/)[0] ?? null;
+    await execAsync2(
+      `git stash store -m ${quoteArg(label)} ${sha}`,
+      { cwd: rootDir }
+    );
+    await execAsync2("git reset --hard HEAD", { cwd: rootDir });
+    await execAsync2("git clean -fd", { cwd: rootDir });
     mergerLog.log(
-      `${taskId}: stashed ${dirty.size} unrelated dirty path(s) in rootDir as ${ref} (${label})`
+      `${taskId}: stashed ${dirty.size} unrelated dirty path(s) in rootDir as ${sha.slice(0, 7)} (${label})`
     );
-    return ref;
+    return { sha, label };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     mergerLog.warn(
       `${taskId}: pre-merge autostash failed (${msg}) \u2014 proceeding without stash; concurrent dev edits in rootDir may be wiped`
     );
+    try {
+      await execAsync2("git reset", { cwd: rootDir });
+    } catch {
+    }
     return null;
   }
 }
-async function restoreUnrelatedRootDirChanges(rootDir, taskId, stashRef) {
+async function findStashRefBySha(rootDir, sha) {
   try {
-    await execAsync2(`git stash pop "${stashRef}"`, { cwd: rootDir });
-    mergerLog.log(`${taskId}: restored autostash ${stashRef}`);
+    const { stdout } = await execAsync2(
+      `git stash list --format="%H %gd"`,
+      { cwd: rootDir, encoding: "utf-8" }
+    );
+    for (const line of String(stdout).split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const [entrySha, ref] = trimmed.split(/\s+/);
+      if (entrySha === sha && ref) return ref;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function dropAutostashBySha(rootDir, taskId, sha) {
+  const ref = await findStashRefBySha(rootDir, sha);
+  if (!ref) {
+    mergerLog.log(`${taskId}: autostash ${sha.slice(0, 7)} no longer in stash list (already dropped)`);
+    return;
+  }
+  try {
+    await execAsync2(`git stash drop ${ref}`, { cwd: rootDir });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
+    mergerLog.warn(`${taskId}: failed to drop autostash ${ref} (${msg}) \u2014 harmless, will linger in stash list`);
+  }
+}
+async function runAiAgentForAutostashConflict(params) {
+  const { store, rootDir, taskId, conflictedFiles, options, settings } = params;
+  const agentLogger = new AgentLogger({
+    store,
+    taskId,
+    agent: "merger",
+    persistAgentToolOutput: settings.persistAgentToolOutput,
+    onAgentText: options.onAgentText ? (_id, delta) => options.onAgentText(delta) : void 0,
+    onAgentTool: options.onAgentTool ? (_id, name) => options.onAgentTool(name) : void 0
+  });
+  let taskForSkillContext = null;
+  let skillContext = void 0;
+  if (options.agentStore) {
+    try {
+      taskForSkillContext = await store.getTask(taskId);
+      skillContext = await buildSessionSkillContext({
+        agentStore: options.agentStore,
+        task: taskForSkillContext,
+        sessionPurpose: "merger",
+        projectRootDir: rootDir,
+        pluginRunner: options.pluginRunner
+      });
+    } catch {
+    }
+  }
+  const assignedAgentId = taskForSkillContext?.assignedAgentId?.trim();
+  const agentStoreWithGetAgent = options.agentStore && typeof options.agentStore.getAgent === "function" ? options.agentStore : null;
+  const assignedAgent = assignedAgentId && agentStoreWithGetAgent ? await agentStoreWithGetAgent.getAgent(assignedAgentId).catch(() => null) : null;
+  const mergerRuntimeHint = extractRuntimeHint(assignedAgent?.runtimeConfig);
+  const systemPrompt = `You are an autostash-conflict resolution agent running after a Fusion merge has already committed on the main branch.
+
+Before the merge ran, the developer had uncommitted local changes in their working tree. The merger snapshotted those changes into a git stash, ran the merge cleanly, and is now reapplying the stash on top of the merged HEAD. The reapply hit conflicts because the merge committed changes that overlap the developer's stashed edits.
+
+## Your job
+Edit the conflicted files in place to remove every conflict marker (\`<<<<<<<\`, \`=======\`, \`>>>>>>>\`) and produce a coherent merged result that:
+- Preserves the developer's intended uncommitted changes (the "Updated upstream" / branch-side, depending on which side the stash pop wrote)
+- Layers them onto the merged HEAD content (the other side)
+
+## Rules
+1. Read each conflicted file carefully before editing
+2. Resolve every conflict marker \u2014 none may remain after you finish
+3. Do NOT make any git commits. Do NOT run \`git add\` or \`git stash drop\`. Just edit the files.
+4. Do NOT touch files that are not in the conflicted-files list
+5. If you genuinely cannot determine the right resolution for a hunk, prefer the developer's stashed edits (their work is the unsaved context) and add a brief \`// TODO(autostash-conflict)\` comment so they can review
+
+The orchestrator will verify post-run that no conflict markers remain. If any do, this attempt is treated as a failure and the stash is left intact for manual recovery.`;
+  const fileList = conflictedFiles.map((f) => `- ${f}`).join("\n");
+  const prompt = `Resolve autostash apply conflicts for task ${taskId}.
+
+## Conflicted files
+${fileList}
+
+## Steps
+1. For each file above, read its current contents (it has conflict markers from the failed \`git stash apply\`)
+2. Edit it to a clean state with no conflict markers \u2014 preserving the developer's intended changes layered on top of the merged HEAD
+3. After all files are clean, you are done. Do NOT commit or run git stash commands.`;
+  mergerLog.log(`${taskId}: starting autostash-conflict resolution agent (${conflictedFiles.length} file(s))`);
+  const { session } = await createResolvedAgentSession({
+    sessionPurpose: "merger",
+    runtimeHint: mergerRuntimeHint,
+    pluginRunner: options.pluginRunner,
+    cwd: rootDir,
+    systemPrompt,
+    tools: "coding",
+    onText: agentLogger.onText,
+    onThinking: agentLogger.onThinking,
+    onToolStart: agentLogger.onToolStart,
+    onToolEnd: agentLogger.onToolEnd,
+    defaultProvider: settings.defaultProviderOverride && settings.defaultModelIdOverride ? settings.defaultProviderOverride : settings.defaultProvider,
+    defaultModelId: settings.defaultProviderOverride && settings.defaultModelIdOverride ? settings.defaultModelIdOverride : settings.defaultModelId,
+    fallbackProvider: settings.fallbackProvider,
+    fallbackModelId: settings.fallbackModelId,
+    defaultThinkingLevel: settings.defaultThinkingLevel,
+    ...skillContext?.skillSelectionContext ? { skillSelection: skillContext.skillSelectionContext } : {},
+    taskId,
+    taskTitle: taskForSkillContext?.title,
+    onFallbackModelUsed: createFallbackModelObserver({
+      agent: "merger",
+      label: "autostash conflict agent",
+      store,
+      taskId,
+      taskTitle: taskForSkillContext?.title
+    })
+  });
+  options.onSession?.(session);
+  try {
+    await store.appendAgentLog(
+      taskId,
+      `Autostash conflict agent started (model: ${describeModel(session)}, files: ${conflictedFiles.length})`,
+      "text",
+      void 0,
+      "merger"
+    );
+    await withRateLimitRetry(async () => {
+      throwIfAborted(options.signal, taskId);
+      await promptWithFallback(session, prompt);
+      checkSessionError(session);
+    }, {
+      onRetry: (attempt, delayMs, error) => {
+        const delaySec = Math.round(delayMs / 1e3);
+        mergerLog.warn(`\u23F3 ${taskId} autostash-conflict agent rate limited \u2014 retry ${attempt} in ${delaySec}s: ${error.message}`);
+      },
+      signal: options.signal
+    });
+    return { success: true };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    mergerLog.warn(`${taskId}: autostash-conflict agent error: ${msg}`);
+    await store.logEntry(taskId, "Autostash conflict agent encountered an error", msg);
+    return { success: false, error: msg };
+  } finally {
+    try {
+      session.dispose();
+    } catch {
+    }
+  }
+}
+async function findFilesWithConflictMarkers(rootDir, files) {
+  const stillConflicted = [];
+  for (const file of files) {
+    try {
+      const fullPath = join30(rootDir, file);
+      if (!existsSync24(fullPath)) continue;
+      const { stdout } = await execAsync2(
+        `git grep -l -e "^<<<<<<< " -e "^=======$" -e "^>>>>>>> " --no-index -- ${quoteArg(fullPath)}`,
+        { cwd: rootDir, encoding: "utf-8" }
+      ).catch(() => ({ stdout: "" }));
+      if (String(stdout).trim()) stillConflicted.push(file);
+    } catch {
+    }
+  }
+  return stillConflicted;
+}
+async function restoreUnrelatedRootDirChanges(rootDir, taskId, handle, ctx) {
+  const { sha } = handle;
+  let applyConflicted = false;
+  try {
+    await execAsync2(`git stash apply ${sha}`, { cwd: rootDir });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const conflicted = await getConflictedFiles(rootDir);
+    if (conflicted.length === 0) {
+      mergerLog.warn(
+        `${taskId}: failed to apply autostash ${sha.slice(0, 7)} (${msg}) \u2014 stash left intact; recover with: cd ${rootDir} && git stash apply ${sha}`
+      );
+      return { status: "failed", stashSha: sha, errorMessage: msg };
+    }
+    applyConflicted = true;
     mergerLog.warn(
-      `${taskId}: failed to pop autostash ${stashRef} (${msg}) \u2014 stash left intact; recover with: cd ${rootDir} && git stash list && git stash pop ${stashRef}`
+      `${taskId}: autostash apply hit conflict in ${conflicted.length} file(s): ${conflicted.join(", ")}`
     );
   }
+  if (!applyConflicted) {
+    mergerLog.log(`${taskId}: restored autostash ${sha.slice(0, 7)} cleanly`);
+    await dropAutostashBySha(rootDir, taskId, sha);
+    return { status: "restored", stashSha: sha };
+  }
+  const conflictedFiles = await getConflictedFiles(rootDir);
+  const smartConflictResolution = (ctx.settings.smartConflictResolution ?? ctx.settings.autoResolveConflicts) !== false;
+  if (!smartConflictResolution) {
+    const message = `Autostash apply conflicted in ${conflictedFiles.length} file(s) and smartConflictResolution is disabled. Stash ${sha.slice(0, 7)} left intact; resolve manually with: cd ${rootDir} && # edit files, then git stash drop <ref>`;
+    mergerLog.warn(`${taskId}: ${message}`);
+    return {
+      status: "conflict-needs-manual",
+      stashSha: sha,
+      conflictedFiles,
+      message
+    };
+  }
+  await ctx.store.logEntry(
+    taskId,
+    `Autostash apply conflicted in ${conflictedFiles.length} file(s) \u2014 invoking AI to resolve`,
+    conflictedFiles.join("\n")
+  );
+  const aiResult = await runAiAgentForAutostashConflict({
+    store: ctx.store,
+    rootDir,
+    taskId,
+    conflictedFiles,
+    options: ctx.options,
+    settings: ctx.settings
+  });
+  if (!aiResult.success) {
+    const message = `Autostash apply conflict, AI resolution failed (${aiResult.error ?? "unknown error"}). Stash ${sha.slice(0, 7)} left intact; recover with: cd ${rootDir} && git status (conflicts in working tree) && # resolve, then git stash drop <ref>`;
+    mergerLog.warn(`${taskId}: ${message}`);
+    return {
+      status: "conflict-needs-manual",
+      stashSha: sha,
+      conflictedFiles,
+      message
+    };
+  }
+  const stillConflicted = await findFilesWithConflictMarkers(rootDir, conflictedFiles);
+  if (stillConflicted.length > 0) {
+    const message = `AI agent reported success but conflict markers remain in: ${stillConflicted.join(", ")}. Stash ${sha.slice(0, 7)} left intact; recover manually.`;
+    mergerLog.warn(`${taskId}: ${message}`);
+    return {
+      status: "conflict-needs-manual",
+      stashSha: sha,
+      conflictedFiles: stillConflicted,
+      message
+    };
+  }
+  mergerLog.log(
+    `${taskId}: AI-resolved autostash conflict in ${conflictedFiles.length} file(s); dropping stash ${sha.slice(0, 7)}`
+  );
+  await ctx.store.logEntry(
+    taskId,
+    `Autostash conflict resolved by AI in ${conflictedFiles.length} file(s)`,
+    conflictedFiles.join("\n")
+  );
+  await dropAutostashBySha(rootDir, taskId, sha);
+  return {
+    status: "ai-resolved",
+    stashSha: sha,
+    conflictedFiles
+  };
 }
 async function generateAiMergeSummary(commitLog, diffStat, settings, rootDir) {
   try {
@@ -65661,6 +66070,7 @@ You are assisting with a paused \`git pull --rebase\`.
       taskId
     })
   });
+  options?.onSession?.(session);
   const prompt = [
     `Resolve rebase conflicts for task ${taskId}.`,
     "",
@@ -65874,7 +66284,8 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
   if (mergeBlocker) {
     throw new Error(`Cannot merge ${taskId}: ${mergeBlocker}`);
   }
-  const autostashRef = await stashUnrelatedRootDirChanges(rootDir, taskId);
+  const autostashHandle = await stashUnrelatedRootDirChanges(rootDir, taskId);
+  let resultForFinally;
   try {
     const branch = task.branch || `fusion/${taskId.toLowerCase()}`;
     const sourceIssueRef = buildSourceIssueRef(task.sourceIssue);
@@ -65886,6 +66297,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
       worktreeRemoved: false,
       branchDeleted: false
     };
+    resultForFinally = result;
     const mergeRunId = generateSyntheticRunId("merge", taskId);
     const engineRunContext = {
       runId: mergeRunId,
@@ -66840,7 +67252,8 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
         const pushResult = await pushToRemoteAfterMerge(store, rootDir, taskId, settings, {
           onAgentText: options.onAgentText,
           signal: options.signal,
-          runtimeHint: pushRuntimeHint
+          runtimeHint: pushRuntimeHint,
+          onSession: options.onSession
         });
         if (pushResult.pushed) {
           mergerLog.log(`${taskId}: pushed merged result to remote`);
@@ -66892,8 +67305,29 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
     await completeTask(store, taskId, result);
     return result;
   } finally {
-    if (autostashRef) {
-      await restoreUnrelatedRootDirChanges(rootDir, taskId, autostashRef);
+    if (autostashHandle) {
+      try {
+        const settings = await store.getSettings();
+        const outcome = await restoreUnrelatedRootDirChanges(
+          rootDir,
+          taskId,
+          autostashHandle,
+          { store, options, settings }
+        );
+        if (resultForFinally) {
+          resultForFinally.autostash = outcome;
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        mergerLog.warn(`${taskId}: autostash restore threw unexpectedly (${msg}) \u2014 stash may be left in place; check git stash list`);
+        if (resultForFinally) {
+          resultForFinally.autostash = {
+            status: "failed",
+            stashSha: autostashHandle.sha,
+            errorMessage: msg
+          };
+        }
+      }
     }
   }
 }
@@ -67944,7 +68378,7 @@ async function completeTask(store, taskId, result) {
   result.task = task;
   store.emit("task:merged", result);
 }
-var execAsync2, execFileAsync, LOCKFILE_PATTERNS, GENERATED_PATTERNS, DEPENDENCY_SYNC_TRIGGER_PATTERNS, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS, PULL_REBASE_TIMEOUT_MS, PUSH_TIMEOUT_MS, MERGE_COMMIT_LOG_MAX_CHARS, MERGE_DIFF_STAT_MAX_CHARS, VerificationError, MergeAbortedError, VERIFICATION_EXTRA_ENV, FUSION_TASK_ID_TRAILER_KEY;
+var execAsync2, execFileAsync, LOCKFILE_PATTERNS, GENERATED_PATTERNS, DEPENDENCY_SYNC_TRIGGER_PATTERNS, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS, PULL_REBASE_TIMEOUT_MS, PUSH_TIMEOUT_MS, MERGE_COMMIT_LOG_MAX_CHARS, MERGE_DIFF_STAT_MAX_CHARS, VerificationError, MergeAbortedError, VERIFICATION_EXTRA_ENV, AUTOSTASH_LABEL_PREFIX, FUSION_TASK_ID_TRAILER_KEY;
 var init_merger = __esm({
   "../engine/src/merger.ts"() {
     "use strict";
@@ -68026,6 +68460,7 @@ var init_merger = __esm({
         ["FUSION_TEST_WORKSPACE_CONCURRENCY", "4"]
       ].filter(([key]) => !(key in process.env))
     );
+    AUTOSTASH_LABEL_PREFIX = "fusion-merger-autostash:";
     FUSION_TASK_ID_TRAILER_KEY = "Fusion-Task-Id";
   }
 });
@@ -69950,7 +70385,7 @@ function buildSourceIssueRef2(sourceIssue) {
   }
   return `${sourceIssue.repository}#${issueNumber}`;
 }
-function buildExecutionPrompt(task, rootDir, settings, worktreePath) {
+function buildExecutionPrompt(task, rootDir, settings, worktreePath, pluginRunner) {
   const prompt = scopePromptToWorktree2(task.prompt, rootDir, worktreePath);
   const reviewMatch = prompt.match(/##\s*Review Level[:\s]*(\d)/);
   const reviewLevel = reviewMatch ? parseInt(reviewMatch[1], 10) : 0;
@@ -70023,6 +70458,11 @@ git log --oneline
     }
     steeringSection = lines.join("\n");
   }
+  const taskPromptContributions = pluginRunner?.getPromptContributionsForSurface("executor-task") ?? [];
+  if (taskPromptContributions.length > 0) {
+    executorLog.log(`${task.id}: applied ${taskPromptContributions.length} plugin prompt contributions for executor-task surface`);
+  }
+  const pluginTaskContributions = buildPluginPromptSection("executor-task", pluginRunner);
   return `Execute this task.
 
 ## Task: ${task.id}
@@ -70041,6 +70481,10 @@ ${reviewLevel >= 1 ? `Before implementing each step (except Step 0 and the final
 ${reviewLevel >= 2 ? `After implementing + committing each step, call:
 \`fn_review_step(step=N, type="code", step_name="...", baseline="<SHA from before step>")\`` : ""}
 ${reviewLevel >= 3 ? `After tests, also call fn_review_step with type="code" for test review.` : ""}
+${pluginTaskContributions ? `
+
+${pluginTaskContributions}
+` : ""}
 
 ## Worktree Boundaries
 
@@ -71417,6 +71861,41 @@ The tool prevents your session from being killed by the inactivity watchdog duri
           return false;
         }
       }
+      /**
+       * Returns true when execute() should be deferred because the agent bound to
+       * this task has an active heartbeat run and allowParallelExecution=false.
+       *
+       * Only applies to permanent (non-ephemeral) agents. Always returns false
+       * when agentStore is unavailable or the agent cannot be resolved.
+       */
+      async shouldDeferForHeartbeat(agentId) {
+        if (!this.options.agentStore) return false;
+        const agent = await this.options.agentStore.getAgent(agentId).catch(() => null);
+        if (!agent) return false;
+        if (isEphemeralAgent(agent)) return false;
+        const rc = agent.runtimeConfig ?? {};
+        if (rc.allowParallelExecution !== false) return false;
+        const activeRun = await this.options.agentStore.getActiveHeartbeatRun(agentId).catch(() => null);
+        return activeRun !== null;
+      }
+      /**
+       * Re-dispatch execute() for any unstarted in-progress task belonging to the
+       * given agent. Called after a heartbeat run completes to unblock tasks that
+       * were deferred by the allowParallelExecution=false gate.
+       */
+      async resumeTaskForAgent(agentId) {
+        const settings = await this.store.getSettings();
+        if (settings.globalPause || settings.enginePaused) return;
+        const tasks = await this.store.listTasks({ slim: true, column: "in-progress" });
+        for (const task of tasks) {
+          if (task.assignedAgentId === agentId && !task.paused && !this.executing.has(task.id) && !this.activeSessions.has(task.id) && !this.activeStepExecutors.has(task.id) && !this.activeWorkflowStepSessions.has(task.id)) {
+            executorLog.log(`${task.id}: re-dispatching execute() after heartbeat completion for agent ${agentId}`);
+            this.execute(task).catch(
+              (err) => executorLog.error(`Failed to resume ${task.id} after heartbeat completion:`, err)
+            );
+          }
+        }
+      }
       /**
        * Resume orphaned in-progress tasks (e.g., after crash/restart).
        * Call once after engine startup.
@@ -71508,28 +71987,6 @@ The tool prevents your session from being killed by the inactivity watchdog duri
         }
         return "";
       }
-      resolveDependencyWorktree(task, allTasks) {
-        if (task.dependencies.length === 0) return null;
-        for (const depId of task.dependencies) {
-          const dep = allTasks.find((t) => t.id === depId);
-          if (dep && dep.worktree && (dep.column === "done" || dep.column === "in-review") && existsSync29(dep.worktree)) {
-            return dep.worktree;
-          }
-        }
-        return null;
-      }
-      /**
-       * Reuse an existing worktree directory from a dependency task.
-       * Instead of creating a new worktree with `git worktree add`, this creates
-       * a new branch in the existing worktree via `git checkout -b`. The worktree
-       * directory (and its build caches) are preserved.
-       */
-      async reuseWorktree(branch, worktreePath) {
-        await execAsync5(`git checkout -b "${branch}"`, {
-          cwd: worktreePath
-        });
-        executorLog.log(`Reused worktree at ${worktreePath}, created branch ${branch}`);
-      }
       /**
        * Execute a task in an isolated git worktree.
        *
@@ -71543,6 +72000,11 @@ The tool prevents your session from being killed by the inactivity watchdog duri
       async execute(task) {
         executorLog.log(`execute() called for ${task.id} (already executing=${this.executing.has(task.id)})`);
         if (this.executing.has(task.id)) return;
+        const assignedAgentId = task.assignedAgentId;
+        if (assignedAgentId && await this.shouldDeferForHeartbeat(assignedAgentId)) {
+          executorLog.log(`${task.id}: skipping execute \u2014 agent ${assignedAgentId} has active heartbeat run (allowParallelExecution=false)`);
+          return;
+        }
         this.executing.add(task.id);
         executorLog.log(`Starting ${task.id}: ${task.title || task.description.slice(0, 60)}`);
         const settings = await this.store.getSettings();
@@ -72132,9 +72594,9 @@ ${summary}`,
           const sessionRef = { current: null };
           const stepCheckpoints = /* @__PURE__ */ new Map();
           const stuckDetector = this.options.stuckTaskDetector;
-          const assignedAgentId = detail.assignedAgentId?.trim();
-          const reflectionTools = this.options.reflectionService && settings.reflectionEnabled && assignedAgentId ? [createReflectOnPerformanceTool(this.options.reflectionService, assignedAgentId)] : [];
-          const assignedAgent = assignedAgentId && this.options.agentStore ? await this.options.agentStore.getAgent(assignedAgentId).catch(() => null) : null;
+          const assignedAgentId2 = detail.assignedAgentId?.trim();
+          const reflectionTools = this.options.reflectionService && settings.reflectionEnabled && assignedAgentId2 ? [createReflectOnPerformanceTool(this.options.reflectionService, assignedAgentId2)] : [];
+          const assignedAgent = assignedAgentId2 && this.options.agentStore ? await this.options.agentStore.getAgent(assignedAgentId2).catch(() => null) : null;
           const executorRuntimeHint = extractRuntimeHint(assignedAgent?.runtimeConfig);
           if (executionMode === "fast") {
             executorLog.log(`${task.id}: fast mode \u2014 fn_review_step tool not injected`);
@@ -72183,15 +72645,15 @@ ${summary}`,
             ...this.options.agentStore ? [
               createListAgentsTool(this.options.agentStore),
               createDelegateTaskTool(this.options.agentStore, this.store, { rootDir: this.rootDir }),
-              ...assignedAgentId ? [
-                createGetAgentConfigTool(this.options.agentStore, assignedAgentId),
-                createUpdateAgentConfigTool(this.options.agentStore, assignedAgentId)
+              ...assignedAgentId2 ? [
+                createGetAgentConfigTool(this.options.agentStore, assignedAgentId2),
+                createUpdateAgentConfigTool(this.options.agentStore, assignedAgentId2)
               ] : []
             ] : [],
             // Messaging tools — allows executor agents to send and receive messages.
-            ...this.options.messageStore && assignedAgentId ? [
-              createSendMessageTool(this.options.messageStore, assignedAgentId),
-              createReadMessagesTool(this.options.messageStore, assignedAgentId)
+            ...this.options.messageStore && assignedAgentId2 ? [
+              createSendMessageTool(this.options.messageStore, assignedAgentId2),
+              createReadMessagesTool(this.options.messageStore, assignedAgentId2)
             ] : [],
             // Add plugin tools from PluginRunner
             ...this.options.pluginRunner?.getPluginTools() ?? []
@@ -72229,12 +72691,23 @@ ${summary}`,
               getExecutorSystemPrompt(settings),
               executorInstructions
             );
+            const executorSystemContributions = this.options.pluginRunner?.getPromptContributionsForSurface("executor-system") ?? [];
+            if (executorSystemContributions.length > 0) {
+              executorLog.log(`${task.id}: applied ${executorSystemContributions.length} plugin prompt contributions for executor-system surface`);
+            }
+            const executorPluginContributions = buildPluginPromptSection(
+              "executor-system",
+              this.options.pluginRunner
+            );
+            const executorSystemPromptFinal = executorPluginContributions ? `${executorSystemPrompt}
+
+${executorPluginContributions}` : executorSystemPrompt;
             let { session, sessionFile } = await createResolvedAgentSession({
               sessionPurpose: "executor",
               runtimeHint: executorRuntimeHint,
               pluginRunner: this.options.pluginRunner,
               cwd: worktreePath,
-              systemPrompt: executorSystemPrompt,
+              systemPrompt: executorSystemPromptFinal,
               tools: "coding",
               customTools,
               onText: agentLogger.onText,
@@ -72295,7 +72768,13 @@ ${summary}`,
                   "Review the current state of your worktree and proceed with the next pending step."
                 ].join("\n"));
               } else {
-                const agentPrompt = buildExecutionPrompt(detail, this.rootDir, settings, worktreePath);
+                const agentPrompt = buildExecutionPrompt(
+                  detail,
+                  this.rootDir,
+                  settings,
+                  worktreePath,
+                  this.options.pluginRunner
+                );
                 await promptWithFallback(session, agentPrompt);
               }
               checkSessionError(session);
@@ -72471,7 +72950,7 @@ ${summary}`,
                     runtimeHint: executorRuntimeHint,
                     pluginRunner: this.options.pluginRunner,
                     cwd: worktreePath,
-                    systemPrompt: executorSystemPrompt,
+                    systemPrompt: executorSystemPromptFinal,
                     tools: "coding",
                     customTools,
                     onText: agentLogger.onText,
@@ -72521,7 +73000,7 @@ ${summary}`,
                       "Do NOT ask for permission. Do NOT write a summary. Just call a tool and keep working.",
                       "",
                       "Original task:",
-                      buildExecutionPrompt(detail, this.rootDir, settings, worktreePath)
+                      buildExecutionPrompt(detail, this.rootDir, settings, worktreePath, this.options.pluginRunner)
                     ].join("\n");
                   } else {
                     retryPrompt = [
@@ -72531,7 +73010,7 @@ ${summary}`,
                       "2. If there is remaining work, finish it and then call fn_task_done.",
                       "",
                       "Original task:",
-                      buildExecutionPrompt(detail, this.rootDir, settings, worktreePath)
+                      buildExecutionPrompt(detail, this.rootDir, settings, worktreePath, this.options.pluginRunner)
                     ].join("\n");
                   }
                   stuckDetector?.recordActivity(task.id);
@@ -73591,7 +74070,7 @@ ${failureContext.output.slice(0, VERIFICATION_LOG_MAX_CHARS)}
             return reRunResult.allPassed;
           } finally {
             await logger2.flush();
-            await session.dispose();
+            session.dispose();
           }
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
@@ -74310,7 +74789,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
        * like `fusion/fn-2729`) used purely for log messages. `depTip` is the
        * resolved SHA of the dep's tip — that's what gets squash-merged.
        */
-      async planSquashImportFromDep(taskId, depTip, originalStartPoint) {
+      async planSquashImportFromDep(_taskId, depTip, originalStartPoint) {
         let settings;
         try {
           settings = await this.store.getSettings();
@@ -75199,7 +75678,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
           this.childSessions.delete(childId);
         }
         try {
-          await this.options.agentStore?.updateAgentState(childId, "terminated");
+          await this.options.agentStore?.updateAgentState(childId, "paused");
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           executorLog.warn(`Failed to update spawned child ${childId} state to 'terminated' during cleanup: ${msg}`);
@@ -78242,9 +78721,6 @@ function taskRelevanceScore(agent, task) {
   }
   return score;
 }
-function isBlockedStateDuplicate(current, previous) {
-  return current.blockedBy === previous.blockedBy && current.contextHash === previous.contextHash;
-}
 function truncatePrompt(text, maxChars) {
   if (text.length <= maxChars) return text;
   return `${text.slice(0, maxChars)}
@@ -78304,28 +78780,42 @@ var init_agent_heartbeat = __esm({
 
 ## Your Role
 
-You are a lightweight periodic checker in the broader Fusion system, not the primary implementation agent.
-Your purpose is to keep momentum: detect issues early, surface blockers, and route work to the right place.
-Think in single-pass interventions, not long coding sessions.
+This is an ambient heartbeat. Task implementation work (coding, running tests, making commits) runs in a separate
+execution path handled by the executor. Do NOT do task body work or implementation in this heartbeat.
+
+Your purpose is to keep momentum through coordination: surface blockers, respond to messages, manage memory,
+delegate, and route work to the right place. Think in single-pass interventions, not coding sessions.
 
 Your job:
-1. Check your assigned task \u2014 read the description and PROMPT.md if present.
-2. Do ONE useful action that changes project clarity or flow.
+1. Check your assigned task context \u2014 review its state, blockedBy field, and any new comments.
+2. Do ONE useful coordination action.
 3. Use fn_task_create to spawn follow-up work, fn_task_log to record observations, and fn_task_document_write for durable artifacts.
 4. Use fn_list_agents + fn_delegate_task when work should be assigned to a specific capable agent now.
 5. Use fn_get_agent_config and fn_update_agent_config to tune direct reports before delegating recurring work.
-5. Call fn_heartbeat_done when finished with an optional summary of what was accomplished.
+6. Call fn_heartbeat_done when finished with an optional summary of what was accomplished.
 
-Examples of ONE useful action:
-- DO: summarize a blocker in fn_task_log with concrete next step(s).
+**If your bound task is blocked** (blockedBy is set in the task context):
+- Surface the blocker concretely with fn_task_log.
+- Chase the dependency: comment on the blocking task, send a message to the responsible agent, or ping an owner.
+- Look for unblocking work you can spawn or delegate right now.
+- Pivot to other relevant coordination work if the blocker cannot be immediately resolved.
+
+**If your bound task is not blocked:**
+- Surface progress, status, or coordination needs with fn_task_log or fn_task_document_write.
+- Create follow-up tasks for discovered risks or gaps.
+- Respond to new steering comments or user messages.
+
+Examples of ONE useful coordination action:
+- DO: log a concrete blocker with next steps and message the agent responsible for unblocking.
 - DO: create a focused follow-up task when a missing dependency is discovered.
 - DO: delegate a well-scoped task to an appropriate idle specialist agent.
 - DO: save a short investigation note with fn_task_document_write when the analysis is reusable.
-- DON'T: attempt full implementation, broad refactors, or multi-hour coding.
+- DON'T: attempt full implementation, run tests, commit code, or do multi-step coding work.
 - DON'T: create vague tasks like "investigate stuff" without actionable scope.
 
-Keep work lightweight \u2014 this is a single-pass check, not a full implementation run.
-You have coding-capable workspace tools (read/write/edit/bash within worktree boundaries) plus fn_task_create, fn_task_log, and fn_task_document tools.
+Keep work lightweight \u2014 this is a single-pass coordination check, not an implementation run.
+You have workspace read tools (for context gathering) plus fn_task_create, fn_task_log, fn_task_document tools,
+fn_send_message, fn_read_messages, fn_list_agents, fn_delegate_task, and memory tools.
 
 **Task Documents:** Save important findings with fn_task_document_write(key="...", content="...").
 Documents persist across sessions and are visible in the dashboard's Documents tab.
@@ -78344,7 +78834,8 @@ Prefer fn_delegate_task when immediate ownership by a specific agent materially
 
 ## Common Patterns
 
-- **Stuck task:** log the concrete blocker, create a narrowly scoped unblocker task if needed, and optionally message the responsible agent.
+- **Blocked task:** log the concrete blocker, chase the dependency via fn_send_message, create a narrowly scoped unblocker task if needed.
+- **Stuck task with no blockedBy:** log the observation and create a follow-up task to investigate the root cause.
 - **Completed task with follow-up risk:** create explicit follow-up task(s) for residual risk instead of burying notes in a long log.
 - **New user/agent comments:** summarize what changed, identify required action, and route via task creation/delegation.
 - **Dependency drift:** log the mismatch and create reconciliation tasks with clear dependencies.
@@ -78415,7 +78906,7 @@ You have coding-capable workspace tools (read/write/edit/bash within worktree bo
 Use this decision rule:
 - **fn_task_create:** create executable work when ownership is not predetermined.
 - **fn_delegate_task:** assign immediately when a specific agent should own the work now.
-- **fn_memory_append:** persist durable conventions/pitfalls; avoid transient run-by-run chatter.
+- **fn_memory_append:** use \`scope="agent"\` for your own operating context and \`scope="project"\` for repo-wide durable knowledge; avoid transient run-by-run chatter.
 
 If unsure who should do the work, prefer fn_task_create and let scheduler routing happen naturally.
 
@@ -78563,10 +79054,71 @@ not loop on the same plan across heartbeats without recording why.`;
         if (this.messageStore) {
           this.messageStore.setMessageToAgentHook(this.handleMessageToAgent.bind(this));
         }
+        void this.reconcileOrphanedRunningAgents();
         this.pollInterval = setInterval(() => {
           void this.checkMissedHeartbeats();
         }, this.pollIntervalMs);
       }
+      /**
+       * Find agents in `state="running"` that are not actually running and flip
+       * them to `"active"`. An agent is considered orphaned when either:
+       *   (a) it has no active heartbeat run record, or
+       *   (b) it is not in this monitor's in-memory tracked set AND its
+       *       lastHeartbeatAt is older than 3× the configured timeout.
+       *
+       * Case (a) covers historical bypass paths (governance-skip, supersede-on-
+       * startRun, safety-net run termination) that ended the run record but
+       * never propagated the agent-state transition. Case (b) covers a process
+       * that crashed mid-run, leaving both the run row and the agent row stuck.
+       *
+       * Called on monitor start AND periodically from the polling loop to keep
+       * the system self-healing across versions. Best-effort — failures are
+       * logged but do not block the caller.
+       */
+      async reconcileOrphanedRunningAgents() {
+        try {
+          const runningAgents = await this.store.listAgents({ state: "running", includeEphemeral: true });
+          const now = Date.now();
+          for (const agent of runningAgents) {
+            let reason = null;
+            const activeRun = await this.store.getActiveHeartbeatRun(agent.id);
+            if (!activeRun) {
+              reason = "no active run";
+            } else if (!this.trackedAgents.has(agent.id)) {
+              const timeoutMs = this.resolveAgentConfig(agent.id).heartbeatTimeoutMs;
+              const lastTs = agent.lastHeartbeatAt ? Date.parse(agent.lastHeartbeatAt) : NaN;
+              const heartbeatAgeMs = Number.isFinite(lastTs) ? Math.max(0, now - lastTs) : Infinity;
+              if (heartbeatAgeMs > timeoutMs * 3) {
+                try {
+                  const detail = await this.store.getRunDetail(agent.id, activeRun.id);
+                  if (detail && detail.status !== "completed" && detail.status !== "failed" && detail.status !== "terminated") {
+                    await this.store.saveRun({
+                      ...detail,
+                      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                      status: "terminated",
+                      stderrExcerpt: `Reconciled stale run (no heartbeat for ${formatDuration(heartbeatAgeMs)}; threshold ${formatDuration(timeoutMs * 3)})`
+                    });
+                  }
+                  await this.store.endHeartbeatRun(activeRun.id, "terminated");
+                } catch (runEndErr) {
+                  heartbeatLog.warn(`Failed to terminate stale run ${activeRun.id} for ${agent.id}: ${runEndErr instanceof Error ? runEndErr.message : String(runEndErr)}`);
+                }
+                reason = `stale heartbeat (${formatDuration(heartbeatAgeMs)} since lastHeartbeatAt)`;
+              }
+            }
+            if (!reason) continue;
+            try {
+              await this.store.updateAgentState(agent.id, "active");
+              this.clearRunState(agent.id);
+              heartbeatLog.log(`Reconciled orphaned running agent ${agent.id} \u2192 active (${reason})`);
+            } catch (err) {
+              heartbeatLog.warn(`Failed to reconcile orphaned running agent ${agent.id}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+          }
+        } catch (err) {
+          heartbeatLog.warn(`reconcileOrphanedRunningAgents scan failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
       /**
        * Stop the heartbeat monitoring loop.
        * Does not untrack agents - they remain in memory.
@@ -78754,7 +79306,7 @@ not loop on the same plan across heartbeats without recording why.`;
               await this.store.updateAgentState(agentId, "error");
               await this.store.updateAgent(agentId, { lastError: completionResult.stderrExcerpt ?? "Run failed" });
             } else if (completionResult.status === "terminated") {
-              await this.store.updateAgentState(agentId, "terminated");
+              await this.store.updateAgentState(agentId, "paused");
             } else {
               await this.store.updateAgentState(agentId, "active");
             }
@@ -78763,6 +79315,9 @@ not loop on the same plan across heartbeats without recording why.`;
           }
         }
         await this.store.endHeartbeatRun(runId, completionResult.status === "completed" ? "completed" : "terminated");
+        if (completionResult.status === "terminated") {
+          this.onTerminated?.(agentId, completionResult.stderrExcerpt ?? "Run terminated");
+        }
         this.onRunCompleted?.(agentId, completedRun);
       }
       /**
@@ -79288,45 +79843,8 @@ not loop on the same plan across heartbeats without recording why.`;
                   });
                   return await this.store.getRunDetail(agentId, run.id);
                 }
-                const blockedBy = typeof liveTaskDetail.blockedBy === "string" ? liveTaskDetail.blockedBy.trim() : "";
-                const isBlockedTask = liveTaskDetail.status === "queued" && blockedBy.length > 0;
-                if (isBlockedTask) {
-                  const commentCount = (liveTaskDetail.comments?.length ?? 0) + (liveTaskDetail.steeringComments?.length ?? 0);
-                  const lastCommentId = liveTaskDetail.comments?.at(-1)?.id;
-                  const lastSteeringCommentId = liveTaskDetail.steeringComments?.at(-1)?.id;
-                  const contextHash = Buffer.from(
-                    JSON.stringify({ commentCount, lastCommentId, lastSteeringCommentId, blockedBy })
-                  ).toString("base64").slice(0, 16);
-                  const currentBlockedState = {
-                    taskId: resolvedTaskId2,
-                    blockedBy,
-                    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-                    contextHash
-                  };
-                  const previousBlockedState = await this.store.getLastBlockedState(agentId);
-                  if (previousBlockedState && isBlockedStateDuplicate(currentBlockedState, previousBlockedState)) {
-                    await this.completeRun(agentId, run.id, {
-                      status: "completed",
-                      resultJson: { reason: "blocked_duplicate", taskId: resolvedTaskId2, blockedBy }
-                    });
-                    return await this.store.getRunDetail(agentId, run.id);
-                  }
-                  const blockedMessage = `Task is blocked by ${blockedBy}; waiting for dependency/context changes before retrying.`;
-                  await taskStore.addComment(resolvedTaskId2, blockedMessage, "agent", void 0, runContext);
-                  await audit.database({ type: "task:comment:add", target: resolvedTaskId2, metadata: { blockedBy } });
-                  await this.store.setLastBlockedState(agentId, currentBlockedState);
-                  heartbeatLog.log(`Task ${resolvedTaskId2} is blocked by ${blockedBy} \u2014 recorded blocked state`);
-                  await this.completeRun(agentId, run.id, {
-                    status: "completed",
-                    resultJson: { reason: "blocked", taskId: resolvedTaskId2, blockedBy }
-                  });
-                  return await this.store.getRunDetail(agentId, run.id);
-                }
               }
             }
-            if (!isNoTaskRun) {
-              await this.store.clearLastBlockedState(agentId);
-            }
             const STDOUT_EXCERPT_LIMIT = 4e3;
             let outputLength = 0;
             let toolCallCount = 0;
@@ -79432,6 +79950,17 @@ not loop on the same plan across heartbeats without recording why.`;
               baseHeartbeatSystemPrompt,
               [resolvedInstructionsForIdentity, memoryInstructions, selfImprovePrompt].filter((part) => part.trim()).join("\n\n")
             );
+            const heartbeatContributions = this.pluginRunner?.getPromptContributionsForSurface("heartbeat") ?? [];
+            if (heartbeatContributions.length > 0) {
+              heartbeatLog.log(`applied ${heartbeatContributions.length} plugin prompt contributions for heartbeat surface`);
+            }
+            const heartbeatPluginContributions = buildPluginPromptSection(
+              "heartbeat",
+              this.pluginRunner
+            );
+            const systemPromptFinal = heartbeatPluginContributions ? `${systemPrompt}
+
+${heartbeatPluginContributions}` : systemPrompt;
             heartbeatTools.push(heartbeatDoneTool);
             if (isNoTaskRun) {
               agentLogger = new AgentLogger({
@@ -79453,7 +79982,7 @@ not loop on the same plan across heartbeats without recording why.`;
               runtimeHint: extractRuntimeHint2(agent.runtimeConfig),
               pluginRunner: this.pluginRunner,
               cwd: rootDir,
-              systemPrompt,
+              systemPrompt: systemPromptFinal,
               tools: "coding",
               customTools: heartbeatTools,
               ...(() => {
@@ -79656,7 +80185,7 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
               try {
                 const runWithPrompts = {
                   ...run,
-                  systemPrompt: truncatePrompt(systemPrompt, 1e5),
+                  systemPrompt: truncatePrompt(systemPromptFinal, 1e5),
                   executionPrompt: truncatePrompt(executionPrompt, 1e5),
                   heartbeatProcedureSource: customProcedure ? "custom" : "default"
                 };
@@ -79803,8 +80332,6 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
           let health = "healthy";
           if (report.state === "paused") {
             health = report.pauseReason ? `paused (${report.pauseReason})` : "paused";
-          } else if (report.state === "terminated") {
-            health = "terminated";
           } else if (report.state === "error") {
             health = "**stuck**";
           } else if (report.state === "running") {
@@ -79819,7 +80346,6 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
         });
         const hasStuck = rows.some((row) => row.includes("**stuck**"));
         const hasStale = rows.some((row) => row.includes("**stale**"));
-        const hasTerminated = rows.some((row) => row.includes("terminated"));
         const actionLines = ["### Actions for Unresponsive Reports"];
         if (hasStuck) {
           actionLines.push("- For **stuck** reports: consider sending a message via fn_send_message asking for status, or reassigning their task via fn_delegate_task to a healthy agent.");
@@ -79827,9 +80353,6 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
         if (hasStale) {
           actionLines.push("- For **stale** reports: the agent may have lost its heartbeat trigger \u2014 create a follow-up task to investigate.");
         }
-        if (hasTerminated) {
-          actionLines.push("- For **terminated** reports: if they had active work, reassign their tasks or spawn replacement agents.");
-        }
         return [
           "## Reports Health Check",
           "",
@@ -79985,6 +80508,7 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
             }
           }
         }
+        await this.reconcileOrphanedRunningAgents();
       }
       async handleMissedHeartbeat(tracked, reason) {
         await this.store.recordHeartbeat(tracked.agentId, "missed", tracked.runId);
@@ -79995,12 +80519,21 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
         const elapsed = now - tracked.lastSeen;
         const reason = `No heartbeat for ${formatDuration(elapsed)} (2\xD7 timeout threshold: ${formatDuration(heartbeatTimeoutMs * 2)})`;
         heartbeatLog.warn(`Recovering unresponsive agent ${tracked.agentId}: ${reason}`);
+        const runIdToTerminate = tracked.runId;
         try {
           tracked.session.dispose();
         } catch (err) {
           heartbeatLog.warn(`Error disposing session for ${tracked.agentId}: ${err instanceof Error ? err.message : String(err)}`);
         }
         this.untrackAgent(tracked.agentId);
+        try {
+          await this.completeRun(tracked.agentId, runIdToTerminate, {
+            status: "terminated",
+            stderrExcerpt: reason
+          });
+        } catch (err) {
+          heartbeatLog.warn(`completeRun(terminated) failed for ${tracked.agentId}/${runIdToTerminate}: ${err instanceof Error ? err.message : String(err)}`);
+        }
         try {
           await this.pauseAgent(tracked.agentId, { pauseReason: "heartbeat-unresponsive", stopActiveRun: false });
         } catch (err) {
@@ -80030,10 +80563,12 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
       updatedListener = null;
       configRevisionListener = null;
       deletedListener = null;
-      constructor(store, callback, taskStore) {
+      isTaskExecuting;
+      constructor(store, callback, taskStore, options) {
         this.store = store;
         this.callback = callback;
         this.taskStore = taskStore;
+        this.isTaskExecuting = options?.isTaskExecuting;
       }
       /**
        * Start the scheduler. Enables assignment watching.
@@ -80245,6 +80780,10 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
               heartbeatLog.log(`Assignment trigger skipped for ${agent.id} (active run)`);
               return;
             }
+            if (runtimeConfig.allowParallelExecution === false && this.isTaskExecuting?.(taskId)) {
+              heartbeatLog.log(`Assignment tick skipped for ${agent.id} (parallel execution disabled, task ${taskId} executing)`);
+              return;
+            }
             let budgetStatus;
             try {
               budgetStatus = await this.store.getBudgetStatus(agent.id);
@@ -80415,6 +80954,11 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
             heartbeatLog.log(`Timer tick skipped for ${agentId} (active run)`);
             return;
           }
+          const timerRc = agent.runtimeConfig ?? {};
+          if (timerRc.allowParallelExecution === false && agent.taskId && this.isTaskExecuting?.(agent.taskId)) {
+            heartbeatLog.log(`Timer tick skipped for ${agentId} (parallel execution disabled, task ${agent.taskId} executing)`);
+            return;
+          }
           if (this.taskStore) {
             const settings = await this.taskStore.getSettings();
             if (settings.globalPause) {
@@ -82072,6 +82616,7 @@ var init_stuck_task_detector = __esm({
       onStuck;
       beforeRequeue;
       onLoopDetected;
+      paused = false;
       /**
        * Start the polling loop that checks for stuck tasks.
        * Safe to call multiple times (no-ops if already running).
@@ -82297,6 +82842,29 @@ var init_stuck_task_detector = __esm({
         }
         this.tracked.delete(taskId);
       }
+      /**
+       * Pause stuck detection checks while the engine is in a paused lifecycle.
+       * Active tracked sessions are preserved and refreshed on resume.
+       */
+      pause() {
+        if (this.paused) return;
+        this.paused = true;
+      }
+      /**
+       * Resume stuck detection checks and refresh tracked timestamps so the paused
+       * interval does not count as inactivity/no-progress time.
+       */
+      resume() {
+        if (!this.paused) return;
+        this.paused = false;
+        if (this.tracked.size === 0) return;
+        const now = Date.now();
+        for (const entry of this.tracked.values()) {
+          entry.lastActivity = now;
+          entry.lastProgressAt = now;
+          entry.activitySinceProgress = 0;
+        }
+      }
       /**
        * Check for stuck tasks immediately, outside the normal polling cycle.
        * Safe to call at any time — will no-op if no tasks are tracked or timeout is disabled.
@@ -82318,6 +82886,7 @@ var init_stuck_task_detector = __esm({
        */
       async checkStuckTasks() {
         if (this.tracked.size === 0) return;
+        if (this.paused) return;
         let settings;
         try {
           settings = await this.store.getSettings();
@@ -84733,6 +85302,282 @@ var init_plugin_runner = __esm({
   }
 });
 
+// ../engine/src/ephemeral-worker-manager.ts
+var TERMINAL_TASK_COLUMNS, EphemeralWorkerManager;
+var init_ephemeral_worker_manager = __esm({
+  "../engine/src/ephemeral-worker-manager.ts"() {
+    "use strict";
+    init_src();
+    TERMINAL_TASK_COLUMNS = /* @__PURE__ */ new Set(["done", "archived"]);
+    EphemeralWorkerManager = class {
+      agentStore;
+      taskStore;
+      log;
+      isDeletionPendingExternal;
+      /** taskId → owner. In-memory only; on-disk fallback covers restart gaps. */
+      taskAgentMap = /* @__PURE__ */ new Map();
+      /** agentIds with in-flight delete; prevents racing parallel cleanup paths. */
+      pendingDeletions = /* @__PURE__ */ new Set();
+      stateChangeListener;
+      constructor(options) {
+        this.agentStore = options.agentStore;
+        this.taskStore = options.taskStore;
+        this.log = options.logger;
+        this.isDeletionPendingExternal = options.isDeletionPendingExternal ?? (() => false);
+      }
+      // ── public surface ───────────────────────────────────────────────────────
+      /**
+       * Establish ownership for a task that just started executing.
+       * - If the task carries an `assignedAgentId` pointing at a durable agent,
+       *   bind that agent to the task and flip it through active → running.
+       * - Otherwise spawn (or reclaim) an ephemeral `executor-${task.id}` worker.
+       *
+       * Cross-restart safe: looks up an existing ephemeral by name before
+       * creating a new one.
+       */
+      async onTaskStart(task) {
+        try {
+          const assignedAgentId = task.assignedAgentId;
+          if (assignedAgentId) {
+            const assignedAgent = await this.agentStore.getAgent(assignedAgentId);
+            if (assignedAgent && !isEphemeralAgent(assignedAgent)) {
+              this.taskAgentMap.set(task.id, { agentId: assignedAgent.id, ephemeral: false });
+              await this.agentStore.syncExecutionTaskLink(assignedAgent.id, task.id);
+              const currentState = assignedAgent.state;
+              if (currentState !== "running") {
+                if (currentState !== "active") {
+                  await this.agentStore.updateAgentState(assignedAgent.id, "active");
+                }
+                await this.agentStore.updateAgentState(assignedAgent.id, "running");
+              }
+              return { agentId: assignedAgent.id, ephemeral: false };
+            }
+          }
+          const cached = this.taskAgentMap.get(task.id);
+          if (cached) {
+            this.log.warn(`Skipping task-worker creation for ${task.id}: task already has execution owner`);
+            return cached;
+          }
+          const existing = await this.lookupExistingByName(`executor-${task.id}`);
+          if (existing) {
+            if (existing.taskId === task.id) {
+              this.taskAgentMap.set(task.id, { agentId: existing.id, ephemeral: true });
+              this.log.log(`Reusing existing ephemeral worker ${existing.id} for task ${task.id} after restart`);
+              return { agentId: existing.id, ephemeral: true };
+            }
+            try {
+              await this.agentStore.deleteAgent(existing.id);
+              this.log.log(`Deleted stale ephemeral worker ${existing.id} for task ${task.id} before respawn`);
+            } catch (delErr) {
+              this.log.warn(`Failed to delete stale ephemeral worker ${existing.id} for ${task.id}:`, delErr);
+            }
+          }
+          const agent = await this.agentStore.createAgent({
+            name: `executor-${task.id}`,
+            role: "executor",
+            metadata: {
+              agentKind: "task-worker",
+              taskWorker: true,
+              managedBy: "task-executor"
+            },
+            runtimeConfig: { enabled: false }
+          });
+          this.taskAgentMap.set(task.id, { agentId: agent.id, ephemeral: true });
+          await this.agentStore.assignTask(agent.id, task.id);
+          await this.agentStore.updateAgentState(agent.id, "active");
+          await this.agentStore.updateAgentState(agent.id, "running");
+          return { agentId: agent.id, ephemeral: true };
+        } catch (err) {
+          this.log.warn(`Failed to initialize execution owner for task ${task.id}:`, err);
+          return null;
+        }
+      }
+      /**
+       * Tear down ownership after a task completes or errors.
+       * Final state for durable agents matches the outcome (idle/error).
+       * Ephemeral workers are deleted regardless; if the in-memory owner is
+       * missing (e.g. restart between onStart and this callback), falls back
+       * to a name-based lookup so the worker still gets cleaned up.
+       */
+      async onTaskComplete(taskId) {
+        return this.finalize(taskId, "active", "completion");
+      }
+      async onTaskError(taskId) {
+        return this.finalize(taskId, "error", "error");
+      }
+      /**
+       * Listener for agent:stateChanged. Cleans up ephemerals that get halted
+       * out-of-band — e.g. by HeartbeatMonitor flipping them to paused/error
+       * outside the onComplete/onError callbacks.
+       *
+       * Returns the listener fn so the caller can detach it on shutdown.
+       */
+      attachStateChangeListener() {
+        if (this.stateChangeListener) return this.stateChangeListener;
+        const listener = (agentId, from, to) => {
+          if (to !== "paused" && to !== "error") return;
+          if (from === to) return;
+          if (this.pendingDeletions.has(agentId) || this.isDeletionPendingExternal(agentId)) return;
+          void (async () => {
+            try {
+              const agent = await this.agentStore.getAgent(agentId);
+              if (!agent) return;
+              const isWorkerLike = isEphemeralAgent(agent) || agent.metadata?.taskWorker === true || agent.metadata?.agentKind === "task-worker" || agent.metadata?.agentKind === "spawned";
+              if (!isWorkerLike) return;
+              await this.deleteEphemeralAgent(agentId, "halt-listener");
+            } catch (err) {
+              this.log.warn(`Failed to process halt event for agent ${agentId}: ${this.formatError(err)}`);
+            }
+          })();
+        };
+        this.stateChangeListener = listener;
+        this.agentStore.on("agent:stateChanged", listener);
+        return listener;
+      }
+      detachStateChangeListener() {
+        if (!this.stateChangeListener) return;
+        this.agentStore.off("agent:stateChanged", this.stateChangeListener);
+        this.stateChangeListener = void 0;
+      }
+      /**
+       * Startup sweep. Returns the count of zombies cleaned up. Best-effort —
+       * failures are logged and skipped so they never block runtime startup.
+       *
+       * Survivors after this pass: agents bound to a still-in-progress task.
+       * Anything else (no taskId, terminal task column, or halted state) is
+       * by definition a leak.
+       */
+      async reconcileOrphaned() {
+        let cleanedCount = 0;
+        try {
+          const allAgents = await this.agentStore.listAgents({ includeEphemeral: true });
+          for (const agent of allAgents) {
+            if (!isEphemeralAgent(agent)) continue;
+            if (!await this.shouldDeleteOnSweep(agent)) continue;
+            try {
+              await this.agentStore.deleteAgent(agent.id);
+              cleanedCount += 1;
+            } catch (err) {
+              if (this.isBenignDeleteRace(agent.id, err)) {
+                cleanedCount += 1;
+                continue;
+              }
+              this.log.warn(`Startup sweep failed to delete ephemeral agent ${agent.id}: ${this.formatError(err)}`);
+            }
+          }
+        } catch (err) {
+          this.log.warn(`Startup ephemeral sweep failed: ${this.formatError(err)}`);
+        }
+        if (cleanedCount > 0) {
+          this.log.log(`Startup ephemeral sweep cleaned ${cleanedCount} orphaned agent(s)`);
+        }
+        return cleanedCount;
+      }
+      /** Drop in-memory state. Call on runtime stop. */
+      reset() {
+        this.taskAgentMap.clear();
+        this.pendingDeletions.clear();
+      }
+      /** True if a delete is in flight; lets external callers avoid double-delete races. */
+      isDeletionPending(agentId) {
+        return this.pendingDeletions.has(agentId);
+      }
+      getOwner(taskId) {
+        return this.taskAgentMap.get(taskId);
+      }
+      // ── internals ────────────────────────────────────────────────────────────
+      async finalize(taskId, terminalState, reason) {
+        const owner = this.taskAgentMap.get(taskId) ?? await this.recoverOwnerFromDisk(taskId);
+        if (!owner) return;
+        const { agentId, ephemeral } = owner;
+        if (ephemeral) {
+          this.pendingDeletions.add(agentId);
+        }
+        try {
+          await this.agentStore.updateAgentState(agentId, terminalState);
+        } catch (err) {
+          this.log.warn(`Failed to update agent ${agentId} to ${terminalState} (${reason}): ${this.formatError(err)}`);
+        }
+        try {
+          await this.agentStore.syncExecutionTaskLink(agentId, void 0);
+        } catch (err) {
+          this.log.warn(`Failed to clear execution task link for agent ${agentId} on ${reason}: ${this.formatError(err)}`);
+        }
+        this.taskAgentMap.delete(taskId);
+        if (!ephemeral) return;
+        try {
+          await this.agentStore.deleteAgent(agentId);
+        } catch (err) {
+          if (this.isBenignDeleteRace(agentId, err)) return;
+          this.log.warn(`Failed to delete agent ${agentId} after ${reason}: ${this.formatError(err)}`);
+        } finally {
+          this.pendingDeletions.delete(agentId);
+        }
+      }
+      /**
+       * Look up the ephemeral worker on disk when the in-memory map has no
+       * record. Covers the cross-restart case where onComplete fires in a
+       * different process session than the onStart that created the worker.
+       */
+      async recoverOwnerFromDisk(taskId) {
+        try {
+          const candidate = await this.lookupExistingByName(`executor-${taskId}`);
+          if (candidate) {
+            this.log.log(`Recovered ephemeral owner ${candidate.id} for task ${taskId} from disk (cross-restart)`);
+            return { agentId: candidate.id, ephemeral: true };
+          }
+        } catch (err) {
+          this.log.warn(`Cross-restart owner lookup failed for task ${taskId}: ${this.formatError(err)}`);
+        }
+        return null;
+      }
+      async lookupExistingByName(name) {
+        try {
+          const found = await this.agentStore.findAgentByName(name);
+          if (found && isEphemeralAgent(found)) return found;
+          return null;
+        } catch (err) {
+          this.log.warn(`findAgentByName(${name}) failed: ${this.formatError(err)}`);
+          return null;
+        }
+      }
+      async shouldDeleteOnSweep(agent) {
+        if (agent.state === "paused" || agent.state === "error") return true;
+        if (!agent.taskId) return true;
+        try {
+          const task = await this.taskStore.getTask(agent.taskId);
+          if (!task) return true;
+          if (TERMINAL_TASK_COLUMNS.has(task.column)) return true;
+          return task.column !== "in-progress";
+        } catch {
+          return true;
+        }
+      }
+      async deleteEphemeralAgent(agentId, reason) {
+        if (this.pendingDeletions.has(agentId)) return;
+        this.pendingDeletions.add(agentId);
+        try {
+          await this.agentStore.deleteAgent(agentId);
+        } catch (err) {
+          if (this.isBenignDeleteRace(agentId, err)) return;
+          this.log.warn(`Failed to delete ephemeral agent ${agentId} (${reason}): ${this.formatError(err)}`);
+        } finally {
+          this.pendingDeletions.delete(agentId);
+        }
+      }
+      isBenignDeleteRace(agentId, err) {
+        const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+        if (msg.includes("already deleted") || msg.includes("already removed")) return true;
+        if (msg.includes(`agent ${agentId.toLowerCase()} not found`)) return true;
+        return false;
+      }
+      formatError(err) {
+        return err instanceof Error ? err.message : String(err);
+      }
+    };
+  }
+});
+
 // ../engine/src/runtimes/in-process-runtime.ts
 import { EventEmitter as EventEmitter19 } from "node:events";
 var InProcessRuntime;
@@ -84755,6 +85600,7 @@ var init_in_process_runtime = __esm({
     init_mission_autopilot();
     init_mission_execution_loop();
     init_triage();
+    init_ephemeral_worker_manager();
     InProcessRuntime = class extends EventEmitter19 {
       /**
        * @param config - Runtime configuration
@@ -84779,8 +85625,12 @@ var init_in_process_runtime = __esm({
       agentStore;
       heartbeatMonitor;
       triggerScheduler;
-      /** Maps task IDs to execution owner metadata for lifecycle tracking */
-      taskAgentMap = /* @__PURE__ */ new Map();
+      /**
+       * Coordinates the ephemeral task-worker lifecycle (spawn dedup, finalize,
+       * halt-listener cleanup, startup sweep). See `ephemeral-worker-manager.ts`.
+       * Created once the AgentStore is available; guard call sites with `?`.
+       */
+      workerManager;
       lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
       pluginRunner;
       pluginStore;
@@ -84793,10 +85643,6 @@ var init_in_process_runtime = __esm({
       triageProcessor;
       messageStore;
       concurrencyChangedListener;
-      /** Set of agent IDs with in-flight ephemeral cleanup (prevents duplicate deletion) */
-      pendingEphemeralDeletions = /* @__PURE__ */ new Set();
-      /** Listener for agent:stateChanged events to clean up terminated ephemeral agents */
-      ephemeralTerminationListener;
       /**
        * Optional callback the runtime forwards to SelfHealingManager so that
        * stale-merge recovery can re-enqueue tasks immediately. Set by ProjectEngine
@@ -84826,7 +85672,7 @@ var init_in_process_runtime = __esm({
         runtimeLog.log(`Starting InProcessRuntime for project ${this.config.projectId}`);
         try {
           const {
-            TaskStore: TaskStore2,
+            TaskStore: TaskStore3,
             PluginStore: PluginStoreClass,
             PluginLoader: PluginLoaderClass,
             MessageStore: MessageStoreClass
@@ -84835,7 +85681,7 @@ var init_in_process_runtime = __esm({
             this.taskStore = this.config.externalTaskStore;
             runtimeLog.log(`TaskStore provided externally for project ${this.config.projectId}`);
           } else {
-            this.taskStore = new TaskStore2(this.config.workingDirectory);
+            this.taskStore = new TaskStore3(this.config.workingDirectory);
             await this.taskStore.init();
             runtimeLog.log(`TaskStore initialized for project ${this.config.projectId}`);
           }
@@ -85004,84 +85850,13 @@ var init_in_process_runtime = __esm({
             onStart: (task, worktreePath) => {
               this.recordActivity();
               runtimeLog.log(`Started executing task ${task.id} in ${worktreePath}`);
-              if (!this.agentStore) return;
-              void (async () => {
-                try {
-                  const assignedAgentId = task.assignedAgentId;
-                  if (assignedAgentId) {
-                    const assignedAgent = await this.agentStore.getAgent(assignedAgentId);
-                    if (assignedAgent && !isEphemeralAgent(assignedAgent)) {
-                      this.taskAgentMap.set(task.id, { agentId: assignedAgent.id, ephemeral: false });
-                      await this.agentStore.syncExecutionTaskLink(assignedAgent.id, task.id);
-                      const currentState = assignedAgent.state;
-                      if (currentState !== "running") {
-                        if (currentState !== "active") {
-                          await this.agentStore.updateAgentState(assignedAgent.id, "active");
-                        }
-                        await this.agentStore.updateAgentState(assignedAgent.id, "running");
-                      }
-                      return;
-                    }
-                  }
-                  if (this.taskAgentMap.has(task.id)) {
-                    runtimeLog.warn(`Skipping task-worker creation for ${task.id}: task already has execution owner`);
-                    return;
-                  }
-                  const agent = await this.agentStore.createAgent({
-                    name: `executor-${task.id}`,
-                    role: "executor",
-                    metadata: {
-                      agentKind: "task-worker",
-                      taskWorker: true,
-                      managedBy: "task-executor"
-                    },
-                    runtimeConfig: {
-                      enabled: false
-                    }
-                  });
-                  this.taskAgentMap.set(task.id, { agentId: agent.id, ephemeral: true });
-                  await this.agentStore.assignTask(agent.id, task.id);
-                  await this.agentStore.updateAgentState(agent.id, "active");
-                  await this.agentStore.updateAgentState(agent.id, "running");
-                } catch (err) {
-                  runtimeLog.warn(`Failed to initialize execution owner for task ${task.id}:`, err);
-                }
-              })();
+              void this.workerManager?.onTaskStart(task);
             },
             onComplete: (task) => {
               this.recordActivity();
               runtimeLog.log(`Completed task ${task.id}`);
               this.recordTaskCompletion(task.id, true);
-              const owner = this.taskAgentMap.get(task.id);
-              if (owner && this.agentStore) {
-                const { agentId, ephemeral } = owner;
-                if (ephemeral) {
-                  this.pendingEphemeralDeletions.add(agentId);
-                }
-                void this.agentStore.updateAgentState(agentId, "terminated").catch((err) => {
-                  const msg = err instanceof Error ? err.message : String(err);
-                  runtimeLog.warn(`Failed to update agent ${agentId} state to terminated (completion): ${msg}`);
-                });
-                void this.agentStore.syncExecutionTaskLink(agentId, void 0).catch((err) => {
-                  const msg = err instanceof Error ? err.message : String(err);
-                  runtimeLog.warn(`Failed to clear execution task link for agent ${agentId} on completion: ${msg}`);
-                });
-                this.taskAgentMap.delete(task.id);
-                if (!ephemeral) return;
-                void (async () => {
-                  try {
-                    await this.agentStore?.deleteAgent(agentId);
-                  } catch (err) {
-                    if (this.isBenignEphemeralDeleteRaceError(agentId, err)) {
-                      return;
-                    }
-                    const msg = err instanceof Error ? err.message : String(err);
-                    runtimeLog.warn(`Failed to delete agent ${agentId} after completion: ${msg}`);
-                  } finally {
-                    this.pendingEphemeralDeletions.delete(agentId);
-                  }
-                })();
-              }
+              void this.workerManager?.onTaskComplete(task.id);
             },
             onError: (task, error) => {
               this.recordActivity();
@@ -85099,36 +85874,7 @@ var init_in_process_runtime = __esm({
                   }
                 })();
               }
-              const owner = this.taskAgentMap.get(task.id);
-              if (owner && this.agentStore) {
-                const { agentId, ephemeral } = owner;
-                if (ephemeral) {
-                  this.pendingEphemeralDeletions.add(agentId);
-                }
-                void this.agentStore.updateAgentState(agentId, "terminated").catch((err) => {
-                  const msg = err instanceof Error ? err.message : String(err);
-                  runtimeLog.warn(`Failed to update agent ${agentId} state to terminated (error): ${msg}`);
-                });
-                void this.agentStore.syncExecutionTaskLink(agentId, void 0).catch((err) => {
-                  const msg = err instanceof Error ? err.message : String(err);
-                  runtimeLog.warn(`Failed to clear execution task link for agent ${agentId} on error: ${msg}`);
-                });
-                this.taskAgentMap.delete(task.id);
-                if (!ephemeral) return;
-                void (async () => {
-                  try {
-                    await this.agentStore?.deleteAgent(agentId);
-                  } catch (err) {
-                    if (this.isBenignEphemeralDeleteRaceError(agentId, err)) {
-                      return;
-                    }
-                    const msg = err instanceof Error ? err.message : String(err);
-                    runtimeLog.warn(`Failed to delete agent ${agentId} after error: ${msg}`);
-                  } finally {
-                    this.pendingEphemeralDeletions.delete(agentId);
-                  }
-                })();
-              }
+              void this.workerManager?.onTaskError(task.id);
             }
           };
           this.executor = new TaskExecutor(
@@ -85155,6 +85901,13 @@ var init_in_process_runtime = __esm({
               },
               onTerminated: (agentId, reason) => {
                 runtimeLog.warn(`Agent ${agentId} terminated (unresponsive): ${reason}`);
+              },
+              onRunCompleted: (agentId) => {
+                if (this.executor) {
+                  void this.executor.resumeTaskForAgent(agentId).catch((err) => {
+                    runtimeLog.warn(`resumeTaskForAgent failed for ${agentId}: ${err instanceof Error ? err.message : String(err)}`);
+                  });
+                }
               }
             });
             this.heartbeatMonitor.start();
@@ -85174,83 +85927,24 @@ var init_in_process_runtime = __esm({
                   contextSnapshot: { ...context }
                 });
               },
-              this.taskStore
+              this.taskStore,
+              { isTaskExecuting: (taskId) => this.executor.getExecutingTaskIds().has(taskId) }
             );
             this.triggerScheduler.start();
             const isHeartbeatEnabledAgent = (agent) => !isEphemeralAgent(agent) && agent.runtimeConfig?.enabled !== false;
             const isTickableHeartbeatState = (state) => state === "active" || state === "running" || state === "idle";
             const isTimerManagedAgent = (agent) => isHeartbeatEnabledAgent(agent) && isTickableHeartbeatState(agent.state);
-            this.ephemeralTerminationListener = (agentId, from, to) => {
-              if (to !== "terminated") return;
-              if (from === "terminated") return;
-              if (this.pendingEphemeralDeletions.has(agentId) || this.executor?.isEphemeralDeletionPending(agentId)) return;
-              void (async () => {
-                try {
-                  const agent = await this.agentStore?.getAgent(agentId);
-                  if (!agent) return;
-                  if (!isEphemeralAgent(agent)) return;
-                  this.pendingEphemeralDeletions.add(agentId);
-                  try {
-                    await this.agentStore?.deleteAgent(agentId);
-                  } catch (err) {
-                    if (this.isBenignEphemeralDeleteRaceError(agentId, err)) {
-                      return;
-                    }
-                    const msg = err instanceof Error ? err.message : String(err);
-                    runtimeLog.warn(`Failed to delete ephemeral agent ${agentId} after termination: ${msg}`);
-                  } finally {
-                    this.pendingEphemeralDeletions.delete(agentId);
-                  }
-                } catch (err) {
-                  const msg = err instanceof Error ? err.message : String(err);
-                  runtimeLog.warn(`Failed to process termination event for agent ${agentId}: ${msg}`);
-                }
-              })();
-            };
-            this.agentStore.on("agent:stateChanged", this.ephemeralTerminationListener);
-            try {
-              const allAgents = await this.agentStore.listAgents({ includeEphemeral: true });
-              let cleanedCount = 0;
-              for (const agent of allAgents) {
-                if (!isEphemeralAgent(agent)) continue;
-                let shouldDelete = agent.state === "terminated" || agent.state === "error";
-                if (!shouldDelete && agent.taskId) {
-                  try {
-                    const task = await this.taskStore.getTask(agent.taskId);
-                    if (!task || task.column !== "in-progress") {
-                      shouldDelete = true;
-                    }
-                  } catch {
-                    shouldDelete = true;
-                  }
-                }
-                if (!shouldDelete) continue;
-                try {
-                  if (agent.state !== "terminated") {
-                    await this.agentStore.updateAgentState(agent.id, "terminated");
-                  }
-                } catch (err) {
-                  const msg = err instanceof Error ? err.message : String(err);
-                  runtimeLog.warn(`Startup sweep failed to set ephemeral agent ${agent.id} terminated: ${msg}`);
-                }
-                try {
-                  await this.agentStore.deleteAgent(agent.id);
-                  cleanedCount += 1;
-                } catch (err) {
-                  if (this.isBenignEphemeralDeleteRaceError(agent.id, err)) {
-                    cleanedCount += 1;
-                    continue;
-                  }
-                  const msg = err instanceof Error ? err.message : String(err);
-                  runtimeLog.warn(`Startup sweep failed to delete ephemeral agent ${agent.id}: ${msg}`);
-                }
-              }
-              if (cleanedCount > 0) {
-                runtimeLog.log(`Startup ephemeral sweep cleaned ${cleanedCount} orphaned agent(s)`);
-              }
-            } catch (err) {
-              const msg = err instanceof Error ? err.message : String(err);
-              runtimeLog.warn(`Startup ephemeral sweep failed (continuing): ${msg}`);
+            if (this.agentStore && !this.workerManager) {
+              this.workerManager = new EphemeralWorkerManager({
+                agentStore: this.agentStore,
+                taskStore: this.taskStore,
+                logger: runtimeLog,
+                isDeletionPendingExternal: (agentId) => this.executor?.isEphemeralDeletionPending(agentId) ?? false
+              });
+            }
+            if (this.workerManager) {
+              this.workerManager.attachStateChangeListener();
+              await this.workerManager.reconcileOrphaned();
             }
             try {
               const agents = await this.agentStore.listAgents();
@@ -85421,12 +86115,8 @@ var init_in_process_runtime = __esm({
             this.routineScheduler.stop();
             runtimeLog.log("RoutineScheduler stopped");
           }
-          if (this.ephemeralTerminationListener && this.agentStore) {
-            this.agentStore.off("agent:stateChanged", this.ephemeralTerminationListener);
-            this.ephemeralTerminationListener = void 0;
-            runtimeLog.log("AgentStore agent:stateChanged listener removed");
-          }
-          this.pendingEphemeralDeletions.clear();
+          this.workerManager?.detachStateChangeListener();
+          this.workerManager?.reset();
           this.executor?.disposeEphemeralTimers();
           if (this.triggerScheduler) {
             this.triggerScheduler.stop();
@@ -85722,21 +86412,6 @@ var init_in_process_runtime = __esm({
         });
         runtimeLog.log("Event forwarding setup complete");
       }
-      /**
-       * Returns true when an ephemeral delete failure is expected due to cleanup races
-       * (for example the agent was already removed by a parallel cleanup path).
-       */
-      isBenignEphemeralDeleteRaceError(agentId, err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        const normalized = msg.toLowerCase();
-        if (normalized.includes("already deleted") || normalized.includes("already removed")) {
-          return true;
-        }
-        if (normalized.includes(`agent ${agentId.toLowerCase()} not found`)) {
-          return true;
-        }
-        return /^agent\s+.+\s+not found$/i.test(msg.trim());
-      }
       /**
        * Update status and emit health-changed event.
        */
@@ -89469,6 +90144,37 @@ ${detail}`
         }
       }
       wireSettingsListeners(store) {
+        const applyDetectorPauseLifecycle = (paused, source) => {
+          try {
+            const detector = this.runtime.stuckTaskDetector;
+            if (paused) {
+              detector?.pause?.();
+            } else {
+              detector?.resume?.();
+            }
+          } catch (err) {
+            runtimeLog.warn(
+              `${source}: stuck detector ${paused ? "pause" : "resume"} hook failed: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        };
+        const onPauseLifecycleTransition = ({
+          settings: s,
+          previous: prev
+        }) => {
+          const wasPaused = prev.globalPause || prev.enginePaused;
+          const isPaused = s.globalPause || s.enginePaused;
+          if (!wasPaused && isPaused) {
+            const source = s.globalPause && !prev.globalPause ? "Global pause" : "Engine pause";
+            applyDetectorPauseLifecycle(true, source);
+          }
+          if (wasPaused && !isPaused) {
+            const source = prev.globalPause && !s.globalPause ? "Global unpause" : "Engine unpause";
+            applyDetectorPauseLifecycle(false, source);
+          }
+        };
+        store.on("settings:updated", onPauseLifecycleTransition);
+        this.settingsHandlers.push(onPauseLifecycleTransition);
         const onGlobalPause = ({ settings, previous }) => {
           if (settings.globalPause && !previous.globalPause) {
             if (this.mergeAbortController) {
@@ -100000,12 +100706,14 @@ var init_register_settings_sync_inbound_routes = __esm({
 });
 
 // ../dashboard/src/routes/register-agent-core-routes.ts
+var MAX_AVATAR_BYTES;
 var init_register_agent_core_routes = __esm({
   "../dashboard/src/routes/register-agent-core-routes.ts"() {
     "use strict";
     init_src();
     init_api_error();
     init_src2();
+    MAX_AVATAR_BYTES = 2 * 1024 * 1024;
   }
 });
 
@@ -101038,6 +101746,7 @@ import { Router as Router3 } from "express";
 var init_mission_routes = __esm({
   "../dashboard/src/mission-routes.ts"() {
     "use strict";
+    init_src();
     init_project_store_resolver();
     init_src();
     init_sse_buffer();
@@ -106920,11 +107629,69 @@ var INSIGHT_CATEGORIES = [
 var INSIGHT_STATUSES = ["generated", "confirmed", "stale", "dismissed", "archived"];
 var INSIGHT_RUN_STATUSES = ["pending", "running", "completed", "failed", "cancelled"];
 var INSIGHT_RUN_TRIGGERS = ["schedule", "manual", "task_completion", "merge_event", "api"];
+function getTaskSourceAgentLabel(task) {
+  const metadataAgentName = task.sourceMetadata?.agentName;
+  if (typeof metadataAgentName === "string" && metadataAgentName.trim().length > 0) {
+    return metadataAgentName.trim();
+  }
+  if (typeof task.sourceAgentId === "string" && task.sourceAgentId.trim().length > 0) {
+    return task.sourceAgentId.trim();
+  }
+  return void 0;
+}
+function getTaskSourceLabel(task) {
+  switch (task.sourceType) {
+    case "dashboard_ui":
+      return "Dashboard";
+    case "quick_chat":
+      return "Quick Chat";
+    case "chat_session":
+      return "Chat Session";
+    case "agent_heartbeat": {
+      const sourceAgent = getTaskSourceAgentLabel(task);
+      return sourceAgent ? `Agent (${sourceAgent})` : "Agent";
+    }
+    case "automation": {
+      const sourceAgent = getTaskSourceAgentLabel(task);
+      return sourceAgent ? `Automation (${sourceAgent})` : "Automation";
+    }
+    case "cron":
+      return "Scheduled Task";
+    case "workflow_step":
+      return "Workflow Step";
+    case "github_import": {
+      const issueUrl = task.sourceMetadata?.issueUrl;
+      return typeof issueUrl === "string" && issueUrl.length > 0 ? `GitHub Import (${issueUrl})` : "GitHub Import";
+    }
+    case "research": {
+      const findingLabel = task.sourceMetadata?.findingLabel;
+      if (typeof findingLabel === "string" && findingLabel.length > 0) {
+        return `Research (${findingLabel})`;
+      }
+      const runId = task.sourceMetadata?.runId;
+      return typeof runId === "string" && runId.length > 0 ? `Research (${runId})` : "Research";
+    }
+    case "task_refine":
+      return task.sourceParentTaskId ? `Refinement of ${task.sourceParentTaskId}` : "Refinement";
+    case "task_duplicate":
+      return task.sourceParentTaskId ? `Duplicate of ${task.sourceParentTaskId}` : "Duplicate";
+    case "cli":
+      return "CLI";
+    case "api":
+      return "API";
+    case "recovery":
+      return "Recovery";
+    default:
+      return void 0;
+  }
+}
 function formatTaskLine(t) {
   const label = t.title || t.description.slice(0, 60) + (t.description.length > 60 ? "\u2026" : "");
+  const source = getTaskSourceLabel(t);
+  const sourceSuffix = source ? ` [via: ${source}]` : "";
   const deps = t.dependencies.length ? ` [deps: ${t.dependencies.join(", ")}]` : "";
   const paused = t.paused ? " (paused)" : "";
-  return `${t.id}  ${label}${deps}${paused}`;
+  return `${t.id}  ${label}${sourceSuffix}${deps}${paused}`;
 }
 async function getResearchAvailability(store) {
   const settings = await store.getSettings();
@@ -107260,6 +108027,10 @@ Column: triage
       if (task.dependencies.length) {
         lines.push(`Dependencies: ${task.dependencies.join(", ")}`);
       }
+      const sourceLabel = getTaskSourceLabel(task);
+      if (sourceLabel) {
+        lines.push(`Created via: ${sourceLabel}`);
+      }
       if (task.paused) lines.push("Status: PAUSED");
       lines.push("");
       if (task.steps.length > 0) {