@desplega.ai/agent-swarm 2.5.1 → 2.5.3

package/src/tests/script-run-config-scope.test.ts

@@ -0,0 +1,120 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { randomBytes } from "node:crypto";
+import { createServer, type Server } from "node:http";
+import { closeDb, createAgent, initDb, upsertSwarmConfig } from "../be/db";
+import { mintScriptRunToken, revokeSessionToken } from "../be/users";
+import { handleConfig } from "../http/config";
+import { handleCore } from "../http/core";
+import { handleSessions } from "../http/sessions";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { listenOnFreePort } from "./test-net";
+
+// A script run presents a token minted by `mintScriptRunToken` (the api does
+// this per run instead of handing the script the operator key). These tests
+// pin that the token is scoped to its executing agent at the config layer, so
+// a worker's inline script cannot read another agent's secret or delete its
+// config row — the escalation that running as the operator allowed.
+const API_KEY = `script-run-config-operator-${randomBytes(8).toString("hex")}`;
+const WORKER_SECRET = `worker-secret-${randomBytes(8).toString("hex")}`;
+const OTHER_SECRET = `other-secret-${randomBytes(8).toString("hex")}`;
+
+let server: Server;
+let baseUrl: string;
+let workerId: string;
+let otherId: string;
+let otherConfigId: string;
+
+function headers(bearer: string, agentId?: string): Record<string, string> {
+  return {
+    Authorization: `Bearer ${bearer}`,
+    "Content-Type": "application/json",
+    ...(agentId ? { "X-Agent-ID": agentId } : {}),
+  };
+}
+
+beforeAll(async () => {
+  initDb(":memory:");
+  workerId = (await createAgent({ name: "script-run-worker", isLead: false, status: "idle" })).id;
+  otherId = (await createAgent({ name: "script-run-other", isLead: false, status: "idle" })).id;
+  await upsertSwarmConfig({
+    scope: "agent",
+    scopeId: workerId,
+    key: "OWN_SECRET",
+    value: WORKER_SECRET,
+    isSecret: true,
+  });
+  otherConfigId = (
+    await upsertSwarmConfig({
+      scope: "agent",
+      scopeId: otherId,
+      key: "OTHER_SECRET",
+      value: OTHER_SECRET,
+      isSecret: true,
+    })
+  ).id;
+  server = createServer(async (req, res) => {
+    if (await handleCore(req, res, req.headers["x-agent-id"] as string | undefined, API_KEY))
+      return;
+    const segments = getPathSegments(req.url || "");
+    const query = parseQueryParams(req.url || "");
+    if (await handleSessions(req, res, segments, query)) return;
+    if (await handleConfig(req, res, segments, query)) return;
+    res.writeHead(404).end();
+  });
+  baseUrl = `http://127.0.0.1:${await listenOnFreePort(server)}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+});
+
+describe("script run token is scoped to its executing agent", () => {
+  test("reads its own agent's secret", async () => {
+    const run = await mintScriptRunToken(workerId, 60_000);
+    try {
+      const res = await fetch(`${baseUrl}/api/config/resolved?includeSecrets=true`, {
+        headers: headers(run.plaintext),
+      });
+      expect(res.status).toBe(200);
+      expect(await res.text()).toContain(WORKER_SECRET);
+    } finally {
+      await revokeSessionToken(run.tokenId);
+    }
+  });
+
+  test("cannot read another agent's secret", async () => {
+    const run = await mintScriptRunToken(workerId, 60_000);
+    try {
+      const res = await fetch(
+        `${baseUrl}/api/config/resolved?includeSecrets=true&agentId=${otherId}`,
+        { headers: headers(run.plaintext) },
+      );
+      // X-Agent-ID is forced to the token's agent, so this reads the worker's
+      // own scope; either way the other agent's secret never comes back.
+      const body = await res.text();
+      expect(body).not.toContain(OTHER_SECRET);
+    } finally {
+      await revokeSessionToken(run.tokenId);
+    }
+  });
+
+  test("cannot delete another agent's config row", async () => {
+    const run = await mintScriptRunToken(workerId, 60_000);
+    try {
+      const res = await fetch(`${baseUrl}/api/config/${otherConfigId}`, {
+        method: "DELETE",
+        headers: headers(run.plaintext),
+      });
+      await res.text();
+      expect(res.status).toBe(403);
+      // The row is still there, read back as operator.
+      const check = await fetch(`${baseUrl}/api/config/${otherConfigId}`, {
+        headers: headers(API_KEY),
+      });
+      expect(check.status).toBe(200);
+    } finally {
+      await revokeSessionToken(run.tokenId);
+    }
+  });
+});

package/src/tests/script-run-token.test.ts

@@ -0,0 +1,75 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { randomBytes } from "node:crypto";
+import { closeDb, createAgent, initDb } from "../be/db";
+import {
+  AgentTokenExistsError,
+  mintAgentToken,
+  mintScriptRunToken,
+  resolveSessionToken,
+  revokeAgentTokens,
+  revokeSessionToken,
+} from "../be/users";
+
+const synthetic = (label: string) => `script-run-token-${label}-${randomBytes(8).toString("hex")}`;
+
+let agentId: string;
+let otherId: string;
+
+beforeAll(async () => {
+  initDb(":memory:");
+  agentId = (await createAgent({ name: synthetic("agent"), isLead: false, status: "idle" })).id;
+  otherId = (await createAgent({ name: synthetic("other"), isLead: false, status: "idle" })).id;
+});
+
+afterAll(() => {
+  closeDb();
+});
+
+describe("mintScriptRunToken", () => {
+  test("resolves to the executing agent as an agent principal", async () => {
+    const token = await mintScriptRunToken(agentId, 60_000);
+    expect(token.plaintext.startsWith("aseph_")).toBe(true);
+
+    const resolved = await resolveSessionToken(token.plaintext);
+    expect(resolved).not.toBeNull();
+    if (resolved?.kind !== "agent") throw new Error("expected an agent principal");
+    expect(resolved.agentId).toBe(agentId);
+    expect(resolved.tokenKind).toBe("agent");
+    expect(resolved.taskId).toBeNull();
+    expect(resolved.runtimeId).toBeNull();
+
+    await revokeSessionToken(token.tokenId);
+  });
+
+  test("does not count as the agent's worker token", async () => {
+    // A script run must be able to mint its token while the agent already
+    // holds a worker token, and vice versa: the two lifecycles are separate.
+    const worker = await mintAgentToken(agentId);
+    const run = await mintScriptRunToken(agentId, 60_000);
+
+    expect(run.tokenId).not.toBe(worker.tokenId);
+    // The worker token is unique per agent; minting a second would throw. The
+    // script run token sharing the agent did not trip that uniqueness.
+    await expect(mintAgentToken(agentId)).rejects.toBeInstanceOf(AgentTokenExistsError);
+
+    await revokeSessionToken(run.tokenId);
+    await revokeAgentTokens(agentId);
+  });
+
+  test("survives a revoke of the agent's worker tokens", async () => {
+    const worker = await mintAgentToken(otherId);
+    const run = await mintScriptRunToken(otherId, 60_000);
+
+    // Revoking the agent's worker tokens (worker-token revoke / rotate) must
+    // not revoke a script run's in-flight token.
+    await revokeAgentTokens(otherId);
+
+    expect(await resolveSessionToken(worker.plaintext)).toBeNull();
+    const stillValid = await resolveSessionToken(run.plaintext);
+    expect(stillValid).not.toBeNull();
+    expect(stillValid?.agentId).toBe(otherId);
+
+    await revokeSessionToken(run.tokenId);
+    expect(await resolveSessionToken(run.plaintext)).toBeNull();
+  });
+});

package/src/tests/scripts-http.test.ts

@@ -574,6 +574,25 @@ describe("/api/scripts HTTP", () => {
     ).toBe(beforeFailed);
   });
 
+  skip("a run mints a per-run token for its agent and revokes it when the run ends", async () => {
+    const tokens = () =>
+      getDbClient().query<{ revokedAt: string | null }>(
+        "SELECT revokedAt FROM session_tokens WHERE agentId = ? AND scriptRun = 1",
+        [workerId],
+      );
+    const before = (await tokens()).length;
+    const res = await dispatch("/api/scripts/run", {
+      method: "POST",
+      agentId: workerId,
+      body: JSON.stringify({ source: validSource(2), args: { value: 2 }, intent: "token" }),
+    });
+    expect(res.status).toBe(200);
+    expect((await res.json()).result).toEqual({ result: 4 });
+    const minted = (await tokens()).slice(before);
+    expect(minted).toHaveLength(1);
+    expect(minted[0]?.revokedAt).not.toBeNull();
+  });
+
   test("workspace-rw named scripts return 501", async () => {
     await upsert({ name: "workspace", source: validSource(2), fsMode: "workspace-rw" });
     const res = await dispatch("/api/scripts/run", {

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

@@ -4,6 +4,7 @@ import { keyPrefixRange, sessionGroupKey } from "../assets/key";
 import {
   closeDb,
   countSessions,
+  createSteeringMessage,
   createTaskExtended,
   createUser,
   getDbClient,
@@ -58,6 +59,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 +197,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 +262,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);
@@ -491,3 +633,270 @@ test("limit clamps to 200 and count without chain filters does not recurse", asy
   expect(body.sessions).toHaveLength(200);
   expect(body.total).toBe(205);
 });
+
+describe("Mine view hides machine-started roots", () => {
+  test("a workflow root attributed to the viewer is hidden by default and shown under All", async () => {
+    // Positive control: pr-review-demo fan-out carries the trigger user as requester.
+    const demo = await task("shared/", { source: "workflow", tags: ["pr-review-demo"] });
+    const scheduled = await task("shared/", { source: "schedule" });
+    const heartbeat = await task("shared/", { source: "system" });
+    // Negative controls: the viewer's own human sessions stay.
+    const slack = await task("shared/", { source: "slack" });
+    const ui = await task("shared/", { source: "ui" });
+    const whatsapp = await task("shared/", { source: "system", taskType: "kapso-inbound" });
+    // A workflow root someone else shared with the viewer stays too.
+    const sharedRun = await task("shared/", { source: "workflow", requestedByUserId: other.id });
+    await share(sharedRun);
+    // Ownerless roots stay out of both views, as before.
+    await task("shared/", { source: "workflow", requestedByUserId: undefined });
+
+    const headers = { "x-swarm-user-id": owner.id };
+    const list = async (query: string) => {
+      const res = await fetch(`${baseUrl}/api/sessions?scope=tree&limit=50&${query}`, { headers });
+      const body = (await res.json()) as { total: number; sessions: { root: { id: string } }[] };
+      expect(body.sessions).toHaveLength(body.total);
+      return body.sessions.map((s) => s.root.id).sort();
+    };
+    const tree = async (query: string) => {
+      const res = await fetch(`${baseUrl}/api/session-tree?${query}`, { headers });
+      return ((await res.json()) as Awaited<ReturnType<typeof getSessionTree>>).noGroup.total;
+    };
+
+    const mine = [slack.id, ui.id, whatsapp.id, sharedRun.id].sort();
+    const all = [...mine, demo.id, scheduled.id, heartbeat.id].sort();
+    expect(await list("")).toEqual(mine);
+    expect(await list("show=mine")).toEqual(mine);
+    expect(await list("show=all")).toEqual(all);
+    expect(await tree("")).toBe(mine.length);
+    expect(await tree("show=all")).toBe(all.length);
+
+    // No picked user: the bypass actor still sees every root, ownerless included.
+    const bypass = await fetch(`${baseUrl}/api/sessions?scope=tree&limit=50`);
+    expect(((await bypass.json()) as { total: number }).total).toBe(all.length + 1);
+    // Access is unchanged: the hidden session still opens by direct link.
+    const detail = await fetch(`${baseUrl}/api/sessions/${demo.id}`, { headers });
+    expect(detail.status).toBe(200);
+  });
+});
+
+describe("source filter and list triage", () => {
+  const asOwner = () => ({ "x-swarm-user-id": owner.id, "content-type": "application/json" });
+  const treeOf = async (query = "") => {
+    const res = await fetch(`${baseUrl}/api/session-tree?${query}`, { headers: asOwner() });
+    expect(res.status).toBe(200);
+    return (await res.json()) as Awaited<ReturnType<typeof getSessionTree>>;
+  };
+  const listOf = async (query: string) => {
+    const res = await fetch(`${baseUrl}/api/sessions?scope=tree&limit=50&${query}`, {
+      headers: asOwner(),
+    });
+    const body = (await res.json()) as {
+      total: number;
+      sessions: { root: { id: string }; readState?: string }[];
+    };
+    return body;
+  };
+  const triage = (body: Record<string, unknown>, withUser = true) =>
+    fetch(`${baseUrl}/api/session-triage`, {
+      method: "POST",
+      headers: withUser ? asOwner() : { "content-type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+  test("hideSource leaves a source out of sections and lists, and sources still count it", async () => {
+    const slackA = await task("shared/", { source: "slack" });
+    const slackB = await task("shared/a/", { source: "slack" });
+    const ui = await task("shared/", { source: "ui" });
+    const chat = await task("shared/", { source: "chat" });
+
+    const full = await treeOf();
+    expect(full.inbox.total).toBe(4);
+    expect(full.sources).toEqual([
+      { source: "slack", total: 2 },
+      { source: "chat", total: 1 },
+      { source: "ui", total: 1 },
+    ]);
+
+    const hidden = await treeOf("hideSource=slack,chat");
+    expect(hidden.inbox.total).toBe(1);
+    expect(hidden.noGroup.total).toBe(1);
+    expect(hidden.groups).toEqual([]);
+    // The menu still offers the hidden sources back.
+    expect(hidden.sources).toEqual(full.sources);
+
+    const inbox = await listOf("triage=inbox&hideSource=slack,chat");
+    expect(inbox.total).toBe(1);
+    expect(inbox.sessions.map((s) => s.root.id)).toEqual([ui.id]);
+    const all = await listOf("triage=inbox");
+    expect(all.sessions.map((s) => s.root.id).sort()).toEqual(
+      [slackA.id, slackB.id, ui.id, chat.id].sort(),
+    );
+  });
+
+  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);
+    const slack = await task("shared/", { source: "slack" });
+    const grouped = await task("shared/a/", { source: "ui" });
+    const workflow = await task("shared/", { source: "workflow" });
+    const later = await task("shared/", { source: "ui" });
+    await state(later.id, "snoozed", NOW, { snoozeUntil: "2999-01-01T00:00:00.000Z" });
+
+    // No group, Slack hidden, Mine view: a and b only.
+    let res = await triage({ action: "done", noGroup: true, hideSource: ["slack"] });
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ updated: 2 });
+    let done = await listOf("triage=done");
+    expect(done.sessions.map((s) => s.root.id).sort()).toEqual([a.id, b.id].sort());
+    // The rest keep their state; the workflow root (All only) was not touched.
+    const inbox = await listOf("triage=inbox&show=all");
+    expect(inbox.sessions.map((s) => s.root.id).sort()).toEqual(
+      [slack.id, grouped.id, workflow.id].sort(),
+    );
+    expect((await listOf("triage=later")).sessions.map((s) => s.root.id)).toEqual([later.id]);
+
+    // Back to the Inbox from the Done list, then read and unread across the Inbox.
+    res = await triage({ action: "inbox", triage: "done" });
+    expect(await res.json()).toEqual({ updated: 2 });
+    expect((await listOf("triage=done")).total).toBe(0);
+    res = await triage({ action: "unread", triage: "inbox" });
+    expect(await res.json()).toEqual({ updated: 4 });
+    expect((await treeOf()).inbox.unread).toBe(4);
+    res = await triage({ action: "read", triage: "inbox" });
+    expect(await res.json()).toEqual({ updated: 4 });
+    const tree = await treeOf();
+    expect(tree.inbox.unread).toBe(0);
+    expect(tree.inbox.total).toBe(4);
+
+    // One group only.
+    res = await triage({ action: "done", groupKey: "shared/a/" });
+    expect(await res.json()).toEqual({ updated: 1 });
+    done = await listOf("triage=done");
+    expect(done.sessions.map((s) => s.root.id)).toEqual([grouped.id]);
+    // Show All reaches the workflow root.
+    res = await triage({ action: "done", triage: "inbox", show: "all" });
+    expect(await res.json()).toEqual({ updated: 4 });
+    expect((await listOf("triage=inbox&show=all")).total).toBe(0);
+  });
+
+  test("triage by list acts on the Later list", async () => {
+    const snoozedA = await task("shared/", { source: "ui" });
+    const snoozedB = await task("shared/", { source: "ui" });
+    const open = await task("shared/", { source: "ui" });
+    for (const id of [snoozedA.id, snoozedB.id]) {
+      await state(id, "snoozed", NOW, { snoozeUntil: "2999-01-01T00:00:00.000Z" });
+    }
+
+    let res = await triage({ action: "done", triage: "later" });
+    expect(await res.json()).toEqual({ updated: 2 });
+    expect((await listOf("triage=later")).total).toBe(0);
+    const done = await listOf("triage=done");
+    expect(done.sessions.map((s) => s.root.id).sort()).toEqual([snoozedA.id, snoozedB.id].sort());
+    const cleared = await getDbClient().query<{ snoozeUntil: string | null }>(
+      "SELECT snoozeUntil FROM inbox_item_state WHERE itemId IN (?, ?)",
+      [snoozedA.id, snoozedB.id],
+    );
+    expect(cleared.map((row) => row.snoozeUntil)).toEqual([null, null]);
+
+    await state(snoozedA.id, "snoozed", NOW, { snoozeUntil: "2999-01-01T00:00:00.000Z" });
+    res = await triage({ action: "inbox", triage: "later" });
+    expect(await res.json()).toEqual({ updated: 1 });
+    const inbox = await listOf("triage=inbox");
+    expect(inbox.sessions.map((s) => s.root.id).sort()).toEqual([snoozedA.id, open.id].sort());
+  });
+
+  test("triage by list writes the same row fields as the one-session PATCH", async () => {
+    type Row = {
+      status: string;
+      snoozeUntil: string | null;
+      dismissedAt: string | null;
+      doneAt: string | null;
+      readAt: string | null;
+      lastReadAt: string | null;
+    };
+    const rowOf = async (id: string) =>
+      (await getDbClient().get<Row>("SELECT * FROM inbox_item_state WHERE itemId = ?", [
+        id,
+      ])) as Row;
+    const unreadCursor = "1970-01-01T00:00:00.000Z";
+    for (const action of ["done", "inbox", "read", "unread"] as const) {
+      // Two sessions with the same earlier state: read once, then snoozed past
+      // the wake time (back in the Inbox). One gets the dashboard's PATCH
+      // write, the other the list write.
+      const one = await task(`shared/${action}-one/`, { source: "ui" });
+      const list = await task(`shared/${action}-list/`, { source: "ui" });
+      for (const id of [one.id, list.id]) {
+        await state(id, "snoozed", NOW, { snoozeUntil: OLD, lastReadAt: OLD });
+        await getDbClient().run("UPDATE inbox_item_state SET readAt = ? WHERE itemId = ?", [
+          OLD,
+          id,
+        ]);
+      }
+      const listed = (await fetch(
+        `${baseUrl}/api/sessions?scope=tree&groupKey=shared/${action}-one/`,
+        {
+          headers: asOwner(),
+        },
+      ).then((res) => res.json())) as { sessions: { lastActivityAt: string }[] };
+      const lastActivityAt = listed.sessions[0]?.lastActivityAt;
+      expect(lastActivityAt).toBeTruthy();
+      // The write of `writeFor` in apps/ui/src/api/hooks/use-session-triage.ts.
+      const write =
+        action === "done"
+          ? { status: "done" as const }
+          : action === "read"
+            ? { status: "open" as const, readAt: NOW, lastReadAt: lastActivityAt }
+            : action === "unread"
+              ? { status: "open" as const, lastReadAt: unreadCursor }
+              : { status: "open" as const };
+      await upsertInboxState({ userId: owner.id, itemType: "to_read", itemId: one.id, ...write });
+      const res = await triage({ action, groupKey: `shared/${action}-list/` });
+      expect(await res.json()).toEqual({ updated: 1 });
+
+      const [a, b] = [await rowOf(one.id), await rowOf(list.id)];
+      expect({ ...b, doneAt: b.doneAt !== null }).toMatchObject({
+        status: a.status,
+        snoozeUntil: a.snoozeUntil,
+        dismissedAt: a.dismissedAt,
+        doneAt: a.doneAt !== null,
+        readAt: a.readAt,
+        lastReadAt: a.lastReadAt,
+      });
+      // readAt is sticky: the first view stays.
+      expect(b.readAt).toBe(OLD);
+    }
+  });
+
+  test("triage by list needs a picked user and exactly one list", async () => {
+    await task("shared/", { source: "ui" });
+    expect((await triage({ action: "done", triage: "inbox" }, false)).status).toBe(400);
+    expect((await triage({ action: "done" })).status).toBe(400);
+    expect((await triage({ action: "done", triage: "inbox", noGroup: true })).status).toBe(400);
+    expect((await listOf("triage=inbox")).total).toBe(1);
+  });
+});