@desplega.ai/agent-swarm 1.167.0 → 1.169.0

package/src/providers/amp-adapter.ts

@@ -44,7 +44,7 @@ import type {
  * default; the image installs exactly this version and the per-task settings
  * set `amp.updates.mode: "disabled"`. Bump it deliberately, with a live run.
  */
-export const AMP_PACKAGE = "@ampcode/cli@0.0.1791460855-g1f688c";
+export const AMP_PACKAGE = "@ampcode/cli@0.0.1791633643-g895a91";
 
 /** MCP server name. Amp exposes its tools as `agent_swarm` / `store_progress` (dashes become underscores). */
 const AMP_MCP_SERVER_NAME = "agent-swarm";
@@ -537,7 +537,7 @@ class AmpSession implements ProviderSession {
   }
 
   private get stdin(): AmpStdin {
-    return this.proc.stdin as unknown as AmpStdin;
+    return this.proc.stdin as AmpStdin;
   }
 
   private async writeInput(text: string): Promise<void> {

package/src/providers/claude-adapter.ts

@@ -41,6 +41,7 @@ import {
   terminateProcessGroup,
 } from "../utils/process-group";
 import { scrubSecrets } from "../utils/secret-scrubber";
+import { ClaudeBackgroundKeepalive } from "./claude-background-keepalive";
 import { normalizeClaudeMessage } from "./claude-session-events";
 import { resolveSlashSkillPrompt } from "./codex-skill-resolver";
 import { CTX_MODE_NUDGE_EVERY } from "./ctx-mode-env";
@@ -904,6 +905,8 @@ class ClaudeSession implements ProviderSession {
   private lastAssistantText = "";
   /** Per-session stream-json transcript used by the parent-owned session summarizer. */
   private transcript: string[];
+  /** Keeps the session heartbeat fresh while Claude idles on background tasks. */
+  private backgroundKeepalive: ClaudeBackgroundKeepalive;
   readonly deliverSteering?: (delivery: SteerDelivery) => Promise<SteerDeliveryResult>;
 
   constructor(
@@ -925,6 +928,7 @@ class ClaudeSession implements ProviderSession {
     this.contextWindowSize = getContextWindowSize(model);
     this.systemPromptFile = systemPromptFile;
     this.transcript = [`User: ${scrubSecrets(config.prompt)}`];
+    this.backgroundKeepalive = new ClaudeBackgroundKeepalive(config);
     const cmd = this.buildCommand();
 
     console.log(
@@ -1158,6 +1162,7 @@ class ClaudeSession implements ProviderSession {
     try {
       await Promise.all([stdoutPromise, stderrPromise]);
     } finally {
+      this.backgroundKeepalive.stop();
       this.closeStdin();
     }
     await logFileHandle.end();
@@ -1226,6 +1231,7 @@ class ClaudeSession implements ProviderSession {
       if (json.type === "result") {
         this.closeStdin();
       }
+      this.backgroundKeepalive.observe(json);
 
       const normalized = normalizeClaudeMessage(json, {
         taskId: this.config.taskId,

package/src/providers/claude-background-keepalive.ts

@@ -0,0 +1,100 @@
+/**
+ * Keeps a Claude session's heartbeat fresh while it waits on background work.
+ *
+ * A Claude session that starts a `run_in_background` Bash job (or backgrounds a
+ * subagent) can end its turn and sit idle until the job's task_notification
+ * wakes it. During that wait it makes no tool calls and streams no output, so
+ * neither liveness input (the PostToolUse heartbeat and session-log ingestion)
+ * moves `active_sessions.lastHeartbeatAt`, and the stalled-task sweep classifies
+ * the live session as stale after `HEARTBEAT_STALL_STALE_HB_MIN`.
+ *
+ * Claude Code emits `system/background_tasks_changed` with the full set of live
+ * background tasks on every membership change (REPLACE semantics). While that
+ * set holds at least one non-ambient task, this pings the session heartbeat on
+ * an interval. With no background work the timer never runs, so a hung session
+ * still goes stale. A background job that never settles is bounded too: the
+ * keepalive stops once the session has emitted nothing for
+ * `BACKGROUND_KEEPALIVE_MAX_IDLE_MS`.
+ */
+
+/** Ping interval; well inside the 15-minute stale-session threshold. */
+export const BACKGROUND_KEEPALIVE_INTERVAL_MS = 60_000;
+/** Longest silent wait on background work that the keepalive will cover. */
+export const BACKGROUND_KEEPALIVE_MAX_IDLE_MS = 2 * 60 * 60_000;
+
+type BackgroundTaskEntry = { task_id?: unknown; ambient?: unknown };
+
+export interface ClaudeBackgroundKeepaliveOptions {
+  apiUrl: string;
+  apiKey: string;
+  agentId: string;
+  taskId: string;
+  intervalMs?: number;
+  maxIdleMs?: number;
+}
+
+export class ClaudeBackgroundKeepalive {
+  private liveTaskIds: string[] = [];
+  private timer: ReturnType<typeof setInterval> | undefined;
+  private lastMessageAt = Date.now();
+  private stopped = false;
+  private readonly intervalMs: number;
+  private readonly maxIdleMs: number;
+
+  constructor(private readonly options: ClaudeBackgroundKeepaliveOptions) {
+    this.intervalMs = options.intervalMs ?? BACKGROUND_KEEPALIVE_INTERVAL_MS;
+    this.maxIdleMs = options.maxIdleMs ?? BACKGROUND_KEEPALIVE_MAX_IDLE_MS;
+  }
+
+  /** Feed every protocol message the Claude process emits. */
+  observe(message: { type?: string; subtype?: string; tasks?: unknown }): void {
+    if (this.stopped) return;
+    this.lastMessageAt = Date.now();
+    if (message.type === "system" && message.subtype === "background_tasks_changed") {
+      const tasks = Array.isArray(message.tasks) ? (message.tasks as BackgroundTaskEntry[]) : [];
+      // Ambient tasks (live-update watchers, skip_transcript tasks) are not
+      // activity; Claude Code asks hosts to leave them out of activity signals.
+      this.liveTaskIds = tasks
+        .filter((task) => task && task.ambient !== true && typeof task.task_id === "string")
+        .map((task) => task.task_id as string);
+    }
+    // Any message restarts a keepalive the idle cap stopped, while work is live.
+    if (this.liveTaskIds.length > 0) this.start();
+    else this.clearTimer();
+  }
+
+  /** Stop pinging for good; call when the session ends. */
+  stop(): void {
+    this.stopped = true;
+    this.liveTaskIds = [];
+    this.clearTimer();
+  }
+
+  private start(): void {
+    if (this.timer !== undefined) return;
+    if (!this.options.apiUrl || !this.options.taskId) return;
+    this.timer = setInterval(() => this.tick(), this.intervalMs);
+  }
+
+  private tick(): void {
+    if (Date.now() - this.lastMessageAt > this.maxIdleMs) {
+      this.clearTimer();
+      return;
+    }
+    const { apiUrl, apiKey, agentId, taskId } = this.options;
+    void fetch(`${apiUrl}/api/active-sessions/heartbeat/${encodeURIComponent(taskId)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        "X-Agent-ID": agentId,
+      },
+    }).catch(() => {});
+  }
+
+  private clearTimer(): void {
+    if (this.timer === undefined) return;
+    clearInterval(this.timer);
+    this.timer = undefined;
+  }
+}

package/src/providers/claude-managed-adapter.ts

@@ -37,8 +37,6 @@
 
 import Anthropic from "@anthropic-ai/sdk";
 // Real type usages (the Phase 1 imports become non-decorative as of this phase).
-import type { BetaManagedAgentsAgent as Agent } from "@anthropic-ai/sdk/resources/beta/agents";
-import type { BetaEnvironment as Environment } from "@anthropic-ai/sdk/resources/beta/environments";
 import type {
   BetaManagedAgentsAgentMCPToolResultEvent,
   BetaManagedAgentsAgentMCPToolUseEvent,
@@ -57,7 +55,6 @@ import type {
   BetaManagedAgentsSession as Session,
   BetaManagedAgentsSessionEvent as SessionEvent,
 } from "@anthropic-ai/sdk/resources/beta/sessions";
-import type { BetaSkill as Skill } from "@anthropic-ai/sdk/resources/beta/skills";
 
 import { checkToolLoop } from "../hooks/tool-loop-detection";
 import {
@@ -107,13 +104,6 @@ export function checkClaudeManagedCredentials(env: Record<string, string | undef
   };
 }
 
-// Re-export the type aliases at module level so adjacent files / tests can use
-// the short names without re-discovering the long Beta-prefixed ones. Kept on
-// `void` lines so unused-import lints stay quiet for the type imports above.
-void (null as unknown as Agent);
-void (null as unknown as Environment);
-void (null as unknown as Skill);
-
 /**
  * Required env vars validated at construction time. Listing them in one place
  * keeps the error messages consistent and makes it easy for Phase 2 (worker
@@ -677,7 +667,7 @@ class ClaudeManagedSession implements ProviderSession {
           events: [
             {
               type: "user.message",
-              content: this.userMessageContent as unknown as Record<string, unknown>[],
+              content: this.userMessageContent,
             },
           ],
         });
@@ -857,6 +847,7 @@ export class ClaudeManagedAdapter implements ProviderAdapter {
       // our narrower `ManagedAgentsClient` interface (which exists for
       // testability) but TypeScript can't infer that without us spelling out
       // every method signature on both sides.
+      // oxlint-disable-next-line anti-slop/no-chained-type-assertions -- see the comment above.
       this.client = new Anthropic({ apiKey: this.apiKey }) as unknown as ManagedAgentsClient;
     }
   }

package/src/providers/claude-sdk-session.ts

@@ -29,6 +29,7 @@ import {
   cleanupTaskFile,
   runClaudeSessionSummary,
 } from "./claude-adapter";
+import { ClaudeBackgroundKeepalive } from "./claude-background-keepalive";
 import type { ClaudeProtocolMessage } from "./claude-session-events";
 import { normalizeClaudeMessage } from "./claude-session-events";
 import type {
@@ -317,8 +318,11 @@ class ClaudeSdkSession implements ProviderSession {
   private acceptingInput = true;
   private errorTracker = new SessionErrorTracker();
   private shutdownPromise: Promise<void> | undefined;
+  /** Keeps the session heartbeat fresh while Claude idles on background tasks. */
+  private backgroundKeepalive: ClaudeBackgroundKeepalive;
 
   constructor(private options: CreateClaudeSdkSessionOptions) {
+    this.backgroundKeepalive = new ClaudeBackgroundKeepalive(options.config);
     this.model = options.model;
     this.contextWindowSize = getContextWindowSize(options.model);
     this.transcript = [`User: ${scrubSecrets(options.config.prompt)}`];
@@ -405,7 +409,8 @@ class ClaudeSdkSession implements ProviderSession {
   }
 
   private handleMessage(message: SDKMessage): boolean {
-    const json = message as unknown as ClaudeProtocolMessage;
+    const json = message as ClaudeProtocolMessage;
+    this.backgroundKeepalive.observe(json);
     const normalized = normalizeClaudeMessage(json, {
       taskId: this.options.config.taskId,
       agentId: this.options.config.agentId,
@@ -514,6 +519,7 @@ class ClaudeSdkSession implements ProviderSession {
         this.emit({ type: "error", message, category: "sdk_transport" });
       }
     } finally {
+      this.backgroundKeepalive.stop();
       this.acceptingInput = false;
       this.input.close();
       if (this.aborted) {

package/src/providers/dsh-adapter.ts

@@ -37,7 +37,7 @@ import type {
 } from "./types";
 
 // npm's `latest` is older and lacks the JSON/stdin contract used here.
-export const DSH_PACKAGE = "@deepseek-ai/dsh@0.2.1-alpha.1";
+export const DSH_PACKAGE = "@deepseek-ai/dsh@0.2.1-alpha.2";
 
 export function checkDshCredentials(env: Record<string, string | undefined>): CredStatus {
   return env.DEEPSEEK_API_KEY?.trim() || env.OPENROUTER_API_KEY?.trim()

package/src/providers/opencode-adapter.ts

@@ -559,8 +559,7 @@ export class OpencodeSession implements ProviderSession {
         // so the dashboard's Activity timeline mirrors what other providers
         // emit. We fire tool_start the first time we see a tool part (any
         // status); tool_end fires once when state transitions to "completed".
-        const props = (ev as unknown as { properties: { sessionID?: string; part?: unknown } })
-          .properties;
+        const props = (ev as { properties: { sessionID?: string; part?: unknown } }).properties;
         if (props.sessionID !== this._sessionId) break;
         const part = props.part as
           | {

package/src/providers/pi-mono-adapter.ts

@@ -1692,9 +1692,9 @@ export class PiMonoAdapter implements ProviderAdapter {
     try {
       const sessionManager = SessionManager.create(this.lastCwd);
       // SessionManager stores sessions as files — check if the session exists
-      const sessions = await (
-        sessionManager as unknown as { list(): Promise<Array<{ id: string }>> }
-      ).list?.();
+      // oxlint-disable-next-line anti-slop/no-chained-type-assertions -- pi declares list() as static, so this optional call finds nothing.
+      const listable = sessionManager as unknown as { list?(): Promise<Array<{ id: string }>> };
+      const sessions = await listable.list?.();
       return sessions?.some((s) => s.id === sessionId) ?? false;
     } catch {
       return false;