@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/src/tests/slack-thread-buffer-context.test.ts

@@ -0,0 +1,93 @@
+import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import { closeDb, createAgent, getLatestActiveTaskInThread, initDb } from "../be/db";
+
+process.env.SLACK_RENDER_V2 = "false";
+process.env.STEERING_ENABLED = "false";
+
+const TEST_DB_PATH = "./test-slack-thread-buffer-context.sqlite";
+
+// Replies Slack returns for the thread: the root, one earlier human reply, and
+// the buffered follow-up itself (conversations.replies includes it by the time
+// the buffer flushes).
+const threadMessages = [
+  { ts: "7000.0001", user: "U0ROOT", text: "original request" },
+  { ts: "7000.0005", user: "U0EARLIER", text: "earlier reply that is only context" },
+  {
+    ts: "7000.0010",
+    user: "U0FOLLOWUP",
+    text: "please also fix the retry\nand add a test for it",
+    blocks: [
+      {
+        type: "rich_text",
+        elements: [
+          {
+            type: "rich_text_section",
+            elements: [{ type: "text", text: "please also fix the retry\nand add a test for it" }],
+          },
+        ],
+      },
+    ],
+  },
+];
+
+const realSlackApp = await import("../slack/app");
+mock.module("../slack/app", () => ({
+  ...realSlackApp,
+  getSlackApp: () => ({
+    client: {
+      conversations: { replies: async () => ({ ok: true, messages: threadMessages }) },
+      users: { info: async () => ({ ok: true, user: { profile: {} } }) },
+      chat: { postMessage: async () => ({ ok: true, ts: "7000.0099" }) },
+    },
+  }),
+}));
+
+const { instantFlush, bufferThreadMessage } = await import("../slack/thread-buffer");
+
+beforeAll(async () => {
+  initDb(TEST_DB_PATH);
+  await createAgent({ name: "lead-agent", isLead: true, status: "idle", capabilities: [] });
+});
+
+afterAll(() => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      unlinkSync(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+
+describe("buffered follow-up task description", () => {
+  test("carries each buffered message once, outside <thread_context>", async () => {
+    const channelId = "C700";
+    const threadTs = "7000.0001";
+    bufferThreadMessage(
+      channelId,
+      threadTs,
+      "please also fix the retry\nand add a test for it",
+      "U0FOLLOWUP",
+      "7000.0010",
+    );
+
+    await instantFlush(`${channelId}:${threadTs}`);
+
+    const task = await getLatestActiveTaskInThread(channelId, threadTs);
+    expect(task).not.toBeNull();
+    const description = task!.task;
+    const context = description.slice(
+      description.indexOf("<thread_context>"),
+      description.indexOf("</thread_context>"),
+    );
+
+    // The follow-up appears exactly once, in the buffered section.
+    expect(description.split("please also fix the retry").length - 1).toBe(1);
+    expect(context).not.toContain("please also fix the retry");
+    expect(description).toContain("1 message(s) buffered");
+
+    // Negative control: messages that are not buffered stay in the context.
+    expect(context).toContain("original request");
+    expect(context).toContain("earlier reply that is only context");
+  });
+});

package/src/tests/status.test.ts

@@ -116,6 +116,7 @@ const ENV_KEYS_TO_RESET = [
   "AGENTMAIL_API_KEY",
   "AGENTMAIL_DISABLE",
   "SWARM_VERIFY_TTL_MS",
+  "ANONYMIZED_TELEMETRY",
 ];
 
 const savedEnv = new Map<string, string | undefined>();
@@ -222,6 +223,34 @@ describe("buildStatusPayload — identity", () => {
   });
 });
 
+// ─── Telemetry opt-out state ─────────────────────────────────────────────────
+
+describe("buildStatusPayload — telemetry", () => {
+  test("reports enabled by default (opt-out model)", async () => {
+    const payload = await buildStatusPayload();
+    expect(payload.telemetry).toEqual({ enabled: true });
+  });
+
+  test.each(["false", "0"])("reports disabled when ANONYMIZED_TELEMETRY=%s", async (value) => {
+    process.env.ANONYMIZED_TELEMETRY = value;
+    const payload = await buildStatusPayload();
+    expect(payload.telemetry).toEqual({ enabled: false });
+  });
+
+  test("reports enabled when ANONYMIZED_TELEMETRY=true", async () => {
+    process.env.ANONYMIZED_TELEMETRY = "true";
+    const payload = await buildStatusPayload();
+    expect(payload.telemetry).toEqual({ enabled: true });
+  });
+
+  test("follows the env at call time, matching the flag track() reads", async () => {
+    process.env.ANONYMIZED_TELEMETRY = "false";
+    expect((await buildStatusPayload()).telemetry?.enabled).toBe(false);
+    process.env.ANONYMIZED_TELEMETRY = "true";
+    expect((await buildStatusPayload()).telemetry?.enabled).toBe(true);
+  });
+});
+
 // ─── Setup state machine ─────────────────────────────────────────────────────
 
 function getMilestone(payload: Awaited<ReturnType<typeof buildStatusPayload>>, id: string) {

package/src/tests/steering-promotion.test.ts

@@ -18,6 +18,7 @@ import {
 } from "../be/db";
 import { buildResumeContextPreamble } from "../commands/context-preamble";
 import { codeLevelTriage } from "../heartbeat/heartbeat";
+import { handlePoll } from "../http/poll";
 
 const TEST_DB_PATH = `./test-steering-promotion-${process.pid}.sqlite`;
 
@@ -94,6 +95,56 @@ describe("steering promotion on terminal tasks", () => {
     });
   });
 
+  test("a promoted steer on a Codex agent carries no model or tier, so the claim records none and the adapter default applies", async () => {
+    const codexId = (
+      await createAgent({
+        name: "steering codex",
+        isLead: false,
+        status: "idle",
+        maxTasks: 2,
+        harnessProvider: "codex",
+      })
+    ).id;
+    const task = await createTaskExtended("codex parent", {
+      agentId: codexId,
+      model: "gpt-6-luna",
+    });
+    expect((await startTask(task.id))?.status).toBe("in_progress");
+    await createSteeringMessage({
+      taskId: task.id,
+      body: "steer after reboot",
+      mode: "queue",
+      source: "api",
+      createdByKind: "system",
+    });
+    expect((await failTask(task.id, "reboot sweep"))?.status).toBe("failed");
+    const [promoted] = await getSteeringMessagesForTask(task.id);
+    const followUp = await getTaskById(promoted!.promotedTaskId!);
+    expect(followUp?.agentId).toBe(codexId);
+    expect(followUp?.model ?? null).toBeNull();
+    expect(followUp?.modelTier ?? null).toBeNull();
+
+    let body = "";
+    const req = {
+      method: "GET",
+      url: "/api/poll",
+      headers: { "x-agent-id": codexId },
+    } as unknown as Parameters<typeof handlePoll>[0];
+    const res = {
+      setHeader() {},
+      writeHead() {},
+      end(chunk?: string) {
+        body = chunk ?? "";
+      },
+    } as unknown as Parameters<typeof handlePoll>[1];
+    await handlePoll(req, res, ["api", "poll"], new URLSearchParams(), codexId);
+    const trigger = (JSON.parse(body) as { trigger: Record<string, any> | null }).trigger;
+    expect(trigger?.type).toBe("task_assigned");
+    expect(trigger?.taskId).toBe(followUp!.id);
+    expect(trigger?.task.resolvedModel).toBeUndefined();
+    expect(trigger?.task.modelUnsupported).toBeUndefined();
+  });
+
   test("promotion bypasses disabled follow-up configuration", async () => {
     const { task } = await taskWithPendingSteer("must still be followed", {
       followUpConfig: { disabled: true },

package/src/tests/store-progress-ownership.test.ts

@@ -0,0 +1,136 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ZodType } from "zod";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getTaskAttachments,
+  getTaskById,
+  initDb,
+  startTask,
+} from "../be/db";
+import { registerStoreProgressTool } from "../tools/store-progress";
+import type { SwarmToolResult } from "../tools/utils";
+
+// Regression: a workflow foreach child saw a sibling's task id in its prompt
+// and completed that sibling's task with its own report. Only the assignee
+// (or a lead) may write a task's progress, status, or attachments.
+const ownerId = "aaaa0000-0000-4000-8000-000000000a01";
+const siblingId = "bbbb0000-0000-4000-8000-000000000a02";
+const leadId = "cccc0000-0000-4000-8000-000000000a03";
+
+const server = new McpServer({ name: "store-progress-ownership", version: "1.0.0" });
+registerStoreProgressTool(server);
+const tool = (
+  server as unknown as {
+    _registeredTools: Record<
+      string,
+      {
+        inputSchema: ZodType;
+        handler: (args: unknown, meta: unknown) => Promise<SwarmToolResult>;
+      }
+    >;
+  }
+)._registeredTools["store-progress"]!;
+
+async function call(args: unknown, callerId: string, sourceTaskId?: string) {
+  return tool.handler(tool.inputSchema.parse(args), {
+    sessionId: "store-progress-ownership-session",
+    requestInfo: {
+      headers: {
+        "x-agent-id": callerId,
+        ...(sourceTaskId ? { "x-source-task-id": sourceTaskId } : {}),
+      },
+    },
+  });
+}
+
+async function task(owner: string | null) {
+  const row = await createTaskExtended("ownership regression", {
+    ...(owner ? { agentId: owner } : {}),
+    source: "system",
+    followUpConfig: { disabled: true },
+  });
+  if (owner) await startTask(row.id);
+  return row;
+}
+
+const originalEmbeddingKey = process.env.EMBEDDING_API_KEY;
+const originalOpenAiKey = process.env.OPENAI_API_KEY;
+beforeAll(async () => {
+  process.env.EMBEDDING_API_KEY = "";
+  process.env.OPENAI_API_KEY = "";
+  initDb(":memory:");
+  await createAgent({ id: ownerId, name: "Owner worker", isLead: false, status: "idle" });
+  await createAgent({ id: siblingId, name: "Sibling worker", isLead: false, status: "idle" });
+  await createAgent({ id: leadId, name: "Lead", role: "lead", isLead: true, status: "idle" });
+});
+afterAll(() => {
+  closeDb();
+  if (originalEmbeddingKey === undefined) delete process.env.EMBEDDING_API_KEY;
+  else process.env.EMBEDDING_API_KEY = originalEmbeddingKey;
+  if (originalOpenAiKey === undefined) delete process.env.OPENAI_API_KEY;
+  else process.env.OPENAI_API_KEY = originalOpenAiKey;
+});
+
+describe("store-progress task ownership", () => {
+  test("a non-lead non-owner cannot complete another agent's task", async () => {
+    const target = await task(ownerId);
+    const own = await task(siblingId);
+    const result = await call(
+      {
+        taskId: target.id,
+        status: "completed",
+        output: "sibling report",
+        attachments: [{ kind: "url", name: "report", url: "https://example.com/r" }],
+      },
+      siblingId,
+      own.id,
+    );
+    expect(result.structuredContent?.success).toBe(false);
+    expect(result.structuredContent?.message).toContain("assigned to another agent");
+    // The refusal names the caller's own task so it can retry correctly.
+    expect(result.structuredContent?.message).toContain(own.id);
+    const after = await getTaskById(target.id);
+    expect(after?.status).toBe("in_progress");
+    expect(after?.output).toBeUndefined();
+    expect(await getTaskAttachments(target.id)).toHaveLength(0);
+  });
+
+  test("a non-lead non-owner cannot write progress, and the retry hint falls back to its in-progress task", async () => {
+    const target = await task(ownerId);
+    const own = await task(siblingId);
+    const result = await call({ taskId: target.id, progress: "not mine" }, siblingId);
+    expect(result.structuredContent?.success).toBe(false);
+    expect(result.structuredContent?.message).toContain(own.id);
+    expect((await getTaskById(target.id))?.progress).toBeUndefined();
+  });
+
+  test("the owner can write progress and complete its task", async () => {
+    const own = await task(ownerId);
+    expect(
+      (await call({ taskId: own.id, progress: "halfway" }, ownerId)).structuredContent?.success,
+    ).toBe(true);
+    expect((await getTaskById(own.id))?.progress).toBe("halfway");
+    const result = await call({ taskId: own.id, status: "completed", output: "done" }, ownerId);
+    expect(result.structuredContent?.success).toBe(true);
+    expect((await getTaskById(own.id))?.status).toBe("completed");
+  });
+
+  test("a lead can still complete a worker's task", async () => {
+    const target = await task(ownerId);
+    const result = await call(
+      { taskId: target.id, status: "completed", output: "closed by lead" },
+      leadId,
+    );
+    expect(result.structuredContent?.success).toBe(true);
+    expect((await getTaskById(target.id))?.status).toBe("completed");
+  });
+
+  test("an unassigned task stays writable, matching POST /api/tasks/:id/finish", async () => {
+    const target = await task(null);
+    const result = await call({ taskId: target.id, progress: "pool note" }, siblingId);
+    expect(result.structuredContent?.success).toBe(true);
+  });
+});

package/src/tests/subscription-plans.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { planAllowsModelFamily } from "../utils/subscription-plans";
+
+describe("planAllowsModelFamily", () => {
+  test("claude_team_standard cannot run fable", () => {
+    expect(planAllowsModelFamily("claude_team_standard", "fable")).toBe(false);
+  });
+
+  test("claude_team_standard can run opus", () => {
+    expect(planAllowsModelFamily("claude_team_standard", "opus")).toBe(true);
+  });
+
+  test("claude_team_premium can run fable", () => {
+    expect(planAllowsModelFamily("claude_team_premium", "fable")).toBe(true);
+  });
+
+  test("a null plan fails open", () => {
+    expect(planAllowsModelFamily(null, "fable")).toBe(true);
+  });
+
+  test("an unknown plan fails open", () => {
+    expect(planAllowsModelFamily("unknown_plan", "fable")).toBe(true);
+  });
+
+  test("an undefined family is always allowed", () => {
+    expect(planAllowsModelFamily("claude_team_standard", undefined)).toBe(true);
+  });
+});

package/src/tests/task-cascade-fail.test.ts

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlinkSync } from "node:fs";
 import {
+  backfillSupersedeTaskResumeTaskId,
   cancelTask,
   cascadeFailDependents,
   closeDb,
@@ -230,7 +231,7 @@ describe("cascadeFailDependents", () => {
     expect(childAfter!.failureReason).toContain("was cancelled");
   });
 
-  test("supersedeTask cascades to dependents", async () => {
+  test("supersedeTask with a resume id re-points never-started dependents", async () => {
     const agent = await createAgent({
       name: "cascade-worker-6",
       isLead: false,
@@ -239,19 +240,164 @@ describe("cascadeFailDependents", () => {
     });
 
     const parent = await createTaskExtended("Parent supersede", { agentId: agent.id });
+    const other = await createTaskExtended("Other dependency", { agentId: agent.id });
     const child = await createTaskExtended("Child of superseded", {
+      agentId: agent.id,
+      dependsOn: [parent.id, other.id],
+    });
+    const resume = await createTaskExtended("Resume of parent", { agentId: agent.id });
+
+    await startTask(parent.id);
+    await supersedeTask(parent.id, { reason: "context limit", resumeTaskId: resume.id });
+
+    const childAfter = await getTaskById(child.id);
+    expect(childAfter!.status).toBe("pending");
+    expect(childAfter!.dependsOn).toEqual([resume.id, other.id]);
+
+    const log = await getDbClient().get<{ oldValue: string; newValue: string; metadata: string }>(
+      "SELECT oldValue, newValue, metadata FROM agent_log WHERE taskId = ? AND eventType = 'task_dependency_repointed'",
+      [child.id],
+    );
+    expect(log?.oldValue).toBe(parent.id);
+    expect(log?.newValue).toBe(resume.id);
+    expect(JSON.parse(log!.metadata).reason).toBe("supersede_resume");
+  });
+
+  test("supersedeTask without a resume id defers dependents until the backfill", async () => {
+    const agent = await createAgent({
+      name: "cascade-worker-6b",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const parent = await createTaskExtended("Parent supersede late resume", { agentId: agent.id });
+    const child = await createTaskExtended("Child of late-resumed", {
+      agentId: agent.id,
+      dependsOn: [parent.id],
+    });
+
+    await startTask(parent.id);
+    await supersedeTask(parent.id, { reason: "graceful_shutdown", resumeTaskId: null });
+
+    // The window between supersede and resume creation must not fail it.
+    expect((await getTaskById(child.id))!.status).toBe("pending");
+
+    const resume = await createTaskExtended("Late resume", { agentId: agent.id });
+    await backfillSupersedeTaskResumeTaskId(parent.id, resume.id);
+
+    const childAfter = await getTaskById(child.id);
+    expect(childAfter!.status).toBe("pending");
+    expect(childAfter!.dependsOn).toEqual([resume.id]);
+  });
+
+  test("supersede settle does not rewrite a dependent that already started", async () => {
+    const agent = await createAgent({
+      name: "cascade-worker-6c",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const parent = await createTaskExtended("Parent supersede started dep", {
+      agentId: agent.id,
+    });
+    const child = await createTaskExtended("Started child", {
       agentId: agent.id,
       dependsOn: [parent.id],
     });
+    const resume = await createTaskExtended("Resume for started dep", { agentId: agent.id });
 
     await startTask(parent.id);
-    await supersedeTask(parent.id, { reason: "context limit", resumeTaskId: null });
+    await startTask(child.id);
+    await supersedeTask(parent.id, { reason: "context limit", resumeTaskId: resume.id });
 
     const childAfter = await getTaskById(child.id);
+    expect(childAfter!.dependsOn).toEqual([parent.id]);
     expect(childAfter!.status).toBe("failed");
     expect(childAfter!.failureReason).toContain("was superseded");
   });
 
+  test("concurrent settlements of a shared dependent keep both replacements", async () => {
+    const agent = await createAgent({
+      name: "cascade-worker-6d",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const a = await createTaskExtended("Shared parent A", { agentId: agent.id });
+    const b = await createTaskExtended("Shared parent B", { agentId: agent.id });
+    const child = await createTaskExtended("Depends on A and B", {
+      agentId: agent.id,
+      dependsOn: [a.id, b.id],
+    });
+    const ra = await createTaskExtended("Resume of A", { agentId: agent.id });
+    const rb = await createTaskExtended("Resume of B", { agentId: agent.id });
+
+    for (const parent of [a, b]) {
+      await startTask(parent.id);
+      await supersedeTask(parent.id, { reason: "crash_recovery", resumeTaskId: null });
+    }
+    await Promise.all([
+      backfillSupersedeTaskResumeTaskId(a.id, ra.id),
+      backfillSupersedeTaskResumeTaskId(b.id, rb.id),
+    ]);
+
+    const childAfter = await getTaskById(child.id);
+    expect(childAfter!.status).toBe("pending");
+    expect(childAfter!.dependsOn).toEqual([ra.id, rb.id]);
+  });
+
+  // A dependent's status changes right after any read the settlement makes.
+  // An accept out of `offered` is still never-started and must be re-pointed;
+  // the claim-into-in_progress guard is covered by the started-dependent test.
+  for (const moveTo of ["reviewing", "pending"] as const) {
+    test(`settlement racing offered -> ${moveTo} still re-points the dependent`, async () => {
+      const agent = await createAgent({
+        name: `cascade-worker-6e-${moveTo}`,
+        isLead: false,
+        status: "idle",
+        capabilities: [],
+      });
+
+      const parent = await createTaskExtended("Parent of offered dep", { agentId: agent.id });
+      const child = await createTaskExtended("Offered child", {
+        agentId: agent.id,
+        dependsOn: [parent.id],
+      });
+      const resume = await createTaskExtended("Resume for offered dep", { agentId: agent.id });
+      const client = getDbClient();
+      await client.run("UPDATE agent_tasks SET status = 'offered' WHERE id = ?", [child.id]);
+      await startTask(parent.id);
+      await supersedeTask(parent.id, { reason: "crash_recovery", resumeTaskId: null });
+
+      const query = client.query.bind(client);
+      let raced = false;
+      client.query = (async (sql: string, params?: unknown[]) => {
+        const rows = (await query(sql, params as never)) as { id?: string; status?: string }[];
+        if (!raced && rows.some((r) => r.id === child.id && r.status === "offered")) {
+          raced = true;
+          await client.run("UPDATE agent_tasks SET status = ? WHERE id = ?", [moveTo, child.id]);
+        }
+        return rows;
+      }) as typeof client.query;
+      try {
+        await backfillSupersedeTaskResumeTaskId(parent.id, resume.id);
+      } finally {
+        client.query = query;
+      }
+      // No read to race (single-statement settlement): the accept lands after.
+      if (!raced) {
+        await client.run("UPDATE agent_tasks SET status = ? WHERE id = ?", [moveTo, child.id]);
+      }
+
+      const childAfter = await getTaskById(child.id);
+      expect(childAfter!.status).toBe(moveTo);
+      expect(childAfter!.dependsOn).toEqual([resume.id]);
+    });
+  }
+
   test("wide fan-out: multiple dependents all cascade-failed", async () => {
     const agent = await createAgent({
       name: "cascade-worker-7",

package/src/tests/task-citations.test.ts

@@ -249,10 +249,11 @@ describe("citation persistence and completion warnings", () => {
     "failed",
     "cancelled",
   ] as const)("only the assigned agent can insert or replace citations on a %s task", async (taskStatus) => {
+    // A lead: non-lead non-owners are refused outright (store-progress-ownership).
     const otherAgent = await createAgent({
       name: `Other citation agent ${taskStatus}`,
-      role: "worker",
-      isLead: false,
+      role: "lead",
+      isLead: true,
       status: "idle",
       capabilities: [],
     });

package/src/tests/tool-annotations.test.ts

@@ -378,7 +378,7 @@ describe("Tool Annotations & Classification", () => {
     // Includes 11 skill tools, 7 MCP server tools, reusable script tools, and the
     // native Kapso/WhatsApp tools (register/unregister number + send/reply message).
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(149);
+    expect(count).toBeLessThanOrEqual(151);
   });
 
   test("core tools are fewer than deferred tools", () => {