@desplega.ai/agent-swarm 1.157.0 → 1.158.0

package/src/tests/sessions-detail-batch.test.ts

@@ -0,0 +1,250 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getDbClient,
+  getRootTaskChain,
+  getTaskById,
+  initDb,
+} from "../be/db";
+import { getTaskSteeringFields, getTaskSteeringFieldsForTasks } from "../be/steering";
+import { getTaskCitations, getTaskCitationsForTasks } from "../be/task-citations";
+import { handleSessions } from "../http/sessions";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import type { AgentTask } from "../types";
+import { listenOnFreePort } from "./test-net";
+
+let server: Server;
+let baseUrl: string;
+let rootId: string;
+const chainIds: string[] = [];
+
+async function addCitation(taskId: string, index: number, general = false) {
+  await getDbClient().run(
+    `INSERT INTO task_citations (task_id, citation_index, kind, ref, label, quote, resolved_url, verified, general)
+     VALUES (?, ?, 'url', ?, ?, NULL, ?, 'unchecked', ?)`,
+    [
+      taskId,
+      index,
+      `https://example.com/${taskId}/${index}`,
+      `c${index}`,
+      `https://example.com/${taskId}/${index}`,
+      general ? 1 : 0,
+    ],
+  );
+}
+
+/** The pre-batch handler body: one agent lookup and one citations query per task. */
+async function unbatchedSession(id: string) {
+  const root = (await getTaskById(id))!;
+  const chain = await getRootTaskChain(id);
+  const decorate = async (task: AgentTask) => ({
+    ...task,
+    ...(await getTaskSteeringFields(task)),
+    citations: await getTaskCitations(task.id),
+  });
+  return { root: await decorate(root), chain: await Promise.all(chain.map(decorate)) };
+}
+
+beforeAll(async () => {
+  initDb(":memory:");
+  server = createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const ok = await handleSessions(
+      req,
+      res,
+      getPathSegments(req.url || ""),
+      parseQueryParams(req.url || ""),
+    );
+    if (!ok) {
+      res.writeHead(404);
+      res.end();
+    }
+  });
+  baseUrl = `http://127.0.0.1:${await listenOnFreePort(server)}`;
+
+  const lead = await createAgent({
+    name: "lead",
+    isLead: true,
+    status: "idle",
+    capabilities: [],
+    harnessProvider: "claude",
+  });
+  const codex = await createAgent({
+    name: "codex worker",
+    isLead: false,
+    status: "idle",
+    capabilities: [],
+    harnessProvider: "codex",
+  });
+  const pi = await createAgent({
+    name: "pi worker",
+    isLead: false,
+    status: "idle",
+    capabilities: [],
+    provider: "pi",
+  });
+
+  const root = await createTaskExtended("session root", { agentId: lead.id, source: "api" });
+  rootId = root.id;
+  const childA = await createTaskExtended("child A", {
+    agentId: codex.id,
+    parentTaskId: root.id,
+    source: "api",
+  });
+  const childB = await createTaskExtended("child B", {
+    agentId: pi.id,
+    parentTaskId: root.id,
+    source: "api",
+  });
+  const grandchild = await createTaskExtended("grandchild of A", {
+    agentId: codex.id,
+    parentTaskId: childA.id,
+    source: "api",
+  });
+  const unassigned = await createTaskExtended("unassigned child", {
+    parentTaskId: childB.id,
+    source: "api",
+    provider: "devin",
+  });
+  const ghost = await createTaskExtended("child of a deleted agent", {
+    agentId: lead.id,
+    parentTaskId: root.id,
+    source: "api",
+  });
+  await getDbClient().run("UPDATE agent_tasks SET agentId = ? WHERE id = ?", [
+    "00000000-0000-4000-8000-000000000000",
+    ghost.id,
+  ]);
+  chainIds.push(childA.id, childB.id, grandchild.id, unassigned.id, ghost.id);
+
+  // Out-of-order inserts so the per-task citation_index ordering is exercised.
+  await addCitation(root.id, 3);
+  await addCitation(root.id, 1, true);
+  await addCitation(root.id, 2);
+  await addCitation(childA.id, 2);
+  await addCitation(childA.id, 1);
+  await addCitation(grandchild.id, 1, true);
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+});
+
+describe("GET /api/sessions/{rootTaskId} batching", () => {
+  test("response is identical to the per-task path on a multi-task chain", async () => {
+    const res = await fetch(`${baseUrl}/api/sessions/${rootId}`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    const expected = JSON.parse(JSON.stringify(await unbatchedSession(rootId)));
+
+    expect(body).toEqual(expected);
+    // Guard against a vacuous match: the fixture covers every branch.
+    expect(body.chain.map((task: AgentTask) => task.id).sort()).toEqual(
+      [rootId, ...chainIds].sort(),
+    );
+    expect(body.root.isLeadTask).toBe(true);
+    expect(body.root.citations.map((c: { index: number }) => c.index)).toEqual([1, 2, 3]);
+    expect(body.root.citations[0].general).toBe(true);
+    const byId = new Map(body.chain.map((task: AgentTask) => [task.id, task]));
+    const [childA, childB, grandchild, unassigned, ghost] = chainIds.map((id) => byId.get(id)) as {
+      isLeadTask: boolean;
+      supportedSteerModes: string[];
+      citations: { index: number }[];
+    }[];
+    expect(childA!.citations.map((c) => c.index)).toEqual([1, 2]);
+    expect(grandchild!.citations).toHaveLength(1);
+    expect(childB!.citations).toEqual([]);
+    expect(unassigned!.isLeadTask).toBe(false);
+    expect(ghost!.isLeadTask).toBe(false);
+  });
+
+  test("404 for an unknown root is unchanged", async () => {
+    const res = await fetch(`${baseUrl}/api/sessions/00000000-0000-4000-8000-000000000001`);
+    expect(res.status).toBe(404);
+  });
+
+  test("getRootTaskChain seeks the chain instead of scanning agent_tasks, same order", async () => {
+    const OLD_CHAIN_SQL = `WITH RECURSIVE chain(id) AS (
+         SELECT id FROM agent_tasks WHERE id = ?
+         UNION ALL
+         SELECT t.id FROM agent_tasks t
+         JOIN chain c ON t.parentTaskId = c.id
+       )
+       SELECT t.id FROM agent_tasks t
+       JOIN chain ON chain.id = t.id
+       ORDER BY t.createdAt`;
+    // Ties on createdAt: the old plan returned them in idx_agent_tasks_created (rowid) order.
+    const ids = [rootId, ...chainIds];
+    const saved = await getDbClient().query<{ id: string; createdAt: string }>(
+      `SELECT id, createdAt FROM agent_tasks WHERE id IN (${ids.map(() => "?").join(",")})`,
+      ids,
+    );
+    await getDbClient().run(
+      `UPDATE agent_tasks SET createdAt = '2026-01-01T00:00:00.000Z' WHERE id IN (${ids
+        .slice(1)
+        .map(() => "?")
+        .join(",")})`,
+      ids.slice(1),
+    );
+    try {
+      const old = await getDbClient().query<{ id: string }>(OLD_CHAIN_SQL, [rootId]);
+      expect((await getRootTaskChain(rootId)).map((t) => t.id)).toEqual(old.map((r) => r.id));
+    } finally {
+      for (const row of saved) {
+        await getDbClient().run("UPDATE agent_tasks SET createdAt = ? WHERE id = ?", [
+          row.createdAt,
+          row.id,
+        ]);
+      }
+    }
+
+    // Capture the SQL the real call issues, then ask SQLite how it runs it.
+    const client = getDbClient();
+    const query = client.query.bind(client);
+    let issued = "";
+    client.query = ((sql: string, params?: unknown[]) => {
+      issued = sql;
+      return query(sql, params as never);
+    }) as typeof client.query;
+    try {
+      await getRootTaskChain(rootId);
+    } finally {
+      client.query = query;
+    }
+    const plan = await client.query<{ detail: string }>(`EXPLAIN QUERY PLAN ${issued}`, [rootId]);
+    expect(plan.map((r) => r.detail)).not.toContain("SCAN t USING INDEX idx_agent_tasks_created");
+  });
+
+  test("batched loaders chunk past 500 ids and match the per-id loaders", async () => {
+    const chain = await getRootTaskChain(rootId);
+    // Pad with ids that have no rows so the real ones straddle chunk boundaries.
+    const padding = Array.from(
+      { length: 1200 },
+      (_, i) => `00000000-0000-4000-8000-${String(i).padStart(12, "0")}`,
+    );
+    const ids = [...padding.slice(0, 499), ...chain.map((t) => t.id), ...padding.slice(499)];
+
+    const citations = await getTaskCitationsForTasks(ids);
+    expect(citations.size).toBe(ids.length);
+    for (const task of chain) {
+      expect(citations.get(task.id)).toEqual(await getTaskCitations(task.id));
+    }
+    expect(citations.get(padding[0]!)).toEqual([]);
+
+    const fakeTasks = padding.map((agentId, i) => ({ ...chain[0]!, id: `fake-${i}`, agentId }));
+    const tasks = [...fakeTasks.slice(0, 499), ...chain, ...fakeTasks.slice(499)];
+    const steering = await getTaskSteeringFieldsForTasks(tasks);
+    expect(steering.size).toBe(tasks.length);
+    for (const task of tasks) {
+      expect(steering.get(task.id)).toEqual(await getTaskSteeringFields(task));
+    }
+  });
+});

package/src/tests/sessions.test.ts

@@ -6,11 +6,13 @@ import {
   createAgent,
   createTaskExtended,
   createUser,
+  getDbClient,
   getRootTaskChain,
   initDb,
   listRecentSessions,
   updateTaskTitle,
 } from "../be/db";
+import { withSiblingAwareness } from "../tasks/sibling-awareness";
 
 const TEST_DB_PATH = "./test-sessions.sqlite";
 
@@ -240,4 +242,120 @@ describe("sessions — getRootTaskChain + listRecentSessions", () => {
     const afterClear = (await listRecentSessions({ limit: 50 })).find((s) => s.root.id === root.id);
     expect(afterClear?.root.title).toBeUndefined();
   });
+
+  test("contextKeyPrefix — returns only matching roots, total agrees, children never appear", async () => {
+    const pageKey = "task:ui:workflow:ctxwf1";
+    const a = await createTaskExtended("ctx session a", { contextKey: `${pageKey}:n1` });
+    const b = await createTaskExtended("ctx session b", { contextKey: `${pageKey}:n2` });
+    // Child inherits the parent's contextKey but must not surface as its own row.
+    const child = await createTaskExtended("ctx child", { parentTaskId: a.id });
+    expect(child.contextKey).toBe(`${pageKey}:n1`);
+    // Longer id sharing the textual prefix: excluded by the trailing `:`.
+    const longer = await createTaskExtended("ctx longer id", {
+      contextKey: "task:ui:workflow:ctxwf1x:n1",
+    });
+    // Positive control: without the filter every root is listed.
+    const all = await listRecentSessions({ limit: 500 });
+    expect(all.some((s) => s.root.id === longer.id)).toBe(true);
+
+    const rows = await listRecentSessions({ limit: 50, contextKeyPrefix: `${pageKey}:` });
+    expect(rows.map((s) => s.root.id).sort()).toEqual([a.id, b.id].sort());
+    expect(await countSessions({ contextKeyPrefix: `${pageKey}:` })).toBe(2);
+    expect(rows.find((s) => s.root.id === a.id)?.chainTaskCount).toBe(2);
+    expect(rows.some((s) => s.root.id === child.id)).toBe(false);
+  });
+
+  test("contextKeyPrefix + q — server-side search keeps newest-first order, ties break on createdAt", async () => {
+    const pageKey = "task:ui:workflow:ctxsearch";
+    const setTimes = (id: string, createdAt: string, lastUpdatedAt: string) =>
+      getDbClient().run("UPDATE agent_tasks SET createdAt = ?, lastUpdatedAt = ? WHERE id = ?", [
+        createdAt,
+        lastUpdatedAt,
+        id,
+      ]);
+    const oldest = await createTaskExtended("legend overlaps the chart", {
+      contextKey: `${pageKey}:n1`,
+    });
+    const middle = await createTaskExtended("axis labels are cut", { contextKey: `${pageKey}:n2` });
+    const newest = await createTaskExtended("legend colors wrong", { contextKey: `${pageKey}:n3` });
+    // Same last activity as `newest`, created earlier: sorts just below it.
+    const tied = await createTaskExtended("legend font", { contextKey: `${pageKey}:n4` });
+    await setTimes(oldest.id, "2026-09-01T10:00:00.000Z", "2026-09-01T10:05:00.000Z");
+    await setTimes(middle.id, "2026-09-10T10:00:00.000Z", "2026-09-10T10:05:00.000Z");
+    await setTimes(newest.id, "2026-09-20T10:00:00.000Z", "2026-09-20T10:05:00.000Z");
+    await setTimes(tied.id, "2026-09-19T10:00:00.000Z", "2026-09-20T10:05:00.000Z");
+    await updateTaskTitle(middle.id, "Legend position");
+
+    const all = await listRecentSessions({ limit: 50, contextKeyPrefix: `${pageKey}:` });
+    expect(all.map((s) => s.root.id)).toEqual([newest.id, tied.id, middle.id, oldest.id]);
+
+    // `q` filters in SQL on task text and custom title, case-insensitive.
+    const hits = await listRecentSessions({
+      limit: 50,
+      contextKeyPrefix: `${pageKey}:`,
+      q: "LEGEND",
+    });
+    expect(hits.map((s) => s.root.id)).toEqual([newest.id, tied.id, middle.id, oldest.id]);
+    const narrow = await listRecentSessions({
+      limit: 50,
+      contextKeyPrefix: `${pageKey}:`,
+      q: "overlaps",
+    });
+    expect(narrow.map((s) => s.root.id)).toEqual([oldest.id]);
+    expect(await countSessions({ contextKeyPrefix: `${pageKey}:`, q: "colors" })).toBe(1);
+    // A match outside the page is not returned.
+    expect(
+      await listRecentSessions({ limit: 50, contextKeyPrefix: `${pageKey}:`, q: "no such text" }),
+    ).toEqual([]);
+  });
+
+  test("contextKeyPrefix — LIKE wildcards in the prefix match literally", async () => {
+    const literal = await createTaskExtended("literal wildcard", {
+      contextKey: "task:ui:route:a%25_b:n1",
+    });
+    // Would match `a%25_b` under an unescaped LIKE (`_` = any char), must not here.
+    await createTaskExtended("wildcard decoy", { contextKey: "task:ui:route:a%25xb:n1" });
+
+    const rows = await listRecentSessions({
+      limit: 50,
+      contextKeyPrefix: "task:ui:route:a%25_b:",
+    });
+    expect(rows.map((s) => s.root.id)).toEqual([literal.id]);
+    expect(await countSessions({ contextKeyPrefix: "task:ui:route:a%25_b:" })).toBe(1);
+    expect(await countSessions({ contextKeyPrefix: "task:ui:route:%" })).toBe(0);
+  });
+
+  test("per-session keys keep a second session on the same page a root (sibling-awareness trap)", async () => {
+    const pageKey = "task:ui:workflow:ctxwf2";
+    const lead = await createAgent({
+      id: "sessions-test-agent-ctx",
+      name: "Sessions Ctx Lead",
+      isLead: true,
+      status: "idle",
+    });
+    const first = await createTaskExtended("first session", {
+      agentId: lead.id,
+      contextKey: `${pageKey}:n1`,
+    });
+    expect(first.status).toBe("pending");
+
+    // POST /api/tasks defaults agentId to the lead, which is what arms the trap.
+    // Positive control: a shared key WOULD nest the new session under the first.
+    const shared = await withSiblingAwareness("same key", {
+      agentId: lead.id,
+      contextKey: `${pageKey}:n1`,
+    });
+    expect(shared.options.parentTaskId).toBe(first.id);
+
+    const prepared = await withSiblingAwareness("second session", {
+      agentId: lead.id,
+      contextKey: `${pageKey}:n2`,
+    });
+    expect(prepared.options.parentTaskId).toBeUndefined();
+    const second = await createTaskExtended(prepared.description, prepared.options);
+    expect(second.parentTaskId).toBeUndefined();
+
+    const rows = await listRecentSessions({ limit: 50, contextKeyPrefix: `${pageKey}:` });
+    expect(rows.map((s) => s.root.id).sort()).toEqual([first.id, second.id].sort());
+  });
 });

package/src/tests/slack-config.test.ts

@@ -4,6 +4,7 @@ import { closeDb, initDb } from "../be/db";
 import { getEnabledCapabilities } from "../server";
 import { getSlackApp, startSlackApp, stopSlackApp } from "../slack/app";
 import { getSlackConfiguration, isSlackConfigured } from "../slack/config";
+import { getSlackConnectionState } from "../slack/connection-state";
 
 const SLACK_ENV_KEYS = [
   "NODE_ENV",
@@ -134,3 +135,24 @@ test.each([
     closeDb();
   }
 }, 20_000);
+
+test("Socket Mode lifecycle drives the live connection state read by /status", async () => {
+  const slack = await startSlackMock(false);
+  initDb(":memory:");
+  try {
+    Object.assign(process.env, slack.mock.env);
+    expect(getSlackConnectionState()).toBe("disconnected");
+
+    expect(await startSlackApp()).toBe(true);
+    await slack.mock.waitForConnection(10_000);
+    // Bolt resolves start() on Slack's hello, which is what emits `connected`.
+    expect(getSlackConnectionState()).toBe("connected");
+
+    await stopSlackApp();
+    expect(getSlackConnectionState()).toBe("disconnected");
+  } finally {
+    await stopSlackApp();
+    await stopSlackMock(slack, false);
+    closeDb();
+  }
+}, 20_000);

package/src/tests/sonnet-5-5-registry.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+import { findKnownModel } from "../../apps/ui/src/lib/agent-runtime-models";
+import { loadModelsDevCache } from "../be/modelsdev-cache";
+import { buildModelsDevSeedRows } from "../be/seed-pricing";
+
+describe("Sonnet 5.5 registry", () => {
+  test("is selectable and keeps Sonnet 5 selectable", () => {
+    expect(findKnownModel("claude-sonnet-5-5")).toMatchObject({
+      id: "claude-sonnet-5-5",
+      reasoningLevels: ["low", "medium", "high", "xhigh"],
+    });
+    expect(findKnownModel("claude-sonnet-5")?.id).toBe("claude-sonnet-5");
+  });
+
+  test("seeds canonical and alias rates without changing Sonnet 5", () => {
+    const cache = loadModelsDevCache();
+    expect(cache).not.toBeNull();
+    const rows = buildModelsDevSeedRows(cache!);
+    for (const provider of ["claude", "claude-managed"] as const) {
+      for (const model of ["claude-sonnet-5-5", "sonnet"]) {
+        const rates = Object.fromEntries(
+          rows
+            .filter((row) => row.provider === provider && row.model === model)
+            .map((row) => [row.tokenClass, row.pricePerMillionUsd]),
+        );
+        expect(rates).toEqual({
+          input: 2,
+          output: 10,
+          cached_input: 0.2,
+          cache_write: 2.5,
+          cache_write_1h: 4,
+        });
+      }
+      expect(
+        rows.find(
+          (row) =>
+            row.provider === provider &&
+            row.model === "claude-sonnet-5" &&
+            row.tokenClass === "input",
+        )?.pricePerMillionUsd,
+      ).toBe(2);
+    }
+  });
+});

package/src/tests/status.test.ts

@@ -40,6 +40,7 @@ import {
   rollupCredStatusForProvider,
   type SetupMilestone,
 } from "../http/status";
+import { setSlackConnectionState } from "../slack/connection-state";
 import type { AgentCredStatus } from "../types";
 
 // Helper for tests: stamp an agent row with a cred_status snapshot so the
@@ -170,6 +171,7 @@ beforeEach(async () => {
   clearEnv();
   await clearTables();
   _resetTestConnectionCache();
+  setSlackConnectionState("disconnected");
 });
 
 afterEach(() => {
@@ -455,7 +457,7 @@ describe("setup milestones", () => {
     process.env.SLACK_APP_TOKEN = "xapp-test";
     const b = await buildStatusPayload();
     expect(getMilestone(b, "slack").state).toBe("configured");
-    expect(getMilestone(b, "slack").hint).toContain("not been verified");
+    expect(getMilestone(b, "slack").hint).toContain("not connected");
 
     process.env.SLACK_MODE = "http";
     delete process.env.SLACK_APP_TOKEN;
@@ -469,6 +471,26 @@ describe("setup milestones", () => {
     expect(getMilestone(c, "slack").state).toBe("unverified");
   });
 
+  test("slack: a live Socket Mode connection reports verified; a dropped one does not", async () => {
+    process.env.SLACK_BOT_TOKEN = "xoxb-test";
+    process.env.SLACK_APP_TOKEN = "xapp-test";
+
+    setSlackConnectionState("connected");
+    const live = getMilestone(await buildStatusPayload(), "slack");
+    expect(live.state).toBe("verified");
+    expect(live.hint).toBeUndefined();
+
+    setSlackConnectionState("connecting");
+    const reconnecting = getMilestone(await buildStatusPayload(), "slack");
+    expect(reconnecting.state).toBe("configured");
+    expect(reconnecting.hint).toContain("not connected");
+
+    // A stale "connected" never verifies credentials that are now missing.
+    setSlackConnectionState("connected");
+    delete process.env.SLACK_APP_TOKEN;
+    expect(getMilestone(await buildStatusPayload(), "slack").state).toBe("unverified");
+  });
+
   test("slack: invalid mode fails closed with a specific hint", async () => {
     process.env.SLACK_MODE = "webhook";
     process.env.SLACK_BOT_TOKEN = "xoxb-test";
@@ -1064,6 +1086,19 @@ describe("computeHealth (Phase 2)", () => {
     expect(computeHealth(synthetic)).toBe("degraded");
   });
 
+  test("`ok` when a connected Slack reports `verified` next to other connected integrations", () => {
+    const synthetic: SetupMilestone[] = [
+      { id: "harness", label: "Harness", state: "verified" },
+      { id: "slack", label: "Slack", state: "verified" },
+      { id: "github", label: "GitHub", state: "verified" },
+      { id: "linear", label: "Linear", state: "verified" },
+      { id: "jira", label: "Jira", state: "unverified" },
+      { id: "workers", label: "Workers", state: "verified" },
+      { id: "first_task", label: "First task", state: "verified" },
+    ];
+    expect(computeHealth(synthetic)).toBe("ok");
+  });
+
   test("integrations in `unverified` alone do NOT degrade health", () => {
     // No integrations are connected — that's the common shape, not a
     // problem. Health should be `ok` as long as harness + workers verified.