@desplega.ai/agent-swarm 1.88.0 → 1.90.0

package/src/be/seed-skills/index.ts

@@ -11,6 +11,12 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import artifactsConfig from "../../../templates/skills/artifacts/config.json" with { type: "text" };
 import artifactsContent from "../../../templates/skills/artifacts/content.md" with { type: "text" };
+import attioInteractionConfig from "../../../templates/skills/attio-interaction/config.json" with {
+  type: "text",
+};
+import attioInteractionContent from "../../../templates/skills/attio-interaction/content.md" with {
+  type: "text",
+};
 import kvStorageConfig from "../../../templates/skills/kv-storage/config.json" with {
   type: "text",
 };
@@ -61,6 +67,7 @@ export type SeedSkill = {
 };
 
 const BUILT_IN_SKILL_SOURCES = [
+  { config: attioInteractionConfig, body: attioInteractionContent },
   { config: artifactsConfig, body: artifactsContent },
   { config: kvStorageConfig, body: kvStorageContent },
   { config: pagesConfig, body: pagesContent },

package/src/cli.tsx

@@ -255,6 +255,19 @@ const COMMAND_HELP: Record<
     options: "  -h, --help             Show this help",
     examples: [`  ${binName} artifact serve`, `  ${binName} artifact help`].join("\n"),
   },
+  x: {
+    usage: `${binName} x <target> [args]`,
+    description:
+      "Execute external command routes. Prototype target: composio routes HTTP requests to the Composio REST API using COMPOSIO_API_KEY.",
+    options: [
+      "  composio <method> <path>       Route to the Composio REST API",
+      "  -h, --help                     Show this help",
+    ].join("\n"),
+    examples: [
+      `  ${binName} x composio GET /tools`,
+      `  ${binName} x composio POST /tools/execute/GITHUB_CREATE_AN_ISSUE --body '{"arguments":{}}'`,
+    ].join("\n"),
+  },
   scripts: {
     usage: `${binName} scripts reembed`,
     description: "Maintenance commands for reusable swarm scripts.",
@@ -369,6 +382,7 @@ function printHelp(command?: string) {
     ["claude", "Run Claude CLI"],
     ["hook", "Handle Claude Code hook events (stdin)"],
     ["artifact", "Manage agent artifacts"],
+    ["x", "Execute external command routes"],
     ["scripts", "Reusable scripts maintenance"],
     ["docs", "Open documentation (--open to launch in browser)"],
     ["codex-login", "Authenticate Codex via ChatGPT OAuth"],
@@ -612,6 +626,10 @@ if (args.showHelp || args.command === "help" || args.command === undefined) {
     port: args.port,
     key: args.key,
   });
+} else if (args.command === "x") {
+  const xArgs = process.argv.slice(process.argv.indexOf("x") + 1);
+  const { runXCommand } = await import("./commands/x");
+  await runXCommand(xArgs);
 } else if (args.command === "scripts") {
   const scriptsArgs = process.argv.slice(process.argv.indexOf("scripts") + 1);
   if (args.showHelp || scriptsArgs[0] !== "reembed") {

package/src/commands/runner.ts

@@ -126,14 +126,88 @@ async function readClaudeMd(clonePath: string, role: string): Promise<string | n
   return null;
 }
 
+export type SwarmAutostash = { ref: string; message: string };
+
+async function listSwarmAutostashes(clonePath: string, role: string): Promise<SwarmAutostash[]> {
+  try {
+    const result = await Bun.$`cd ${clonePath} && git stash list --format=%gd%x09%s`.quiet();
+    return result
+      .text()
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.includes("swarm-autostash"))
+      .flatMap((line) => {
+        const [ref, ...messageParts] = line.split("\t");
+        if (!ref) return [];
+        return [{ ref, message: messageParts.join("\t") || line }];
+      });
+  } catch (err) {
+    console.warn(
+      `[${role}] Could not inspect git stashes for ${clonePath}: ${scrubSecrets((err as Error).message)}`,
+    );
+    return [];
+  }
+}
+
+async function refreshExistingRepoForTask(
+  repoConfig: { name: string; clonePath: string; defaultBranch: string },
+  role: string,
+): Promise<string | null> {
+  const { name, clonePath, defaultBranch } = repoConfig;
+  const statusResult = await Bun.$`cd ${clonePath} && git status --porcelain`.quiet();
+  const statusOutput = statusResult.text().trim();
+  let stashMessage: string | null = null;
+
+  if (statusOutput !== "") {
+    stashMessage = `swarm-autostash ${defaultBranch} ${new Date().toISOString()}`;
+    try {
+      console.log(`[${role}] Auto-stashing pending work in ${name}: ${stashMessage}`);
+      await Bun.$`cd ${clonePath} && git stash push --include-untracked -m ${stashMessage}`.quiet();
+      console.log(`[${role}] Auto-stashed pending work in ${name}`);
+    } catch (err) {
+      const errorMsg = scrubSecrets((err as Error).message);
+      console.warn(`[${role}] Could not auto-stash ${name}, skipping pull: ${errorMsg}`);
+      return `The repo "${name}" at ${clonePath} has uncommitted changes, but auto-stash failed: ${errorMsg}. A git pull was skipped to avoid losing work.`;
+    }
+  }
+
+  try {
+    console.log(`[${role}] Refreshing ${name} from origin/${defaultBranch}...`);
+    const fetchSpec = `${defaultBranch}:refs/remotes/origin/${defaultBranch}`;
+    const remoteRef = `refs/remotes/origin/${defaultBranch}`;
+    await Bun.$`cd ${clonePath} && git fetch origin ${fetchSpec}`.quiet();
+    await Bun.$`cd ${clonePath} && git merge --no-edit --no-stat ${remoteRef}`.quiet();
+    console.log(`[${role}] Refreshed ${name}`);
+    return null;
+  } catch (err) {
+    const errorMsg = scrubSecrets((err as Error).message);
+    console.warn(`[${role}] Could not refresh ${name}: ${errorMsg}`);
+    try {
+      await Bun.$`cd ${clonePath} && git merge --abort`.quiet();
+    } catch {
+      // No merge in progress, or abort failed. The original refresh warning is
+      // the actionable signal; repo setup remains best-effort.
+    }
+    const stashNote = stashMessage
+      ? ` Pending work was preserved in git stash "${stashMessage}".`
+      : "";
+    return `The repo "${name}" at ${clonePath} could not be refreshed from origin/${defaultBranch}: ${errorMsg}.${stashNote}`;
+  }
+}
+
 /**
  * Ensure a repo is cloned and up-to-date for a task.
  * Returns { clonePath, claudeMd, warning }.
  */
-async function ensureRepoForTask(
+export async function ensureRepoForTask(
   repoConfig: { url: string; name: string; clonePath: string; defaultBranch: string },
   role: string,
-): Promise<{ clonePath: string; claudeMd: string | null; warning: string | null }> {
+): Promise<{
+  clonePath: string;
+  claudeMd: string | null;
+  warning: string | null;
+  autoStashes: SwarmAutostash[];
+}> {
   const { url, name, clonePath, defaultBranch } = repoConfig;
 
   try {
@@ -158,28 +232,20 @@ async function ensureRepoForTask(
       console.log(`[${role}] Cloned ${name}`);
     } else {
       console.log(`[${role}] Repo ${name} already cloned at ${clonePath}`);
-      const statusResult = await Bun.$`cd ${clonePath} && git status --porcelain`.quiet();
-      const statusOutput = statusResult.text().trim();
-
-      if (statusOutput === "") {
-        console.log(`[${role}] Pulling ${name} (${defaultBranch})...`);
-        await Bun.$`cd ${clonePath} && git pull origin ${defaultBranch} --ff-only`.quiet();
-        console.log(`[${role}] Pulled ${name}`);
-      } else {
-        console.warn(`[${role}] Repo ${name} has uncommitted changes, skipping pull`);
-        warning = `The repo "${name}" at ${clonePath} has uncommitted changes. A git pull was skipped to avoid losing work. You may need to commit or stash changes before pulling updates.`;
-      }
+      warning = await refreshExistingRepoForTask({ name, clonePath, defaultBranch }, role);
     }
 
     const claudeMd = await readClaudeMd(clonePath, role);
-    return { clonePath, claudeMd, warning };
+    const autoStashes = await listSwarmAutostashes(clonePath, role);
+    return { clonePath, claudeMd, warning, autoStashes };
   } catch (err) {
-    const errorMsg = (err as Error).message;
+    const errorMsg = scrubSecrets((err as Error).message);
     console.warn(`[${role}] Error setting up repo ${name}: ${errorMsg}`);
     const warning = `Failed to clone/setup repo "${name}" at ${clonePath}: ${errorMsg}. The repo may not be available. You may need to clone it manually.`;
     // Only return clonePath if the directory actually exists (clone may have failed)
     const cloneExists = existsSync(clonePath);
-    return { clonePath: cloneExists ? clonePath : "", claudeMd: null, warning };
+    const autoStashes = cloneExists ? await listSwarmAutostashes(clonePath, role) : [];
+    return { clonePath: cloneExists ? clonePath : "", claudeMd: null, warning, autoStashes };
   }
 }
 
@@ -1692,6 +1758,31 @@ async function cleanupActiveSessions(config: ApiConfig): Promise<void> {
   }
 }
 
+/** Reset orphaned in-progress tasks for this agent back to pending dispatch. */
+async function recoverOrphanedInProgressTasks(config: ApiConfig): Promise<number> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "X-Agent-ID": config.agentId,
+  };
+  if (config.apiKey) headers.Authorization = `Bearer ${config.apiKey}`;
+  try {
+    const response = await fetch(`${config.apiUrl}/api/active-sessions/recover-orphaned-tasks`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ agentId: config.agentId, minAgeSeconds: 60 }),
+    });
+    if (!response.ok) {
+      console.warn(`[runner] Failed to recover orphaned tasks: ${response.status}`);
+      return 0;
+    }
+    const data = (await response.json()) as { recovered?: number };
+    return data.recovered ?? 0;
+  } catch (error) {
+    console.warn(`[runner] Error recovering orphaned tasks: ${error}`);
+    return 0;
+  }
+}
+
 /** Trigger a heartbeat sweep via the API (lead startup self-check) */
 async function triggerHeartbeatSweep(config: ApiConfig): Promise<boolean> {
   try {
@@ -1743,7 +1834,7 @@ interface Trigger {
     text?: string;
   }>;
   cursorUpdates?: Array<{ channelId: string; ts: string }>; // Deferred cursor commits for channel_activity
-  requestedBy?: { name: string; email?: string };
+  requestedBy?: { name: string; email?: string; role?: string; notes?: string };
   // Phase 4 — budget_refused fields. The server emits this envelope from
   // /api/poll and MCP task-action accept when an admission gate refuses to
   // let the agent claim a task. Worker reads cause + reset/spend/budget for
@@ -1766,6 +1857,26 @@ interface PollOptions {
   since?: string; // Optional: for filtering finished tasks
 }
 
+type RequesterProfile = NonNullable<Trigger["requestedBy"]>;
+
+export async function buildRequesterProfilePrompt(
+  requestedBy: RequesterProfile | undefined,
+): Promise<string> {
+  if (!requestedBy?.role && !requestedBy?.notes) return "";
+
+  const notes = requestedBy.notes?.trim();
+  const notesSection = notes
+    ? `\nTheir stated notes for how you should respond and act:\n${notes}`
+    : "";
+  const result = await resolveTemplateAsync("task.requester.profile", {
+    requester_name: requestedBy.name,
+    requester_role_suffix: requestedBy.role ? ` (${requestedBy.role})` : "",
+    requester_notes_section: notesSection,
+  });
+
+  return result.skipped ? "" : result.text.trim();
+}
+
 /** Register agent via HTTP API */
 async function registerAgent(opts: {
   apiUrl: string;
@@ -3608,6 +3719,12 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   // Clean up any stale active sessions from previous runs (crash recovery)
   await cleanupActiveSessions(apiConfig);
   console.log(`[${role}] Cleaned up stale active sessions`);
+  const startupRecoveredOrphans = await recoverOrphanedInProgressTasks(apiConfig);
+  if (startupRecoveredOrphans > 0) {
+    console.log(
+      `[${role}] Recovered ${startupRecoveredOrphans} orphaned in-progress task(s) to pending`,
+    );
+  }
 
   // Fetch full agent profile to get soul/identity content
   try {
@@ -4084,7 +4201,10 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   // state persists across iterations.
   let consecutiveBudgetRefusals = 0;
 
-  // Track last finished task check for leads (to avoid re-processing)
+  // Throttle orphan recovery so it runs periodically while the worker is idle or under capacity.
+  let lastOrphanRecoveryAt = 0;
+  const ORPHAN_RECOVERY_INTERVAL_MS = 60_000;
+
   while (true) {
     // Ping server on each iteration to keep status updated
     await pingServer(apiConfig, role);
@@ -4180,6 +4300,16 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
 
     // Only poll if we have capacity
     if (state.activeTasks.size < state.maxConcurrent) {
+      if (Date.now() - lastOrphanRecoveryAt > ORPHAN_RECOVERY_INTERVAL_MS) {
+        lastOrphanRecoveryAt = Date.now();
+        const recoveredOrphans = await recoverOrphanedInProgressTasks(apiConfig);
+        if (recoveredOrphans > 0) {
+          console.log(
+            `[${role}] Recovered ${recoveredOrphans} orphaned in-progress task(s) to pending`,
+          );
+        }
+      }
+
       console.log(
         `[${role}] Polling for triggers (${state.activeTasks.size}/${state.maxConcurrent} active)...`,
       );
@@ -4419,10 +4549,11 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
 
         // Rebuild system prompt with per-task repo context
         const taskBasePrompt = await buildSystemPrompt();
-        const taskSystemPrompt =
-          (additionalSystemPrompt
-            ? `${taskBasePrompt}\n\n${additionalSystemPrompt}`
-            : taskBasePrompt) + cwdWarning;
+        const requesterProfilePrompt = await buildRequesterProfilePrompt(trigger.requestedBy);
+        const taskPromptParts = [taskBasePrompt, requesterProfilePrompt, additionalSystemPrompt]
+          .filter((part): part is string => Boolean(part))
+          .join("\n\n");
+        const taskSystemPrompt = taskPromptParts + cwdWarning;
 
         iteration++;
         const timestamp = new Date().toISOString().replace(/[:.]/g, "-");

package/src/commands/x.ts

@@ -0,0 +1,118 @@
+import { scrubSecrets } from "../utils/secret-scrubber";
+import {
+  DEFAULT_COMPOSIO_BASE_URL,
+  executeComposioRequest,
+  formatComposioResultForCli,
+  parseComposioArgs,
+} from "../x/composio";
+
+interface XCommandDeps {
+  env?: Record<string, string | undefined>;
+  error?: (message: string) => void;
+  exit?: (code: number) => void;
+  fetch?: typeof fetch;
+  log?: (message: string) => void;
+}
+
+export { parseComposioArgs } from "../x/composio";
+
+export async function runXCommand(argv: string[], deps: XCommandDeps = {}): Promise<void> {
+  const [target, ...rest] = argv;
+  const log = deps.log ?? console.log;
+  const error = deps.error ?? console.error;
+  const exit = deps.exit ?? process.exit;
+
+  if (!target || target === "help" || target === "-h" || target === "--help") {
+    printXHelp(log);
+    return;
+  }
+
+  switch (target) {
+    case "composio":
+      await runComposioCommand(rest, deps);
+      return;
+    default:
+      error(`Unknown x target: ${target}`);
+      printXHelp(error);
+      exit(1);
+  }
+}
+
+export async function runComposioCommand(argv: string[], deps: XCommandDeps = {}): Promise<void> {
+  const log = deps.log ?? console.log;
+  const error = deps.error ?? console.error;
+  const exit = deps.exit ?? process.exit;
+  const env = deps.env ?? process.env;
+
+  if (argv.length === 0 || argv[0] === "help" || argv[0] === "-h" || argv[0] === "--help") {
+    printComposioHelp(log);
+    return;
+  }
+
+  let parsed: ReturnType<typeof parseComposioArgs>;
+  try {
+    parsed = parseComposioArgs(argv, env);
+  } catch (err) {
+    error(`composio: ${scrubSecrets(errorMessage(err))}`);
+    printComposioHelp(error);
+    exit(1);
+    return;
+  }
+
+  const result = await executeComposioRequest(parsed, { env, fetch: deps.fetch });
+
+  if (!result.ok) {
+    if (result.status > 0) error(`composio: HTTP ${result.status} ${result.statusText}`.trim());
+    else error(`composio: ${result.error ?? result.statusText}`);
+    if (result.formattedBody) error(result.formattedBody);
+    exit(1);
+    return;
+  }
+
+  log(formatComposioResultForCli(result));
+}
+
+function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+function printXHelp(log: (message: string) => void): void {
+  log(`Usage: agent-swarm x <target> [args]
+
+Targets:
+  composio    Route a request to the Composio REST API
+
+Examples:
+  agent-swarm x composio GET /tools
+  agent-swarm x composio POST /tools/execute/GITHUB_CREATE_AN_ISSUE --body '{"arguments":{}}'`);
+}
+
+function printComposioHelp(log: (message: string) => void): void {
+  log(`Usage: agent-swarm x composio <method> <path> [options]
+
+Routes an HTTP request to the Composio REST API.
+
+Arguments:
+  <method>              GET, POST, PUT, PATCH, DELETE, or HEAD
+  <path>                API path relative to ${DEFAULT_COMPOSIO_BASE_URL}
+
+Options:
+  --body, --data <json> JSON request body
+  -q, --query k=v       Append a query parameter (repeatable)
+  -H, --header k=v      Add a header (repeatable)
+  --base-url <url>      Override base URL (default: COMPOSIO_BASE_URL or v3.1 API)
+  --org                 Use COMPOSIO_ORG_API_KEY and x-org-api-key
+  --raw                 Print response text without JSON pretty formatting
+  -h, --help            Show this help
+
+Environment:
+  COMPOSIO_API_KEY      Project API key for x-api-key auth
+  COMPOSIO_ORG_API_KEY  Optional organization key for --org
+  COMPOSIO_BASE_URL     Optional API base URL override
+
+Examples:
+  agent-swarm x composio GET /tools
+  agent-swarm x composio GET /tools --query limit=10
+  agent-swarm x composio POST /tool_router/session --body '{"user_id":"swarm"}'
+  agent-swarm x composio POST /tools/execute/GITHUB_CREATE_AN_ISSUE --body '{"arguments":{}}'`);
+}

package/src/github/handlers.ts

@@ -1,4 +1,4 @@
-import { failTask, findTaskByVcs, getAllAgents, incrKv, upsertKv } from "../be/db";
+import { failTask, findTaskByVcs, getAllAgents, getSwarmConfigs, incrKv, upsertKv } from "../be/db";
 import { findUserByExternalId } from "../be/users";
 import { resolveTemplate } from "../prompts/resolver";
 import { githubContextKey } from "../tasks/context-key";
@@ -46,6 +46,19 @@ function buildGithubContextKey(
   }
 }
 
+/**
+ * Runtime-config guards for cancel-on-unassign and cancel-on-review-request-removed.
+ * Absent key / any value other than "false" → true (cancel, current behavior).
+ * Value "false" → false (skip cancel, leave task untouched).
+ */
+function cancelFlagEnabled(key: string): boolean {
+  const row = getSwarmConfigs({ scope: "global", key })[0];
+  return row?.value !== "false";
+}
+const cancelOnUnassignEnabled = () => cancelFlagEnabled("github.cancelOnUnassign");
+const cancelOnReviewRequestRemovedEnabled = () =>
+  cancelFlagEnabled("github.cancelOnReviewRequestRemoved");
+
 /**
  * Get review state emoji and label
  */
@@ -278,6 +291,14 @@ export async function handlePullRequest(
       return { created: false };
     }
 
+    // Config gate: skip cancel if disabled
+    if (!cancelOnUnassignEnabled()) {
+      console.log(
+        `[GitHub] unassign cancel disabled by config — leaving task untouched (PR #${pr.number})`,
+      );
+      return { created: false };
+    }
+
     // Find the related task
     const task = findTaskByVcs(repository.full_name, pr.number);
     if (!task) {
@@ -378,6 +399,14 @@ export async function handlePullRequest(
       return { created: false };
     }
 
+    // Config gate: skip cancel if disabled
+    if (!cancelOnReviewRequestRemovedEnabled()) {
+      console.log(
+        `[GitHub] review-request-removed cancel disabled by config — leaving task untouched (PR #${pr.number})`,
+      );
+      return { created: false };
+    }
+
     // Find the related task
     const task = findTaskByVcs(repository.full_name, pr.number);
     if (!task) {
@@ -533,6 +562,7 @@ export async function handlePullRequest(
     vcsUrl: pr.html_url,
     vcsInstallationId: installation?.id,
     contextKey: buildGithubContextKey(repository.full_name, "pr", pr.number),
+    requestedByUserId,
   });
 
   if (lead) {
@@ -638,6 +668,14 @@ export async function handleIssue(
       return { created: false };
     }
 
+    // Config gate: skip cancel if disabled
+    if (!cancelOnUnassignEnabled()) {
+      console.log(
+        `[GitHub] unassign cancel disabled by config — leaving task untouched (issue #${issue.number})`,
+      );
+      return { created: false };
+    }
+
     // Find the related task
     const task = findTaskByVcs(repository.full_name, issue.number);
     if (!task) {
@@ -771,6 +809,7 @@ export async function handleIssue(
     vcsUrl: issue.html_url,
     vcsInstallationId: installation?.id,
     contextKey: buildGithubContextKey(repository.full_name, "issue", issue.number),
+    requestedByUserId,
   });
 
   if (lead) {

package/src/heartbeat/heartbeat.ts

@@ -1,5 +1,6 @@
 import {
-  claimTask,
+  assignUnassignedTaskPending,
+  backfillSupersedeTaskResumeTaskId,
   cleanupStaleSessions,
   createTaskExtended,
   deleteActiveSession,
@@ -25,7 +26,7 @@ import {
   updateAgentStatus,
 } from "../be/db";
 import { resolveTemplate } from "../prompts/resolver";
-import { createResumeFollowUp } from "../tasks/worker-follow-up";
+import { createResumeFollowUp, getNextResumeGeneration } from "../tasks/worker-follow-up";
 import type { AgentTask } from "../types";
 import { getExecutorRegistry } from "../workflows";
 import { recoverIncompleteRuns } from "../workflows/recovery";
@@ -60,6 +61,11 @@ const STALE_CLEANUP_THRESHOLD_MINUTES = Number(process.env.HEARTBEAT_STALE_CLEAN
 /** Max pool tasks to auto-assign per sweep */
 const MAX_AUTO_ASSIGN_PER_SWEEP = Number(process.env.HEARTBEAT_MAX_AUTO_ASSIGN) || 5;
 
+/** Max crash-recovery resume generations before failing for lead triage */
+export const MAX_RESUME_GENERATIONS = Number(process.env.HEARTBEAT_MAX_RESUME_GENERATIONS) || 3;
+
+export const RESUME_BUDGET_EXHAUSTED_REASON = "resume_budget_exhausted";
+
 /** Heartbeat checklist interval: how often to check HEARTBEAT.md (default: 30 min) */
 const HEARTBEAT_CHECKLIST_INTERVAL_MS =
   Number(process.env.HEARTBEAT_CHECKLIST_INTERVAL_MS) || 30 * 60 * 1000;
@@ -98,10 +104,17 @@ export interface HeartbeatFindings {
 let heartbeatInterval: ReturnType<typeof setInterval> | null = null;
 let checklistInterval: ReturnType<typeof setInterval> | null = null;
 let isSweeping = false;
+let beforeHeartbeatSupersedeForTests: ((task: AgentTask) => void) | null = null;
 
 /** Tasks auto-failed during the reboot sweep, consumed by boot triage */
 let rebootAffectedTasks: Array<{ original: AgentTask; retryTaskId: string | null }> = [];
 
+export function setBeforeHeartbeatSupersedeForTests(
+  hook: ((task: AgentTask) => void) | null,
+): void {
+  beforeHeartbeatSupersedeForTests = hook;
+}
+
 // ============================================================================
 // Tier 1: Preflight Gate
 // ============================================================================
@@ -300,16 +313,40 @@ function remediateCrashedWorkerTask(
     return;
   }
 
-  // Supersede + resume path.
+  const nextResumeGeneration = getNextResumeGeneration(task);
+  if (nextResumeGeneration > MAX_RESUME_GENERATIONS) {
+    const failed = failTask(task.id, RESUME_BUDGET_EXHAUSTED_REASON);
+    if (failed) {
+      findings.autoFailedTasks.push({
+        taskId: task.id,
+        agentId: task.agentId,
+        reason: RESUME_BUDGET_EXHAUSTED_REASON,
+      });
+      if (opts.cleanupActiveSession) deleteActiveSession(task.id);
+      console.warn(
+        `[Heartbeat] Auto-failed task ${task.id.slice(0, 8)} — ${RESUME_BUDGET_EXHAUSTED_REASON} (${opts.shortLabel})`,
+      );
+      const remaining = getActiveTaskCount(task.agentId);
+      if (remaining === 0) updateAgentStatus(task.agentId, "idle");
+    }
+    return;
+  }
+
+  beforeHeartbeatSupersedeForTests?.(task);
+
   const superseded = supersedeTask(task.id, {
     reason: opts.supersedeReason,
     resumeTaskId: null,
   });
-  if (!superseded) return;
+  if (!superseded) {
+    return;
+  }
 
   const resume = createResumeFollowUp({ parentId: task.id, reason: "crash_recovery" });
 
   if (resume.kind === "created") {
+    backfillSupersedeTaskResumeTaskId(task.id, resume.task.id);
+
     findings.autoResumedTasks.push({
       taskId: task.id,
       resumeTaskId: resume.task.id,
@@ -320,10 +357,20 @@ function remediateCrashedWorkerTask(
       `[Heartbeat] Auto-superseded task ${task.id.slice(0, 8)} — created resume ${resume.task.id.slice(0, 8)} (${opts.shortLabel})`,
     );
   } else {
-    // `workflow-skip` is unreachable here (handled above). `skipped` covers
-    // parent-not-found / lead-not-found edge cases — just log for operators.
-    console.log(
-      `[Heartbeat] Task ${task.id.slice(0, 8)} superseded but no resume created (${
+    const reason =
+      resume.kind === "skipped"
+        ? `resume_creation_skipped_${resume.reason}`
+        : "resume_creation_skipped_workflow";
+    const failed = failTask(task.id, reason);
+    if (failed) {
+      findings.autoFailedTasks.push({
+        taskId: task.id,
+        agentId: task.agentId,
+        reason,
+      });
+    }
+    console.warn(
+      `[Heartbeat] Task ${task.id.slice(0, 8)} failed because no resume was created (${
         resume.kind === "skipped" ? resume.reason : "workflow-skip"
       })`,
     );
@@ -461,7 +508,7 @@ function checkWorkerHealth(findings: HeartbeatFindings): void {
 
 /**
  * Auto-assign unassigned pool tasks to idle workers with capacity.
- * Uses atomic claimTask() to prevent races.
+ * Leaves tasks pending so the assigned worker's normal poll dispatches them.
  */
 function autoAssignPoolTasks(findings: HeartbeatFindings): void {
   getDb().transaction(() => {
@@ -472,16 +519,37 @@ function autoAssignPoolTasks(findings: HeartbeatFindings): void {
     if (poolTasks.length === 0) return;
 
     let workerIndex = 0;
+    const reservedByWorker = new Map<string, number>();
+    const reservedForWorker = (agentId: string): number => {
+      const cached = reservedByWorker.get(agentId);
+      if (cached !== undefined) return cached;
+      const row = getDb()
+        .prepare<{ count: number }, [string]>(
+          "SELECT COUNT(*) as count FROM agent_tasks WHERE agentId = ? AND status IN ('pending', 'in_progress')",
+        )
+        .get(agentId);
+      const reserved = row?.count ?? 0;
+      reservedByWorker.set(agentId, reserved);
+      return reserved;
+    };
+
     for (const task of poolTasks) {
       if (workerIndex >= idleWorkers.length) break;
 
       const worker = idleWorkers[workerIndex]!;
-      const claimed = claimTask(task.id, worker.id);
+      const maxTasks = worker.maxTasks ?? 1;
+      if (reservedForWorker(worker.id) >= maxTasks) {
+        workerIndex++;
+        continue;
+      }
+
+      const assigned = assignUnassignedTaskPending(task.id, worker.id);
 
-      if (claimed) {
+      if (assigned) {
         findings.autoAssigned.push({ taskId: task.id, agentId: worker.id });
+        reservedByWorker.set(worker.id, reservedForWorker(worker.id) + 1);
         // Check if this worker still has capacity for more
-        const remaining = (worker.maxTasks ?? 1) - getActiveTaskCount(worker.id);
+        const remaining = maxTasks - reservedForWorker(worker.id);
         if (remaining <= 0) {
           workerIndex++;
         }