@desplega.ai/agent-swarm 2.7.5 → 2.7.7

package/src/tests/swarm-diff.test.ts

@@ -28,6 +28,16 @@ const EXAMPLE_HUNK = {
   ],
 };
 
+/** The rendered diff rows: old-side and new-side gutter numbers plus the row HTML. */
+function diffRows(html: string): { old: string; new: string; html: string }[] {
+  return [...html.matchAll(/<tr\b[^>]*>([\s\S]*?)<\/tr>/g)].map(([, row]) => {
+    const [oldCell = "", newCell = ""] = [
+      ...row!.matchAll(/<td class="swarm-diff-gutter"[^>]*>([^<]*)<\/td>/g),
+    ].map(([, cell]) => cell!);
+    return { old: oldCell, new: newCell, html: row! };
+  });
+}
+
 type StubInstance = {
   innerHTML: string;
   textContent: string;
@@ -55,12 +65,15 @@ function makeRig(
 ): {
   Ctor: new () => StubInstance;
   CursorsCtor: new () => StubInstance;
+  JumpsCtor: new () => StubInstance;
   SdkCtor?: new () => { room: (name?: string, options?: unknown) => Promise<unknown> };
   body: StubInstance;
   setText: (el: StubInstance, attrs: Record<string, string>, text: string) => void;
   fireDocumentEvent: (name: string, event: unknown) => void;
   fireNextFrame: () => void;
   flushMicrotasks: () => Promise<void>;
+  /** Sets what `document.querySelectorAll` returns (the jump list's anchors). */
+  setAnchors: (anchors: unknown[]) => void;
 } {
   const registry = new Map<string, new () => StubInstance>();
   const documentListeners = new Map<string, ((event: unknown) => void)[]>();
@@ -143,12 +156,13 @@ function makeRig(
 
   // Provide `document` stubs the jump-list path uses.
   const body = new StubHTMLElement();
+  let anchors: unknown[] = [];
   const doc = {
     readyState,
     documentElement: { scrollWidth: 1000, scrollHeight: 500, clientWidth: 1000, clientHeight: 500 },
     body,
     createElement: () => new StubHTMLElement(),
-    querySelectorAll: () => [],
+    querySelectorAll: () => anchors,
     addEventListener: (name: string, handler: (event: unknown) => void) => {
       const handlers = documentListeners.get(name) ?? [];
       handlers.push(handler);
@@ -176,7 +190,7 @@ function makeRig(
     "CustomEvent",
     "queueMicrotask",
     "console",
-    `${SWARM_UI_JS}\nreturn { diff: window.customElements.get('swarm-diff'), cursors: window.customElements.get('swarm-cursors'), sdk: window.SwarmSDK };`,
+    `${SWARM_UI_JS}\nreturn { diff: window.customElements.get('swarm-diff'), cursors: window.customElements.get('swarm-cursors'), jumps: window.customElements.get('swarm-diff-jumps'), sdk: window.SwarmSDK };`,
   );
   const constructors = factory(
     win,
@@ -189,16 +203,20 @@ function makeRig(
   ) as {
     diff?: new () => StubInstance;
     cursors?: new () => StubInstance;
+    jumps?: new () => StubInstance;
     sdk?: new () => { room: (name?: string, options?: unknown) => Promise<unknown> };
   };
   const Ctor = constructors.diff;
   if (!Ctor) throw new Error("custom element did not register");
   const CursorsCtor = constructors.cursors;
   if (!CursorsCtor) throw new Error("swarm-cursors custom element did not register");
+  const JumpsCtor = constructors.jumps;
+  if (!JumpsCtor) throw new Error("swarm-diff-jumps custom element did not register");
 
   return {
     Ctor,
     CursorsCtor,
+    JumpsCtor,
     SdkCtor: constructors.sdk,
     body,
     setText(el, attrs, text) {
@@ -220,6 +238,9 @@ function makeRig(
       // Drain the chained async room-open and render callbacks.
       for (let i = 0; i < 5; i++) await Promise.resolve();
     },
+    setAnchors(list) {
+      anchors = list;
+    },
   };
 }
 
@@ -517,6 +538,58 @@ describe("<swarm-diff> render", () => {
     expect(html).toContain("Avoid raw console.log");
   });
 
+  test("shows an annotation once, on its new-side line, not on a context row with that old-side number", async () => {
+    // Three added lines shift the new side: the context row `});` is old 63,
+    // new 66, and the annotation names new line 63.
+    const shifted = {
+      hunks: [
+        {
+          old_start: 60,
+          old_lines: 4,
+          new_start: 60,
+          new_lines: 7,
+          lines: [
+            { type: "context", text: "start();" },
+            { type: "add", text: "one();" },
+            { type: "add", text: "two();" },
+            { type: "add", text: "three();" },
+            { type: "context", text: "four();" },
+            { type: "context", text: "five();" },
+            { type: "context", text: "});" },
+          ],
+          annotations: [{ line: 63, severity: "warn", text: "Note on new line 63" }],
+        },
+      ],
+    };
+    const html = await renderViaStub(JSON.stringify(shifted), { file: "src/a.ts" });
+    const rows = diffRows(html);
+    expect(rows.find((row) => row.html.includes("});"))).toMatchObject({ old: "63", new: "66" });
+    const annotated = rows.filter((row) => row.html.includes("Note on new line 63"));
+    expect(annotated.map((row) => [row.old, row.new])).toEqual([["", "63"]]);
+  });
+
+  test("matches a deleted row's annotation on its old-side number", async () => {
+    const deleted = {
+      hunks: [
+        {
+          old_start: 10,
+          old_lines: 3,
+          new_start: 20,
+          new_lines: 2,
+          lines: [
+            { type: "context", text: "keep();" },
+            { type: "del", text: "drop();" },
+            { type: "context", text: "keepToo();" },
+          ],
+          annotations: [{ line: 11, severity: "error", text: "Why drop this?" }],
+        },
+      ],
+    };
+    const html = await renderViaStub(JSON.stringify(deleted), { file: "src/b.ts" });
+    const annotated = diffRows(html).filter((row) => row.html.includes("Why drop this?"));
+    expect(annotated.map((row) => [row.old, row.new])).toEqual([["11", ""]]);
+  });
+
   test("handles empty/missing JSON body gracefully (no rows, no throw)", async () => {
     const html = await renderViaStub("", { file: "empty.ts" });
     // Should still render an outer container with the file name.
@@ -545,6 +618,52 @@ describe("<swarm-diff> render", () => {
   });
 });
 
+describe("<swarm-diff-jumps> labels", () => {
+  const hunk = (oldStart: number, newStart: number) => ({
+    old_start: oldStart,
+    old_lines: 1,
+    new_start: newStart,
+    new_lines: 1,
+    lines: [{ type: "context", text: "x();" }],
+  });
+
+  test("a file with more than one hunk shows each hunk's new-side start line", async () => {
+    const rig = makeRig();
+    const render = async (file: string, hunks: unknown[]) => {
+      const el = new rig.Ctor();
+      rig.setText(el, { file }, JSON.stringify({ hunks }));
+      el.connectedCallback?.();
+      await rig.flushMicrotasks();
+      return el;
+    };
+    // The anchors the jump list finds in the document, built from the rendered HTML.
+    const anchorsOf = (diff: StubInstance) =>
+      [
+        ...diff.innerHTML.matchAll(
+          /<a id="([^"]*)" class="swarm-diff-anchor" data-hunk="([^"]*)" data-new-start="([^"]*)"><\/a>/g,
+        ),
+      ].map(([, id, slug, newStart]) => {
+        const attrs: Record<string, string> = { "data-hunk": slug!, "data-new-start": newStart! };
+        return { id, getAttribute: (name: string) => attrs[name] ?? null, closest: () => diff };
+      });
+    const x = await render("src/x.ts", [hunk(10, 58), hunk(100, 120)]);
+    const y = await render("src/y.ts", [hunk(5, 5)]);
+    rig.setAnchors([...anchorsOf(x), ...anchorsOf(y)]);
+
+    const jumps = new rig.JumpsCtor();
+    jumps.connectedCallback?.();
+    await rig.flushMicrotasks();
+    const links = [
+      ...jumps.innerHTML.matchAll(/<a href="#([^"]*)" target="_self"[^>]*>([^<]*)<\/a>/g),
+    ].map(([, href, label]) => [href, label]);
+    expect(links).toEqual([
+      ["swarm-diff-src-x-ts-10", "src/x.ts:58"],
+      ["swarm-diff-src-x-ts-100", "src/x.ts:120"],
+      ["swarm-diff-src-y-ts-5", "src/y.ts"],
+    ]);
+  });
+});
+
 describe("<swarm-diff> parse-order regression (Bug #479-1)", () => {
   // Real browsers fire connectedCallback when the parser sees the opening
   // tag, BEFORE the JSON text children are parsed. The element MUST defer

package/src/tests/task-auto-title-config-guard.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { validateConfigValue } from "../be/swarm-config-guard";
+
+describe("task auto-title config validation", () => {
+  test("TASK_AUTO_TITLE_ENABLED accepts boolean literals only", () => {
+    expect(validateConfigValue("TASK_AUTO_TITLE_ENABLED", "true")).toBeNull();
+    expect(validateConfigValue("TASK_AUTO_TITLE_ENABLED", "false")).toBeNull();
+    expect(validateConfigValue("TASK_AUTO_TITLE_ENABLED", "maybe")).toMatch(
+      /TASK_AUTO_TITLE_ENABLED/,
+    );
+  });
+
+  test("TASK_AUTO_TITLE_MODEL accepts provider/model-id for a callable provider, a claude alias, or empty", () => {
+    for (const value of [
+      "openrouter/deepseek/deepseek-v4.1-flash",
+      "anthropic/claude-haiku-5-5",
+      "openai/gpt-5-nano",
+      "openai-codex/gpt-6-luna",
+      "haiku",
+      "",
+      "  anthropic/claude-haiku-5-5  ",
+    ]) {
+      expect(validateConfigValue("TASK_AUTO_TITLE_MODEL", value)).toBeNull();
+    }
+  });
+
+  test("TASK_AUTO_TITLE_MODEL rejects unsupported providers and malformed strings", () => {
+    expect(validateConfigValue("TASK_AUTO_TITLE_MODEL", "google/gemini-2.5-flash-lite")).toMatch(
+      /provider must be/,
+    );
+    expect(validateConfigValue("TASK_AUTO_TITLE_MODEL", "openai/")).toMatch(/provider\/model-id/);
+    expect(validateConfigValue("TASK_AUTO_TITLE_MODEL", "openai/gpt 5")).toMatch(
+      /provider\/model-id/,
+    );
+    expect(validateConfigValue("TASK_AUTO_TITLE_MODEL", 42)).toMatch(/must be a string/);
+  });
+});

package/src/tests/task-auto-title-listener.test.ts

@@ -0,0 +1,165 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getTaskById,
+  initDb,
+  updateTaskTitle,
+} from "../be/db";
+import { setTaskTitleIfUnset } from "../be/db/tasks/write";
+import {
+  isTaskAutoTitleEnabled,
+  startTaskAutoTitleListener,
+  type TaskAutoTitleListener,
+} from "../be/task-auto-title-listener";
+import type { generateTaskTitle } from "../utils/internal-ai/task-title";
+import { workflowEventBus } from "../workflows/event-bus";
+
+const TEST_DB_PATH = "./test-task-auto-title-listener.sqlite";
+
+/**
+ * `createTaskExtended` emits `task.created` from an after-commit hook that
+ * imports the event bus asynchronously, so the event lands after the call
+ * returns. Create the task through this helper to await that emission.
+ */
+async function createTaskAndAwaitEvent(task: string): Promise<string> {
+  const created = new Promise<void>((resolve) => {
+    const handler = () => {
+      workflowEventBus.off("task.created", handler);
+      resolve();
+    };
+    workflowEventBus.on("task.created", handler);
+  });
+  const row = await createTaskExtended(task, { agentId, source: "api" });
+  await created;
+  return row.id;
+}
+const LONG_TASK =
+  "Investigate why the nightly Playwright suite times out on the sessions page after the sidebar redesign and fix the flake.";
+
+let agentId: string;
+let listener: TaskAutoTitleListener | null = null;
+
+type Generate = typeof generateTaskTitle;
+
+/** Generator stub that returns `title` and records every prompt it saw. */
+function generator(title: string | null, seen: string[] = []) {
+  const generate: Generate = async (opts) => {
+    seen.push(opts.task);
+    return title
+      ? { ok: true, title, model: "test/model", kind: "openrouter" }
+      : { ok: false, reason: "all-models-failed" };
+  };
+  return { generate, seen };
+}
+
+beforeAll(async () => {
+  initDb(TEST_DB_PATH);
+  agentId = (await createAgent({ name: "auto-title-worker", isLead: false, status: "idle" })).id;
+});
+
+afterEach(() => {
+  listener?.stop();
+  listener = null;
+});
+
+afterAll(async () => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+
+describe("isTaskAutoTitleEnabled", () => {
+  test("defaults on and honours false-ish values", () => {
+    expect(isTaskAutoTitleEnabled({})).toBe(true);
+    expect(isTaskAutoTitleEnabled({ TASK_AUTO_TITLE_ENABLED: "" })).toBe(true);
+    expect(isTaskAutoTitleEnabled({ TASK_AUTO_TITLE_ENABLED: "false" })).toBe(false);
+    expect(isTaskAutoTitleEnabled({ TASK_AUTO_TITLE_ENABLED: "0" })).toBe(false);
+    expect(isTaskAutoTitleEnabled({ TASK_AUTO_TITLE_ENABLED: "true" })).toBe(true);
+  });
+});
+
+describe("setTaskTitleIfUnset", () => {
+  test("writes once and never replaces an existing title", async () => {
+    const task = await createTaskExtended(LONG_TASK, { agentId, source: "api" });
+    expect(task.title).toBeUndefined();
+
+    const first = await setTaskTitleIfUnset(task.id, "  Generated title  ");
+    expect(first?.title).toBe("Generated title");
+
+    const second = await setTaskTitleIfUnset(task.id, "Another title");
+    expect(second).toBeNull();
+    expect((await getTaskById(task.id))?.title).toBe("Generated title");
+
+    expect(await setTaskTitleIfUnset(task.id, "   ")).toBeNull();
+  });
+});
+
+describe("startTaskAutoTitleListener", () => {
+  test("titles a new task after commit", async () => {
+    const { generate, seen } = generator("Fix sessions page Playwright flake");
+    listener = startTaskAutoTitleListener({ env: {}, generate });
+
+    const taskId = await createTaskAndAwaitEvent(LONG_TASK);
+    await listener.idle();
+
+    expect(seen).toEqual([LONG_TASK]);
+    expect((await getTaskById(taskId))?.title).toBe("Fix sessions page Playwright flake");
+  });
+
+  test("keeps a title a person set while the model was running", async () => {
+    let release: () => void = () => {};
+    const gate = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const generate: Generate = async () => {
+      await gate;
+      return { ok: true, title: "Model title", model: "test/model", kind: "openrouter" };
+    };
+    listener = startTaskAutoTitleListener({ env: {}, generate });
+
+    const taskId = await createTaskAndAwaitEvent(LONG_TASK);
+    await updateTaskTitle(taskId, "Human title");
+    release();
+    await listener.idle();
+
+    expect((await getTaskById(taskId))?.title).toBe("Human title");
+  });
+
+  test("leaves the task untouched when generation fails", async () => {
+    const { generate, seen } = generator(null);
+    listener = startTaskAutoTitleListener({ env: {}, generate });
+
+    const taskId = await createTaskAndAwaitEvent(LONG_TASK);
+    await listener.idle();
+
+    expect(seen.length).toBe(1);
+    expect((await getTaskById(taskId))?.title).toBeUndefined();
+  });
+
+  test("does nothing when TASK_AUTO_TITLE_ENABLED is false", async () => {
+    const { generate, seen } = generator("Should not land");
+    listener = startTaskAutoTitleListener({ env: { TASK_AUTO_TITLE_ENABLED: "false" }, generate });
+
+    const taskId = await createTaskAndAwaitEvent(LONG_TASK);
+    await listener.idle();
+
+    expect(seen).toEqual([]);
+    expect((await getTaskById(taskId))?.title).toBeUndefined();
+  });
+
+  test("stop() detaches from the event bus", async () => {
+    const { generate, seen } = generator("Late title");
+    const handle = startTaskAutoTitleListener({ env: {}, generate });
+    handle.stop();
+
+    await createTaskAndAwaitEvent(LONG_TASK);
+    await handle.idle();
+    expect(seen).toEqual([]);
+  });
+});

package/src/tests/tasks-readable-row.test.ts

@@ -0,0 +1,155 @@
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, getAllTasks, getDb, getDbClient, initDb } from "../be/db";
+import { readableSessionCondition } from "../be/db/tasks/read";
+
+const TEST_DB_PATH = "./test-tasks-readable-row.sqlite";
+const AT = "2026-10-01T00:00:00.000Z";
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"])
+    await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => undefined);
+}
+
+async function task(
+  id: string,
+  opts: { parent?: string; owner?: string; scheduleId?: string } = {},
+): Promise<void> {
+  await getDbClient().run(
+    `INSERT INTO agent_tasks (id, task, status, source, parentTaskId, requestedByUserId, scheduleId,
+       createdAt, lastUpdatedAt)
+     VALUES (?, ?, 'completed', 'api', ?, ?, ?, ?, ?)`,
+    [id, `task ${id}`, opts.parent ?? null, opts.owner ?? null, opts.scheduleId ?? null, AT, AT],
+  );
+}
+
+describe("readableSessionRowCondition", () => {
+  beforeAll(async () => {
+    await removeDbFiles();
+    initDb(TEST_DB_PATH);
+    for (const id of ["u1", "u2", "u3"]) {
+      await getDbClient().run(
+        "INSERT INTO users (id, name, role, status, createdAt, lastUpdatedAt) VALUES (?, ?, 'member', 'active', ?, ?)",
+        [id, id, AT, AT],
+      );
+    }
+    // u1's session, three deep.
+    await task("a", { owner: "u1" });
+    await task("a1", { parent: "a", owner: "u1" });
+    await task("a2", { parent: "a1" });
+    // u2's session, with a child that names u1.
+    await task("b", { owner: "u2" });
+    await task("b1", { parent: "b", owner: "u1" });
+    // u2's schedule run: everyone reads it.
+    await task("c", { owner: "u2", scheduleId: "schedule-1" });
+    await task("c1", { parent: "c" });
+    // u2's session shared with u1, and one shared with everyone.
+    await task("d", { owner: "u2" });
+    await task("d1", { parent: "d" });
+    await task("e", { owner: "u2" });
+    await getDbClient().run(
+      `INSERT INTO session_shares (id, rootTaskId, userId, access, createdAt)
+       VALUES ('share-d', 'd', 'u1', 'read', ?), ('share-e', 'e', NULL, 'read', ?)`,
+      [AT, AT],
+    );
+    // A revoked share hides again.
+    await task("f", { owner: "u2" });
+    await getDbClient().run(
+      `INSERT INTO session_shares (id, rootTaskId, userId, access, createdAt, revokedAt)
+       VALUES ('share-f', 'f', 'u1', 'read', ?, ?)`,
+      [AT, AT],
+    );
+    // A session nobody owns.
+    await task("g");
+    await task("g1", { parent: "g", owner: "u2" });
+    // Orphan subtrees: the top's parent is gone, so the top is the root.
+    await task("h", { owner: "u2" });
+    await task("h1", { parent: "h" });
+    await task("h2", { parent: "h1", owner: "u1" });
+    await task("i", { owner: "u1" });
+    await task("i1", { parent: "i", owner: "u2" });
+    await task("i2", { parent: "i1" });
+    // Chains deeper than the walk's hop limit fall back to the set form.
+    for (const [root, owner] of [
+      ["deep-u1", "u1"],
+      ["deep-u2", "u2"],
+    ] as const) {
+      await task(root, { owner });
+      let parent: string = root;
+      for (let i = 1; i <= 70; i++) {
+        await task(`${root}-${i}`, { parent });
+        parent = `${root}-${i}`;
+      }
+    }
+    getDb().run("PRAGMA foreign_keys = OFF");
+    getDb().run("DELETE FROM agent_tasks WHERE id IN ('h', 'i')");
+    getDb().run("PRAGMA foreign_keys = ON");
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles();
+  });
+
+  for (const userId of ["u1", "u2", "u3", null]) {
+    test(`the page shows the rows the set form shows, for ${userId ?? "a guest"}`, async () => {
+      const set = readableSessionCondition(userId);
+      const expected = (
+        await getDbClient().query<{ id: string }>(
+          `SELECT id FROM agent_tasks WHERE ${set.sql} ORDER BY id`,
+          set.params,
+        )
+      ).map((row) => row.id);
+      const page = await getAllTasks({ readableBy: { userId }, limit: 1000 });
+      expect(page.map((t) => t.id).sort()).toEqual(expected);
+    });
+  }
+
+  test("u1 sees exactly the expected sessions", async () => {
+    const page = await getAllTasks({ readableBy: { userId: "u1" }, limit: 1000 });
+    const deep = Array.from({ length: 70 }, (_, i) => `deep-u1-${i + 1}`);
+    expect(page.map((t) => t.id).sort()).toEqual(
+      [
+        "a",
+        "a1",
+        "a2",
+        "c",
+        "c1",
+        "d",
+        "d1",
+        "e",
+        "g",
+        "g1",
+        "h1",
+        "h2",
+        "deep-u1",
+        ...deep,
+      ].sort(),
+    );
+  });
+
+  test("the page walks up from each row it reads", async () => {
+    const query = spyOn(getDbClient(), "query");
+    let sql = "";
+    let params: unknown[] = [];
+    try {
+      await getAllTasks({ status: "completed", readableBy: { userId: "u1" } });
+      [sql, params = []] = query.mock.calls.find(([s]) => s.includes("WITH page AS"))! as [
+        string,
+        unknown[]?,
+      ];
+    } finally {
+      query.mockRestore();
+    }
+    const plan = getDb()
+      .query<{ detail: string }, any[]>(`EXPLAIN QUERY PLAN ${sql}`)
+      .all(...(params as any[]))
+      .map((row) => row.detail)
+      .join("\n");
+    // The walk is a correlated lookup per row. The set form appears only as
+    // the fallback branch, which SQLite builds when a walk finds no root.
+    expect(plan).toContain("CORRELATED SCALAR SUBQUERY");
+    expect(plan).toContain("SEARCH u USING INDEX sqlite_autoindex_agent_tasks_1 (id=?)");
+    expect(plan).toContain("SEARCH p USING INDEX sqlite_autoindex_agent_tasks_1 (id=?)");
+  });
+});