@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/tests/fixtures/runner-legacy-resume-prompt.ts

@@ -0,0 +1,122 @@
+/**
+ * Runs the real runner boot in a child process up to the legacy paused-task
+ * resume, and records the prompts the provider receives for that session.
+ */
+import { mock } from "bun:test";
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ProviderSessionConfig } from "../../providers/types";
+
+const directory = process.argv[2]!;
+const pausedTaskId = "44444444-4444-4444-8444-444444444444";
+const REQUESTER_SENTINEL = "RESUME_REQUESTER_SENTINEL_7f3a";
+const MISSING_DIR = "/nonexistent/legacy-resume-dir-7f3a";
+
+const resolver = await import("../../prompts/resolver");
+mock.module("../../prompts/resolver", () => ({
+  ...resolver,
+  configureHttpResolver() {},
+}));
+const profileSync = await import("../../commands/profile-sync");
+mock.module("../../commands/profile-sync", () => ({
+  ...profileSync,
+  SOUL_MD_PATH: join(directory, "SOUL.md"),
+  IDENTITY_MD_PATH: join(directory, "IDENTITY.md"),
+  TOOLS_MD_PATH: join(directory, "TOOLS.md"),
+  HEARTBEAT_MD_PATH: join(directory, "HEARTBEAT.md"),
+  CLAUDE_MD_PATH: join(directory, "CLAUDE.md"),
+  WORKSPACE_CLAUDE_MD_PATH: join(directory, "CLAUDE.md"),
+  SETUP_SCRIPT_PATH: join(directory, "start-up.sh"),
+  IDENTITY_BASELINES_PATH: join(directory, "baselines.json"),
+  async readIdentityBaselines() {
+    return {};
+  },
+  async writeProfileFileFromDb() {
+    return null;
+  },
+  async writeIdentityBaselines() {},
+  async syncProfileFilesToServer() {},
+  async prependProfileSyncRejectionBanner(prompt: string) {
+    return { prompt, injected: false };
+  },
+}));
+mock.module("../../utils/skills-refresh", () => ({
+  async refreshSkillsIfChanged() {
+    return { changed: false };
+  },
+}));
+const credentials = await import("../../utils/credentials");
+mock.module("../../utils/credentials", () => ({
+  ...credentials,
+  async resolveCredentialPools() {
+    return [];
+  },
+}));
+
+mock.module("../../providers/index", () => ({
+  async createProviderAdapter() {
+    return {
+      name: "pi",
+      traits: { hasMcp: true, hasLocalEnvironment: true, nativeSkillDiscovery: false },
+      formatCommand(name: string, args: string) {
+        return `/${name} ${args}`;
+      },
+      async createSession(config: ProviderSessionConfig) {
+        writeFileSync(
+          join(directory, "result.json"),
+          JSON.stringify({
+            taskId: config.taskId,
+            prompt: config.prompt,
+            systemPrompt: config.systemPrompt,
+          }),
+        );
+        // runAgent runs forever; the first spawn is the resumed task.
+        process.exit(0);
+      },
+    };
+  },
+}));
+
+// All requests terminate here. The paused-tasks endpoint carries the
+// requester projection the API attaches, as on a task_assigned trigger.
+globalThis.fetch = (async (input: string | URL | Request) => {
+  const url = new URL(input instanceof Request ? input.url : input.toString());
+  if (url.pathname === "/me") {
+    return Response.json({ name: "Fixture agent", soulMd: "Fixture soul" });
+  }
+  if (url.pathname === "/api/paused-tasks") {
+    return Response.json({
+      tasks: [
+        {
+          id: pausedTaskId,
+          task: "Resume the paused fixture task",
+          status: "paused",
+          dir: MISSING_DIR,
+          attachments: [],
+          requestedBy: {
+            id: "user-1",
+            name: "Fixture Requester",
+            email: "requester@example.com",
+            role: "CTO",
+            notes: REQUESTER_SENTINEL,
+          },
+        },
+      ],
+    });
+  }
+  if (url.pathname === "/api/poll") return new Promise(() => {});
+  if (url.pathname === "/api/config/resolved") return Response.json({ configs: [] });
+  if (url.pathname === "/api/agents") return Response.json({ enabledCapabilities: [] });
+  if (url.pathname === "/cancelled-tasks") return Response.json({ cancelled: [] });
+  if (url.pathname.startsWith("/api/tasks/")) {
+    return Response.json({ success: true, task: { id: pausedTaskId, status: "in_progress" } });
+  }
+  return Response.json({ enabled: false, recovered: 0, memories: [], configs: [] });
+}) as typeof fetch;
+
+process.env.MAX_CONCURRENT_TASKS = "1";
+const { runAgent } = await import("../../commands/runner");
+await runAgent(
+  { role: "worker", defaultPrompt: "Fixture", metadataType: "worker_metadata" },
+  { logsDir: join(directory, "logs"), systemPrompt: "Additional fixture instructions" },
+);

package/src/tests/github-handlers.test.ts

@@ -421,3 +421,38 @@ describe("no github email enrichment", () => {
     expect(await getKv(UNMAPPED_NAMESPACE, "triage-target:count")).toBeNull();
   });
 });
+
+// ── Every no-task comment path logs why ──
+
+describe("comment skip reasons", () => {
+  async function skippedReasons(events: CommentEvent[]): Promise<string[]> {
+    const logSpy = spyOn(console, "log").mockImplementation(() => {});
+    try {
+      for (const event of events) {
+        expect((await handleComment(event, "issue_comment")).created).toBe(false);
+      }
+      return logSpy.mock.calls
+        .map((args) => String(args[0]))
+        .filter((line) => line.startsWith("[GitHub] Skipped issue_comment."));
+    } finally {
+      logSpy.mockRestore();
+    }
+  }
+
+  test("edited, unmentioned and duplicate comments each log a reason", async () => {
+    const mention = `@${GITHUB_BOT_NAME} please review`;
+    const edited = { ...makeCommentEvent("skip-edit", mention), action: "edited" };
+    edited.comment = { ...edited.comment, id: 7001 };
+    const noMention = makeCommentEvent("skip-plain", "no ping here");
+    noMention.comment = { ...noMention.comment, id: 7002 };
+    const first = makeCommentEvent("skip-dup", mention);
+    first.comment = { ...first.comment, id: 7003 };
+
+    expect((await handleComment(first, "issue_comment")).created).toBe(true);
+    expect(await skippedReasons([edited, noMention, first])).toEqual([
+      "[GitHub] Skipped issue_comment.edited by skip-edit on test/repo comment 7001: action is not created",
+      "[GitHub] Skipped issue_comment.created by skip-plain on test/repo comment 7002: no bot mention",
+      "[GitHub] Skipped issue_comment.created by skip-dup on test/repo comment 7003: duplicate delivery",
+    ]);
+  });
+});

package/src/tests/harness-provider-resolution.test.ts

@@ -158,6 +158,18 @@ describe("resolveHarnessProvider", () => {
   test("keeps 'claude' when no credentials are present at all", () => {
     expect(resolveHarnessProvider({}, {})).toBe("claude");
   });
+
+  test("prefers 'pi' when a NaN or Helmcode key is the only LLM credential", () => {
+    expect(resolveHarnessProvider({ NAN_API_KEY: "example-nan" }, {})).toBe("pi");
+    expect(resolveHarnessProvider({}, { HELMCODE_API_NAN: "example-nan" })).toBe("pi");
+    expect(resolveHarnessProvider({ HELMCODE_API_KEY: "example-helm" }, {})).toBe("pi");
+  });
+
+  test("keeps 'claude' when a NaN key sits next to an Anthropic credential", () => {
+    expect(
+      resolveHarnessProvider({ NAN_API_KEY: "example-nan", ANTHROPIC_API_KEY: "example-ant" }, {}),
+    ).toBe("claude");
+  });
 });
 
 // ─── validateConfigValue ─────────────────────────────────────────────────────

package/src/tests/heartbeat-checklist.test.ts

@@ -524,7 +524,8 @@ describe("Heartbeat Checklist", () => {
             buildCredentials: () => {
               setupStarted.resolve();
               return new Promise((resolve) => {
-                releaseSetup = () => resolve({ egressSecrets: [], failedBindings: [] });
+                releaseSetup = () =>
+                  resolve({ egressSecrets: [], failedBindings: [], userConfig: {} });
               });
             },
           });
@@ -561,7 +562,7 @@ describe("Heartbeat Checklist", () => {
         {
           buildCredentials: async () => {
             controller.abort();
-            return { egressSecrets: [], failedBindings: [] };
+            return { egressSecrets: [], failedBindings: [], userConfig: {} };
           },
         },
       );

package/src/tests/hook-runtime-close.test.ts

@@ -24,8 +24,6 @@ test(
     });
     await Bun.$`mkdir -p ${tempDir}`.quiet();
     try {
-      await Bun.write(`${tempDir}/pm2`, '#!/bin/sh\nif [ "$1" = jlist ]; then printf "[]"; fi\n');
-      await Bun.$`chmod +x ${tempDir}/pm2`.quiet();
       await Bun.write(
         `${tempDir}/.mcp.json`,
         JSON.stringify({

package/src/tests/http-api-integration.test.ts

@@ -1174,13 +1174,6 @@ describe("Stats & Metadata", () => {
     expect(Array.isArray(body.logs)).toBe(true);
   });
 
-  test("GET /api/services — returns services list", async () => {
-    const { status, body } = await get("/api/services");
-    expect(status).toBe(200);
-    expect(body.services).toBeDefined();
-    expect(Array.isArray(body.services)).toBe(true);
-  });
-
   test("GET /api/scheduled-tasks — returns scheduled tasks", async () => {
     const { status, body } = await get("/api/scheduled-tasks");
     expect(status).toBe(200);
@@ -1817,24 +1810,6 @@ describe("Memory", () => {
   });
 });
 
-// ===========================================================================
-// 16. Ecosystem
-// ===========================================================================
-
-describe("Ecosystem", () => {
-  test("GET /ecosystem — missing agent ID header returns 400", async () => {
-    const { status } = await get("/ecosystem");
-    expect(status).toBe(400);
-  });
-
-  test("GET /ecosystem — returns ecosystem config for agent", async () => {
-    const { status, body } = await get("/ecosystem", { agentId: ids.workerAgent });
-    expect(status).toBe(200);
-    expect(body.apps).toBeDefined();
-    expect(Array.isArray(body.apps)).toBe(true);
-  });
-});
-
 // ===========================================================================
 // 17. Close Agent (run near end as it changes agent state)
 // ===========================================================================

package/src/tests/migration-046-budgets.test.ts

@@ -224,25 +224,26 @@ describe("migration 046 — budgets and pricing", () => {
     // Derive expected rates from the vendored snapshot instead of literals —
     // Anthropic reprices (sonnet-5 intro rate through 2026-08-31), and this
     // test pins faithful PROJECTION of the snapshot, not a rate freeze.
-    const cost = loadModelsDevCache()?.anthropic?.models?.["claude-sonnet-5"]?.cost;
-    expect(cost?.input).toBeGreaterThan(0);
-    const expectedPrices = {
-      input: cost?.input,
-      cached_input: cost?.cache_read,
-      cache_write: cost?.cache_write,
-      // Phase 3: Anthropic-billed rows derive the 1h class at 2x base input.
-      cache_write_1h: (cost?.input ?? 0) * 2,
-      output: cost?.output,
-    } as const;
+    // The `sonnet` shortname follows the current default, Sonnet 5.5.
     const seededKeys = [
-      ["claude", "claude-sonnet-5"],
-      ["claude-managed", "claude-sonnet-5"],
-      ["claude", "sonnet"],
-      ["claude-managed", "sonnet"],
-      ["pi", "sonnet"],
+      ["claude", "claude-sonnet-5", "claude-sonnet-5"],
+      ["claude-managed", "claude-sonnet-5", "claude-sonnet-5"],
+      ["claude", "sonnet", "claude-sonnet-5-5"],
+      ["claude-managed", "sonnet", "claude-sonnet-5-5"],
+      ["pi", "sonnet", "claude-sonnet-5-5"],
     ] as const;
 
-    for (const [provider, model] of seededKeys) {
+    for (const [provider, model, sourceId] of seededKeys) {
+      const cost = loadModelsDevCache()?.anthropic?.models?.[sourceId]?.cost;
+      expect(cost?.input).toBeGreaterThan(0);
+      const expectedPrices = {
+        input: cost?.input,
+        cached_input: cost?.cache_read,
+        cache_write: cost?.cache_write,
+        // Phase 3: Anthropic-billed rows derive the 1h class at 2x base input.
+        cache_write_1h: (cost?.input ?? 0) * 2,
+        output: cost?.output,
+      } as const;
       for (const [tokenClass, price] of Object.entries(expectedPrices)) {
         const row = await client.get<PricingRow>(
           `SELECT * FROM pricing

package/src/tests/migration-217-chat-sdk-state.test.ts

@@ -0,0 +1,113 @@
+import { Database } from "bun:sqlite";
+import { expect, test } from "bun:test";
+
+function setup(): Database {
+  const db = new Database(":memory:");
+  db.exec(
+    `CREATE TABLE agents (
+       id TEXT PRIMARY KEY,
+       isLead INTEGER NOT NULL DEFAULT 0
+     )`,
+  );
+  db.exec("INSERT INTO agents (id, isLead) VALUES ('lead', 1), ('worker', 0)");
+  db.exec(
+    `CREATE TABLE agent_tasks (
+       id TEXT PRIMARY KEY,
+       status TEXT NOT NULL,
+       source TEXT NOT NULL,
+       taskType TEXT,
+       contextKey TEXT,
+       agentId TEXT
+     )`,
+  );
+  return db;
+}
+
+function obligations(db: Database): string[] {
+  return db
+    .query<{ task_id: string }, []>("SELECT task_id FROM chat_relay_obligations ORDER BY task_id")
+    .all()
+    .map((row) => row.task_id);
+}
+
+test("migration 217 creates the chat state tables and the pending index", async () => {
+  const db = setup();
+  try {
+    db.exec(await Bun.file("src/be/migrations/217_chat_sdk_state.sql").text());
+    const tables = db
+      .query<{ name: string }, []>("SELECT name FROM sqlite_master WHERE type = 'table'")
+      .all()
+      .map((row) => row.name);
+    for (const table of [
+      "chat_state_kv",
+      "chat_subscriptions",
+      "chat_locks",
+      "chat_lists",
+      "chat_queue",
+      "chat_relay_obligations",
+    ]) {
+      expect(tables).toContain(table);
+    }
+    const pendingIndex = db
+      .query<{ sql: string }, []>(
+        "SELECT sql FROM sqlite_master WHERE name = 'idx_chat_relay_obligations_pending'",
+      )
+      .get();
+    expect(pendingIndex?.sql).toContain("WHERE delivered_at IS NULL AND given_up_at IS NULL");
+    expect(
+      db
+        .query<{ name: string }, []>("PRAGMA index_list(chat_queue)")
+        .all()
+        .map((index) => index.name),
+    ).toContain("idx_chat_queue_thread");
+    expect(db.query("PRAGMA integrity_check").get()).toEqual({ integrity_check: "ok" });
+  } finally {
+    db.close();
+  }
+});
+
+test("migration 217 triggers enqueue a relay obligation only for chat-rooted terminal tasks", async () => {
+  const db = setup();
+  try {
+    db.exec(await Bun.file("src/be/migrations/217_chat_sdk_state.sql").text());
+    const insert = db.prepare(
+      "INSERT INTO agent_tasks (id, status, source, taskType, contextKey, agentId) VALUES (?, ?, ?, ?, ?, ?)",
+    );
+    const key = "task:chat-sdk:telegram:555";
+    insert.run("chat", "in_progress", "chat", "chat-inbound", key, "lead");
+    insert.run("slack", "in_progress", "slack", null, "task:slack:C1:1.2", "lead");
+    insert.run("followup", "in_progress", "system", "follow-up", key, "lead");
+    insert.run("resume-lead", "in_progress", "system", "resume", key, "lead");
+    insert.run("resume-worker", "in_progress", "system", "resume", key, "worker");
+    insert.run("resume-unassigned", "in_progress", "system", "resume", key, null);
+    insert.run("delegated", "in_progress", "system", "delegated", key, "worker");
+    insert.run("upper", "in_progress", "chat", null, "TASK:CHAT-SDK:telegram:555", "lead");
+    insert.run("done-at-insert", "completed", "chat", null, "task:chat-sdk:telegram:777", "lead");
+    insert.run("resume-at-insert", "completed", "system", "resume", key, "lead");
+
+    for (const id of [
+      "chat",
+      "slack",
+      "followup",
+      "resume-lead",
+      "resume-worker",
+      "resume-unassigned",
+      "delegated",
+      "upper",
+    ]) {
+      db.run("UPDATE agent_tasks SET status = 'completed' WHERE id = ?", [id]);
+    }
+    // A second terminal transition must not add a second row.
+    db.run("UPDATE agent_tasks SET status = 'failed' WHERE id = 'chat'");
+
+    expect(obligations(db)).toEqual([
+      "chat",
+      "done-at-insert",
+      "followup",
+      "resume-at-insert",
+      "resume-lead",
+    ]);
+  } finally {
+    db.close();
+  }
+});

package/src/tests/model-tier-resolution.test.ts

@@ -267,6 +267,99 @@ describe("claim-time resolution via /api/poll", () => {
   });
 });
 
+// A row that already ran carries that run's model: the session report wrote it
+// into `model`, and the claim wrote `resolvedModel`/`modelSource`. Re-claiming
+// it must resolve from the config in force NOW, not replay the previous run.
+describe("re-claim after a previous run", () => {
+  async function markRan(
+    taskId: string,
+    fields: { model: string; resolvedModel?: string; modelSource?: string },
+  ): Promise<void> {
+    await getDbClient().run(
+      `UPDATE agent_tasks SET model = ?, resolvedModel = ?, modelSource = ?,
+         claudeSessionId = 'previous-session', status = 'pending' WHERE id = ?`,
+      [fields.model, fields.resolvedModel ?? null, fields.modelSource ?? null, taskId],
+    );
+  }
+
+  test("an unpinned task drops the previous run's model, so the agent's current config applies", async () => {
+    const worker = await createAgent({
+      name: "rerun-unpinned",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+      harnessProvider: "claude",
+    });
+    const task = await createTaskExtended("plain work", { agentId: worker.id });
+    // First run: no pin, MODEL_OVERRIDE was opus, the session reported it.
+    await markRan(task.id, { model: "claude-opus-5-5" });
+
+    const trigger = await callPoll(worker.id);
+
+    expect(trigger?.type).toBe("task_assigned");
+    // No `model` in the trigger: the worker falls through to MODEL_OVERRIDE.
+    expect(trigger?.task.model).toBeUndefined();
+    expect(trigger?.task.resolvedModel).toBeUndefined();
+    expect(await taskRow(task.id)).toEqual({
+      resolvedModel: null,
+      modelSource: null,
+      modelAlias: null,
+    });
+  });
+
+  test("a tier task re-resolves the tier after the tier config changed", async () => {
+    const worker = await createAgent({
+      name: "rerun-tier",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+      harnessProvider: "claude",
+    });
+    const task = await createTaskExtended("smart work", { agentId: worker.id, modelTier: "smart" });
+    await markRan(task.id, {
+      model: "claude-opus-5-5",
+      resolvedModel: "claude-opus-5-5",
+      modelSource: "tier-config",
+    });
+    process.env.MODEL_TIER_CLAUDE_SMART = "claude-sonnet-5-5";
+
+    const trigger = await callPoll(worker.id, header({}));
+
+    expect(trigger?.task.model).toBeUndefined();
+    expect(trigger?.task.resolvedModel).toBe("claude-sonnet-5-5");
+    expect(await taskRow(task.id)).toEqual({
+      resolvedModel: "claude-sonnet-5-5",
+      modelSource: "tier-config",
+      modelAlias: null,
+    });
+  });
+
+  test("a task-pinned model stays pinned on re-claim", async () => {
+    const worker = await createAgent({
+      name: "rerun-pinned",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+      harnessProvider: "claude",
+    });
+    const task = await createTaskExtended("pinned work", {
+      agentId: worker.id,
+      model: "claude-sonnet-5-5",
+    });
+    await markRan(task.id, {
+      model: "claude-sonnet-5-5",
+      resolvedModel: "claude-sonnet-5-5",
+      modelSource: "model",
+    });
+
+    const trigger = await callPoll(worker.id);
+
+    expect(trigger?.task.model).toBe("claude-sonnet-5-5");
+    expect(trigger?.task.resolvedModel).toBe("claude-sonnet-5-5");
+    expect((await taskRow(task.id))?.modelSource).toBe("model");
+  });
+});
+
 describe("claim-time harness guard", () => {
   test("a directed task pinning an Anthropic model on a Codex worker fails fast with a tagged reason", async () => {
     const worker = await createAgent({

package/src/tests/models-catalog.test.ts

@@ -11,14 +11,17 @@
  */
 
 import { afterEach, describe, expect, test } from "bun:test";
+import { reasoningLevelsForModel } from "@desplega/model-catalog";
 import {
   buildModelsCatalog,
+  type CatalogProviderId,
   getModelsCatalog,
   PINNED_MODELSDEV_ENTRIES,
   resetModelsCatalogForTests,
   updateLiveModelsCatalog,
 } from "../be/models-catalog";
 import type { ModelsDevCache } from "../be/modelsdev-cache";
+import { getContextWindowSize } from "../utils/context-window";
 
 afterEach(() => {
   resetModelsCatalogForTests();
@@ -82,6 +85,14 @@ describe("getModelsCatalog", () => {
     expect(Object.keys(result.providers.openrouter?.models ?? {}).length).toBeGreaterThan(0);
     expect(Object.keys(result.providers.anthropic?.models ?? {}).length).toBeGreaterThan(0);
     expect(Object.keys(result.providers.opencode?.models ?? {}).length).toBeGreaterThan(0);
+    expect(result.providers.nan?.models["glm5.3-flash"]).toBeDefined();
+    expect(Object.keys(result.providers.helmcode?.models ?? {}).sort()).toEqual([
+      "deepseek-v4-flash",
+      "gemma4",
+      "glm5.3",
+      "glm5.3-flash",
+      "qwen3.6",
+    ]);
   });
 
   test("prefers live data after an update", () => {
@@ -99,7 +110,7 @@ describe("getModelsCatalog", () => {
     const result = getModelsCatalog();
     for (const entryPath of PINNED_MODELSDEV_ENTRIES) {
       const slashIndex = entryPath.indexOf("/");
-      const providerId = entryPath.slice(0, slashIndex) as "anthropic" | "amazon-bedrock";
+      const providerId = entryPath.slice(0, slashIndex) as CatalogProviderId;
       const modelId = entryPath.slice(slashIndex + 1);
       expect(result.providers[providerId]?.models[modelId]).toBeDefined();
     }
@@ -118,3 +129,33 @@ describe("getModelsCatalog", () => {
     expect(result.providers.anthropic?.models["claude-mythos-5"]?.name).toBe("Live Mythos");
   });
 });
+
+describe("nan and helmcode sections", () => {
+  test("the registry-synthesized helmcode section survives a live payload that lacks it", () => {
+    // LIVE_CACHE has no helmcode provider: the registry section is refilled.
+    updateLiveModelsCatalog(LIVE_CACHE);
+    const helmcode = getModelsCatalog().providers.helmcode;
+    expect(helmcode?.id).toBe("helmcode");
+    expect(helmcode?.name).toBe("Helmcode");
+    expect(helmcode?.models["glm5.3"]?.limit?.context).toBe(1_048_576);
+    expect(helmcode?.models["qwen3.6"]?.limit?.context).toBe(262_144);
+  });
+
+  test("reasoning levels resolve for helmcode and nan ids on pi and opencode", () => {
+    const catalog = getModelsCatalog().providers;
+    for (const harness of ["pi", "opencode"]) {
+      expect(
+        reasoningLevelsForModel(harness, "helmcode/glm5.3-flash", catalog).length,
+      ).toBeGreaterThan(0);
+      expect(reasoningLevelsForModel(harness, "nan/glm5.3-flash", catalog).length).toBeGreaterThan(
+        0,
+      );
+    }
+  });
+
+  test("context windows come from the catalog sections", () => {
+    expect(getContextWindowSize("helmcode/glm5.3")).toBe(1_048_576);
+    expect(getContextWindowSize("helmcode/gemma4")).toBe(262_144);
+    expect(getContextWindowSize("nan/qwen3.6")).toBe(262_144);
+  });
+});