@desplega.ai/agent-swarm 2.5.2 → 2.5.4

package/src/tests/session-logs.test.ts

@@ -5,6 +5,7 @@ import {
   closeDb,
   createSessionLogs,
   createTaskExtended,
+  getDbClient,
   getSessionLogsBySession,
   getSessionLogsByTaskId,
   getTaskById,
@@ -226,6 +227,75 @@ describe("Session Logs API", () => {
       expect(logs[3]?.iteration).toBe(2);
       expect(logs[3]?.lineNumber).toBe(1);
     });
+
+    test("keeps write order across many flushes of one iteration", async () => {
+      const task = await createTaskExtended("Task for multi-flush ordering");
+      // The runner flushes every 50 lines or 5s, so one iteration arrives as
+      // many POSTs. Each POST used to restart lineNumber at 0.
+      const written: string[] = [];
+      for (let flush = 0; flush < 3; flush++) {
+        const lines = [0, 1, 2, 3].map((i) => `flush${flush}-line${i}`);
+        written.push(...lines);
+        await createSessionLogs({
+          taskId: task.id,
+          sessionId: "multi-flush-session",
+          iteration: 1,
+          cli: "claude",
+          lines,
+        });
+      }
+
+      const all = await getSessionLogsByTaskId(task.id);
+      expect(all.map((l) => l.content)).toEqual(written);
+      expect(all.map((l) => l.lineNumber)).toEqual(written.map((_, i) => i));
+
+      const tail = await getSessionLogsByTaskId(task.id, 5);
+      expect(tail.map((l) => l.content)).toEqual(written.slice(-5));
+
+      const bySession = await getSessionLogsBySession("multi-flush-session", 1);
+      expect(bySession.map((l) => l.content)).toEqual(written);
+    });
+
+    test("reads rows stored with per-flush lineNumbers in write order", async () => {
+      const task = await createTaskExtended("Task with legacy session log rows");
+      // Rows written before the fix: lineNumber restarts per POST, and
+      // createdAt ties inside one POST.
+      const legacy = [
+        ["a0", 0],
+        ["a1", 1],
+        ["a2", 2],
+        ["b0", 0],
+        ["b1", 1],
+        ["c0", 0],
+      ] as const;
+      await getDbClient().transaction(async (tx) => {
+        for (const [content, lineNumber] of legacy) {
+          await tx.run(
+            `INSERT INTO session_logs (id, taskId, sessionId, iteration, cli, content, lineNumber, createdAt)
+             VALUES (?, ?, 'legacy-session', 1, 'claude', ?, ?, '2026-10-01T00:00:00.000Z')`,
+            [crypto.randomUUID(), task.id, content, lineNumber],
+          );
+        }
+      });
+      // A flush after deploy lands behind the legacy rows.
+      await createSessionLogs({
+        taskId: task.id,
+        sessionId: "legacy-session",
+        iteration: 1,
+        cli: "claude",
+        lines: ["d0", "d1"],
+      });
+
+      const written = ["a0", "a1", "a2", "b0", "b1", "c0", "d0", "d1"];
+      const all = await getSessionLogsByTaskId(task.id);
+      expect(all.map((l) => l.content)).toEqual(written);
+
+      const tail = await getSessionLogsByTaskId(task.id, 4);
+      expect(tail.map((l) => l.content)).toEqual(["b1", "c0", "d0", "d1"]);
+
+      const bySession = await getSessionLogsBySession("legacy-session", 1);
+      expect(bySession.map((l) => l.content)).toEqual(written);
+    });
   });
 
   describe("POST /api/session-logs", () => {

package/src/tests/sessions-tree.test.ts

@@ -4,6 +4,9 @@ import { keyPrefixRange, sessionGroupKey } from "../assets/key";
 import {
   closeDb,
   countSessions,
+  createAgent,
+  createSessionCost,
+  createSteeringMessage,
   createTaskExtended,
   createUser,
   getDbClient,
@@ -58,6 +61,7 @@ beforeAll(async () => {
 });
 beforeEach(async () => {
   await getDbClient().run("DELETE FROM approval_requests");
+  await getDbClient().run("DELETE FROM task_steering_messages");
   await getDbClient().run("DELETE FROM inbox_item_state");
   await getDbClient().run("DELETE FROM session_shares");
   await getDbClient().run("DELETE FROM agent_tasks");
@@ -195,7 +199,8 @@ describe("chain-wide read state", () => {
       { activity: "2026-10-14T12:00:00.000Z", expected: "read" },
       { status: "dismissed", updated: OLD, expected: "done" },
       { status: "done", updated: NOW, expected: "done" },
-      { status: "done", updated: OLD, expected: "unread" },
+      // Agent activity after the Done mark keeps it Done.
+      { status: "done", updated: OLD, expected: "done" },
       { status: "snoozed", snoozeUntil: "2026-10-22T12:00:00.000Z", expected: "later" },
       { status: "snoozed", snoozeUntil: NOW, expected: "unread" },
       { status: "snoozed", expected: "unread" },
@@ -259,6 +264,145 @@ describe("chain-wide read state", () => {
   });
 });
 
+describe("Done holds until the session needs the user", () => {
+  const DONE_AT = "2026-10-21T11:00:00.000Z";
+  const BEFORE = "2026-10-21T10:30:00.000Z";
+  const AFTER = "2026-10-21T11:30:00.000Z";
+  const readState = async (id: string) =>
+    (await listRecentSessions(filters({ limit: 100 }))).find((s) => s.root.id === id)?.readState;
+  const doneSession = async () => {
+    const root = await task("shared/", { source: "ui" }, BEFORE);
+    await getDbClient().run(
+      "UPDATE agent_tasks SET createdAt = ?, status = 'in_progress' WHERE id = ?",
+      [BEFORE, root.id],
+    );
+    await state(root.id, "done", DONE_AT);
+    expect(await readState(root.id)).toBe("done");
+    return root;
+  };
+  const child = async (
+    parentTaskId: string,
+    extra: Parameters<typeof createTaskExtended>[1],
+    createdAt = AFTER,
+  ) => {
+    const row = await createTaskExtended("Child", { parentTaskId, key: "shared/", ...extra });
+    await getDbClient().run(
+      "UPDATE agent_tasks SET createdAt = ?, lastUpdatedAt = ?, status = 'completed' WHERE id = ?",
+      [createdAt, createdAt, row.id],
+    );
+    return row;
+  };
+  const approval = async (taskId: string, createdAt: string, status = "pending") =>
+    getDbClient().run(
+      `INSERT INTO approval_requests (id, sourceTaskId, title, questions, approvers, status, createdAt)
+      VALUES (?, ?, 'Approve deploy', '[]', '{}', ?, ?)`,
+      [crypto.randomUUID(), taskId, status, createdAt],
+    );
+
+  test("agent progress and a status change keep it Done", async () => {
+    const root = await doneSession();
+    await getDbClient().run(
+      "UPDATE agent_tasks SET lastUpdatedAt = ?, status = 'completed' WHERE id = ?",
+      [AFTER, root.id],
+    );
+    expect(await readState(root.id)).toBe("done");
+    const tree = await getSessionTree(actor(), NOW);
+    expect(tree.done.total).toBe(1);
+    expect(tree.inbox.total).toBe(0);
+  });
+
+  test("agent-created child and delegated tasks keep it Done", async () => {
+    const root = await doneSession();
+    // Inherits the requester from its parent.
+    const inherited = await child(root.id, { source: "mcp" });
+    // Lead delegation, a deferred wake-up and a follow-up name the requester explicitly.
+    await child(inherited.id, { source: "mcp", requestedByUserId: owner.id });
+    await child(root.id, { source: "schedule", requestedByUserId: owner.id });
+    await child(root.id, { source: "system", requestedByUserId: owner.id });
+    await child(root.id, { source: "workflow", requestedByUserId: owner.id });
+    expect(await readState(root.id)).toBe("done");
+  });
+
+  test("a pending approval created after Done returns it to the Inbox", async () => {
+    const before = await doneSession();
+    await approval(before.id, BEFORE);
+    const resolved = await doneSession();
+    await approval(resolved.id, AFTER, "approved");
+    expect(await readState(before.id)).toBe("done");
+    expect(await readState(resolved.id)).toBe("done");
+
+    const root = await doneSession();
+    const agent = await child(root.id, { source: "mcp" });
+    await approval(agent.id, AFTER);
+    expect(await readState(root.id)).toBe("unread");
+    expect(await ids({ triage: "inbox" })).toEqual([root.id]);
+  });
+
+  test("a human follow-up after Done returns it to the Inbox", async () => {
+    const earlier = await doneSession();
+    await child(earlier.id, { source: "ui", requestedByUserId: owner.id }, BEFORE);
+    expect(await readState(earlier.id)).toBe("done");
+
+    const root = await doneSession();
+    await child(root.id, { source: "ui", requestedByUserId: owner.id });
+    expect(await readState(root.id)).toBe("unread");
+    const slack = await doneSession();
+    await child(slack.id, { source: "slack", requestedByUserId: other.id });
+    expect(await readState(slack.id)).toBe("unread");
+    const tree = await getSessionTree(actor(), NOW);
+    expect(tree.inbox.total).toBe(2);
+    expect(tree.done.total).toBe(1);
+  });
+
+  test("a person's steer or queued message after Done returns it to the Inbox", async () => {
+    // The real writer stamps created_at with the column default, after DONE_AT.
+    const steered = await doneSession();
+    await createSteeringMessage({
+      taskId: steered.id,
+      body: "Change course",
+      mode: "steer",
+      source: "ui",
+      createdByKind: "user",
+      createdByUserId: owner.id,
+    });
+    expect(await readState(steered.id)).toBe("unread");
+
+    const queued = await doneSession();
+    const agent = await child(queued.id, { source: "mcp" });
+    await createSteeringMessage({
+      taskId: agent.id,
+      body: "Also check this",
+      mode: "queue",
+      source: "slack",
+      createdByKind: "user",
+      createdByUserId: owner.id,
+    });
+    expect(await readState(queued.id)).toBe("unread");
+    expect((await ids({ triage: "inbox" })).sort()).toEqual([steered.id, queued.id].sort());
+  });
+
+  test("agent, system, cancelled and earlier steering keep it Done", async () => {
+    const steer = async (
+      taskId: string,
+      createdByKind: "user" | "agent" | "system",
+      createdAt = AFTER,
+      status = "pending",
+    ) =>
+      getDbClient().run(
+        `INSERT INTO task_steering_messages
+          (id, task_id, body, mode, status, source, created_by_kind, created_at)
+        VALUES (?, ?, 'Steer', 'queue', ?, 'mcp', ?, ?)`,
+        [crypto.randomUUID(), taskId, status, createdByKind, createdAt],
+      );
+    const root = await doneSession();
+    await steer(root.id, "agent");
+    await steer(root.id, "system");
+    await steer(root.id, "user", AFTER, "cancelled");
+    await steer(root.id, "user", BEFORE, "handled");
+    expect(await readState(root.id)).toBe("done");
+  });
+});
+
 test("needs attention uses the latest failed status and pending approvals anywhere in the chain", async () => {
   const failed = await task();
   const child = await task("shared/a/", { parentTaskId: failed.id }, NOW);
@@ -463,6 +607,41 @@ test("session detail carries the viewer's read state with the list rule", async
   expect(bypass.lastActivityAt).toBeUndefined();
 });
 
+test("session detail carries each chain task's cost, so the header can total the whole session", async () => {
+  const agent = await createAgent({ name: "cost-agent", isLead: false, status: "idle" });
+  const root = await task();
+  const child = await task("shared/a/", { parentTaskId: root.id });
+  const grandchild = await task("shared/a/", { parentTaskId: child.id });
+  const followUp = await task("shared/a/", { parentTaskId: root.id });
+  const noCost = await task("shared/a/", { parentTaskId: root.id });
+  const spend = async (taskId: string, totalCostUsd: number) =>
+    createSessionCost({
+      sessionId: crypto.randomUUID(),
+      taskId,
+      agentId: agent.id,
+      totalCostUsd,
+      durationMs: 1_000,
+      numTurns: 1,
+      model: "test-model",
+    });
+  await spend(root.id, 0.2);
+  await spend(root.id, 0.0051);
+  await spend(child.id, 0.5);
+  await spend(grandchild.id, 0.25);
+  await spend(followUp.id, 0.335);
+
+  const res = await fetch(`${baseUrl}/api/sessions/${root.id}`);
+  const body = (await res.json()) as { chain: { id: string; totalCostUsd?: number }[] };
+  const costs = Object.fromEntries(body.chain.map((t) => [t.id, t.totalCostUsd]));
+  expect(costs[root.id]).toBeCloseTo(0.2051, 6);
+  expect(costs[child.id]).toBeCloseTo(0.5, 6);
+  expect(costs[grandchild.id]).toBeCloseTo(0.25, 6);
+  expect(costs[followUp.id]).toBeCloseTo(0.335, 6);
+  expect(costs[noCost.id]).toBeUndefined();
+  const total = body.chain.reduce((sum, t) => sum + (t.totalCostUsd ?? 0), 0);
+  expect(total).toBeCloseTo(1.2901, 6);
+});
+
 test("limit clamps to 200 and count without chain filters does not recurse", async () => {
   await getDbClient().transaction(async () => {
     for (let i = 0; i < 205; i++)
@@ -591,6 +770,31 @@ describe("source filter and list triage", () => {
     );
   });
 
+  test("showSource keeps only the listed sources, and an empty list keeps none", async () => {
+    await task("shared/", { source: "slack" });
+    const ui = await task("shared/a/", { source: "ui" });
+    await task("shared/", { source: "github" });
+
+    const full = await treeOf();
+    const shown = await treeOf("showSource=ui");
+    expect(shown.inbox.total).toBe(1);
+    expect(shown.groups.map((g) => g.key)).toEqual(["shared/a/"]);
+    expect(shown.sources).toEqual(full.sources);
+    const inbox = await listOf("triage=inbox&showSource=ui");
+    expect(inbox.total).toBe(1);
+    expect(inbox.sessions.map((s) => s.root.id)).toEqual([ui.id]);
+
+    const none = await treeOf("showSource=");
+    expect(none.inbox.total).toBe(0);
+    expect(none.sources).toEqual(full.sources);
+    expect((await listOf("triage=inbox&showSource=")).total).toBe(0);
+
+    expect((await triage({ action: "done", triage: "inbox", showSource: ["ui"] })).status).toBe(
+      200,
+    );
+    expect((await listOf("triage=done")).sessions.map((s) => s.root.id)).toEqual([ui.id]);
+  });
+
   test("triage by list writes every matching session, honoring the list and the filters", async () => {
     const a = await task("shared/", { source: "ui" });
     const b = await task("shared/", { source: "ui" }, OLD);

package/src/tests/skill-search-long-content.test.ts

@@ -0,0 +1,193 @@
+import { Database } from "bun:sqlite";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createSkill,
+  deleteSkill,
+  getDb,
+  initDb,
+  searchSkills,
+  updateSkill,
+} from "../be/db";
+
+// Natural-language probes that missed on the live catalog: the obvious skill
+// has a long SKILL.md body, and a shorter skill repeats the query words in
+// its content. bm25 over the whole row buried the name/description hit.
+const TEST_DB_PATH = `./test-skill-search-long-content-${process.pid}.sqlite`;
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(path + suffix).catch(() => {});
+  }
+}
+
+async function topNames(query: string): Promise<string[]> {
+  return (await searchSkills(query, 10, false)).map((skill) => skill.name);
+}
+
+// A long body of words that no probe uses, like a full SKILL.md.
+const longBody = (topic: string) =>
+  `${topic}\n${"Each step lists its inputs, outputs and the checks to run afterwards. ".repeat(60)}`;
+
+describe("searchSkills on long skill bodies", () => {
+  beforeAll(async () => {
+    await removeDbFiles(TEST_DB_PATH);
+    initDb(TEST_DB_PATH);
+
+    const fixture = [
+      {
+        name: "pages",
+        description: "Publish hosted HTML pages with share links for outside readers.",
+        content: longBody("Hosted artifacts."),
+      },
+      {
+        name: "newsletter-sources",
+        description: "Weekly AI newsletter source list and reading picks.",
+        content: "Publish a short note for a page you read, then publish the page list. ".repeat(6),
+      },
+      {
+        name: "browser-interaction",
+        description: "Drive a headless browser.",
+        content: "Open a page, wait for a page to load, then read a page. ".repeat(6),
+      },
+      {
+        name: "scheduling",
+        description: "Recurring jobs with cron expressions: create, pause or resume a schedule.",
+        content: longBody("Cron jobs."),
+      },
+      {
+        name: "social-content",
+        description: "Draft social posts for the brand accounts.",
+        content: "How do I create a post? Create a draft, then schedule a post for a slot. ".repeat(
+          6,
+        ),
+      },
+      {
+        name: "code-quality",
+        description: "Checks to run before you push or open a pull request, and how to review one.",
+        content: longBody("Pre-push gate."),
+      },
+      {
+        name: "customer-ops",
+        description: "Operations runbook for one customer deployment.",
+        content:
+          "Open a pull request, ask a reviewer, review a pull request, request a fix. ".repeat(6),
+      },
+      // "get" is a stopword, and "aaa-get-helper" sorts first by name.
+      { name: "get", description: "Fetch API resources.", content: "fetch resources" },
+      { name: "aaa-get-helper", description: "Get helper instructions", content: "get content" },
+      { name: "what is it", description: "Release notes digest.", content: "notes" },
+      { name: "aaa-what-is-it", description: "What is it for, in short.", content: "notes" },
+    ];
+    for (const skill of fixture) await createSkill({ ...skill, scope: "swarm" });
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles(TEST_DB_PATH);
+  });
+
+  test.each([
+    ["publish a page", "pages"],
+    ["how do I create a schedule", "scheduling"],
+    ["how do I review a pull request", "code-quality"],
+  ])("%p ranks %p first over content that repeats the query words", async (query, expected) => {
+    expect((await topNames(query))[0]).toBe(expected);
+  });
+
+  test("stopwords do not match every skill", async () => {
+    // Every fixture body contains "a"; only skills about pages may match.
+    expect(await topNames("publish a page")).not.toContain("code-quality");
+  });
+
+  test("a query of only stopwords falls back to the substring match", async () => {
+    const names = await topNames("how do I");
+    expect(names).toContain("social-content");
+    expect(names).not.toContain("pages");
+  });
+
+  test.each([
+    "get",
+    "GET",
+    " Get ",
+  ])("an exact-name query of only stopwords (%p) ranks that skill first", async (query) => {
+    expect((await searchSkills(query, 1, false)).map((skill) => skill.name)).toEqual(["get"]);
+    expect((await topNames(query)).slice(0, 2)).toEqual(["get", "aaa-get-helper"]);
+  });
+
+  test("a multi-word exact name of only stopwords ranks first", async () => {
+    expect((await searchSkills("What Is It", 1, false)).map((skill) => skill.name)).toEqual([
+      "what is it",
+    ]);
+  });
+
+  test("keeps the name/description index in sync on update and delete", async () => {
+    const skill = await createSkill({
+      name: "meta-sync-probe",
+      description: "Starts with gammaword.",
+      content: "",
+      scope: "swarm",
+    });
+    const metaRows = (term: string) =>
+      getDb()
+        .query<{ skill_id: string }, [string]>(
+          "SELECT skill_id FROM skills_meta_fts WHERE skills_meta_fts MATCH ?",
+        )
+        .all(`"${term}"`)
+        .map((row) => row.skill_id);
+    expect(metaRows("gammaword")).toEqual([skill.id]);
+
+    await updateSkill(skill.id, { description: "Now about deltaword." });
+    expect(metaRows("gammaword")).toEqual([]);
+    expect(metaRows("deltaword")).toEqual([skill.id]);
+
+    await deleteSkill(skill.id);
+    expect(metaRows("deltaword")).toEqual([]);
+  });
+
+  test("migrated schema carries the name/description sync triggers", () => {
+    const triggers = getDb()
+      .query<{ name: string }, []>(
+        "SELECT name FROM sqlite_master WHERE type = 'trigger' AND tbl_name = 'skills' AND name LIKE 'skills_meta_fts_%' ORDER BY name",
+      )
+      .all()
+      .map((row) => row.name);
+    expect(triggers).toEqual([
+      "skills_meta_fts_delete",
+      "skills_meta_fts_insert",
+      "skills_meta_fts_update",
+    ]);
+  });
+});
+
+test("migration 241 backfills skills that existed before it ran", async () => {
+  const db = new Database(":memory:");
+  try {
+    db.exec(await Bun.file("src/be/migrations/019_skills.sql").text());
+    db.run(
+      "INSERT INTO skills (id, name, description, content, type, scope, createdAt, lastUpdatedAt) VALUES ('s1', 'legacy-skill', 'Old description', 'old body', 'remote', 'swarm', '2026-01-01', '2026-01-01')",
+    );
+    const migration = await Bun.file("src/be/migrations/241_skills_meta_fts.sql").text();
+    db.exec(migration);
+
+    const match = (term: string) =>
+      db
+        .query<{ skill_id: string }, [string]>(
+          "SELECT skill_id FROM skills_meta_fts WHERE skills_meta_fts MATCH ?",
+        )
+        .all(term)
+        .map((row) => row.skill_id);
+    expect(match('"description"')).toEqual(["s1"]);
+    // Content is not indexed here.
+    expect(match('"body"')).toEqual([]);
+
+    // Re-running the migration does not duplicate backfilled rows.
+    db.exec(migration);
+    expect(db.query<{ n: number }, []>("SELECT count(*) AS n FROM skills_meta_fts").get()?.n).toBe(
+      1,
+    );
+  } finally {
+    db.close();
+  }
+});