@desplega.ai/agent-swarm 2.7.4 → 2.7.6

package/src/tests/seed-model-profiles.test.ts

@@ -62,9 +62,9 @@ beforeEach(async () => {
 
 describe("tier seeds", () => {
   test("one profile per harness and tier, copied from the tier map; none for acp", async () => {
-    expect(await seedModelProfiles()).toBe(40);
+    expect(await seedModelProfiles()).toBe(44);
     const profiles = await listModelProfiles();
-    expect(profiles).toHaveLength(40);
+    expect(profiles).toHaveLength(44);
     expect(profiles.some((p) => p.harness === "acp")).toBe(false);
     for (const profile of profiles) {
       const tier = profile.seededFrom?.replace("tier:", "") as (typeof MODEL_TIERS)[number];

package/src/tests/seed-schedules.test.ts

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import {
   closeDb,
+  createWorkflow,
   getScheduledTaskByName,
   getScheduledTasks,
   initDb,
@@ -13,6 +14,7 @@ import {
   loadSeedSchedules,
   type ScheduleTemplateSource,
 } from "../be/seed/schedules-seeder";
+import { createWorkflowsSeeder } from "../be/seed/workflows-seeder";
 
 const TEST_DB_PATH = "./test-seed-schedules.sqlite";
 
@@ -72,6 +74,31 @@ function zeroConfigScheduleSource(opts?: {
   } satisfies ScheduleTemplateSource;
 }
 
+/** A schedule template with an explicit target block and an optional task prompt. */
+function targetScheduleSource(target: Record<string, unknown>, prompt?: string) {
+  return {
+    config: JSON.stringify({
+      name: "test-target-schedule",
+      title: "Test target schedule",
+      description: "Seeded schedule with a target.",
+      placeholders: [],
+      requires: [],
+      runAllSeedersCandidate: true,
+      autoEnableCandidate: true,
+    }),
+    content: `# Test\n\n## Schedule\n\n\`\`\`json\n${JSON.stringify({
+      cron: "0 9 * * *",
+      timezone: "UTC",
+      enabled: true,
+      ...target,
+    })}\n\`\`\`\n${prompt === undefined ? "" : `\n## Scheduled Task\n\n${prompt}`}`,
+  } satisfies ScheduleTemplateSource;
+}
+
+async function makeWorkflow(name: string) {
+  return createWorkflow({ name, definition: { nodes: [] } });
+}
+
 const ORIGINAL_SEED_AUTOMATIONS_ENABLED = process.env.SEED_AUTOMATIONS_ENABLED;
 
 beforeEach(async () => {
@@ -133,6 +160,8 @@ describe("schedules seeder", () => {
 
   test("SEED_AUTOMATIONS_ENABLED=false still seeds all schedules disabled", async () => {
     process.env.SEED_AUTOMATIONS_ENABLED = "false";
+    // dreaming-daily targets the seeded dreaming workflow.
+    await runSeeder(createWorkflowsSeeder(), { quiet: true });
     const result = await runSeeder(createSchedulesSeeder(), { quiet: true });
     expect(result).toMatchObject({ created: 12, failed: [] });
     const schedules = await getScheduledTasks();
@@ -141,6 +170,8 @@ describe("schedules seeder", () => {
   });
 
   test("seeds a disabled schedule whose timezone still needs setup", async () => {
+    // dreaming-daily targets the seeded dreaming workflow.
+    await runSeeder(createWorkflowsSeeder(), { quiet: true });
     const result = await runSeeder(createSchedulesSeeder(), { quiet: true });
     expect(result).toMatchObject({ created: 12, failed: [] });
     expect(await getScheduledTaskByName("weekly-dependabot-triage")).toMatchObject({
@@ -245,6 +276,113 @@ describe("schedules seeder", () => {
     );
   });
 
+  test("dreaming-daily is a workflow schedule with no task prompt", async () => {
+    await runSeeder(createWorkflowsSeeder(), { quiet: true });
+    const dreaming = loadSeedSchedules().find((schedule) => schedule.name === "dreaming-daily");
+    expect(dreaming).toMatchObject({
+      targetType: "workflow",
+      workflow: "dreaming",
+      taskTemplate: "",
+    });
+    // Agent-task templates carry no target keys, so their seed hash is unchanged.
+    const digest = loadSeedSchedules().find((schedule) => schedule.name === "daily-blocker-digest");
+    expect(digest && "targetType" in digest).toBe(false);
+  });
+
+  test("seeds a workflow target by name and re-runs as a no-op", async () => {
+    const workflow = await makeWorkflow("test-target-workflow");
+    const seeder = createSchedulesSeeder([
+      targetScheduleSource({ targetType: "workflow", workflow: "test-target-workflow" }),
+    ]);
+    expect(await runSeeder(seeder, { quiet: true })).toMatchObject({ created: 1, failed: [] });
+    const row = await getScheduledTaskByName("test-target-schedule");
+    expect(row).toMatchObject({ targetType: "workflow", workflowId: workflow.id });
+    expect(row?.taskTemplate).toBeUndefined();
+    expect(await runSeeder(seeder, { quiet: true })).toMatchObject({
+      skippedUnchanged: 1,
+      updated: 0,
+    });
+  });
+
+  test("seeds a script target and fails on a missing script", async () => {
+    const seeder = createSchedulesSeeder([
+      targetScheduleSource({ targetType: "script", scriptName: "no-such-script", scriptArgs: {} }),
+    ]);
+    const result = await runSeeder(seeder, { quiet: true });
+    expect(result.created).toBe(0);
+    expect(result.failed[0]?.error).toContain('Global script "no-such-script" not found');
+  });
+
+  test("fails a workflow target whose workflow does not exist, without creating a row", async () => {
+    const result = await runSeeder(
+      createSchedulesSeeder([
+        targetScheduleSource({ targetType: "workflow", workflow: "missing" }),
+      ]),
+      { quiet: true },
+    );
+    expect(result.created).toBe(0);
+    expect(result.failed[0]?.error).toContain('Workflow "missing" not found');
+    expect(await getScheduledTaskByName("test-target-schedule")).toBeNull();
+  });
+
+  test("rejects target blocks that ship fields or prompts the target ignores", () => {
+    const cases: [Record<string, unknown>, string | undefined, string][] = [
+      [{ targetType: "workflow", workflow: "w" }, "Do it.", "ships a ## Scheduled Task prompt"],
+      [{ targetType: "script", scriptName: "s" }, "Do it.", "ships a ## Scheduled Task prompt"],
+      [{ targetType: "workflow" }, undefined, "has no workflow name"],
+      [{ targetType: "script" }, undefined, "has no scriptName"],
+      [{ targetType: "workflow", workflow: "w", scriptName: "s" }, undefined, "sets scriptName"],
+      [{ workflow: "w" }, "Do it.", "(targetType agent-task) sets workflow"],
+      [{ targetType: "lambda" }, undefined, 'unknown targetType "lambda"'],
+    ];
+    for (const [target, prompt, message] of cases) {
+      expect(() => loadSeedSchedules([targetScheduleSource(target, prompt)])).toThrow(message);
+    }
+  });
+
+  test("migrates a pristine agent-task schedule to a workflow target and clears its prompt", async () => {
+    const workflow = await makeWorkflow("test-target-workflow");
+    await runSeeder(createSchedulesSeeder([targetScheduleSource({}, "Trigger the workflow.")]), {
+      quiet: true,
+    });
+    expect(await getScheduledTaskByName("test-target-schedule")).toMatchObject({
+      targetType: "agent-task",
+      taskTemplate: "Trigger the workflow.",
+    });
+
+    const result = await runSeeder(
+      createSchedulesSeeder([
+        targetScheduleSource({ targetType: "workflow", workflow: "test-target-workflow" }),
+      ]),
+      { quiet: true },
+    );
+    expect(result).toMatchObject({ updated: 1, failed: [] });
+    const row = await getScheduledTaskByName("test-target-schedule");
+    expect(row).toMatchObject({ targetType: "workflow", workflowId: workflow.id });
+    expect(row?.taskTemplate).toBeUndefined();
+  });
+
+  test("preserves an operator-edited agent-task schedule when its template moves to a workflow", async () => {
+    await makeWorkflow("test-target-workflow");
+    await runSeeder(createSchedulesSeeder([targetScheduleSource({}, "Trigger the workflow.")]), {
+      quiet: true,
+    });
+    const seeded = await getScheduledTaskByName("test-target-schedule");
+    await updateScheduledTask(seeded!.id, { taskTemplate: "My own prompt." });
+
+    const result = await runSeeder(
+      createSchedulesSeeder([
+        targetScheduleSource({ targetType: "workflow", workflow: "test-target-workflow" }),
+      ]),
+      { quiet: true },
+    );
+    expect(result.skippedUserModified).toBe(1);
+    expect(await getScheduledTaskByName("test-target-schedule")).toMatchObject({
+      targetType: "agent-task",
+      taskTemplate: "My own prompt.",
+    });
+  });
+
   test("reports an invalid cron without creating a row", async () => {
     const result = await runSeeder(createSchedulesSeeder([scheduleSource("not a cron")]), {
       quiet: true,

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

@@ -217,6 +217,32 @@ describe("seed-scripts catalog", () => {
     ).toHaveLength(200);
   });
 
+  test.each([
+    ["Incomplete response returned, reason: max_output_tokens", "output-limit"],
+    ["Stopped: max_tokens", "output-limit"],
+    ["Maximum output length exceeded", "output-limit"],
+    ["Output token limit reached", "output-limit"],
+    ["401 Unauthorized", "auth/credentials"],
+    ["invalid token", "auth/credentials"],
+    ["Resource not accessible by personal access token", "auth/credentials"],
+    ["Processed 100 tokens", "other"],
+    ["max_input_tokens exceeded", "other"],
+  ])("task-failure-audit classifies %s as %s", async (failureReason, expectedKey) => {
+    const result = await taskFailureAudit(
+      { publishPage: false },
+      {
+        swarm: {
+          async task_list() {
+            return { data: { tasks: [{ id: "failed-task", failureReason }] } };
+          },
+        },
+      },
+    );
+
+    expect(result.groups).toHaveLength(1);
+    expect(result.groups[0].key).toBe(expectedKey);
+  });
+
   test("task-failure-audit projects failure reasons into schedule-group samples", async () => {
     let projectionArgs: Record<string, unknown> | undefined;
     const result = await taskFailureAudit(

package/src/tests/session-cost-recompute-unit.test.ts

@@ -261,3 +261,42 @@ describe("nan and helmcode sessions price at $0 from the seeded table", () => {
     }
   });
 });
+
+describe("pi on the ChatGPT subscription prices like codex on the same pool", () => {
+  const cache = loadModelsDevCache();
+  const rows = cache ? buildModelsDevSeedRows(cache) : [];
+  const book: RateBook = Object.fromEntries(
+    rows.map((row) => [`${row.provider}:${row.model}:${row.tokenClass}`, row.pricePerMillionUsd]),
+  );
+
+  test("openai-codex/<id> on pi records the codex <id> pricing-table cost", async () => {
+    // One request: 69,308 input tokens, 55,680 of them cached, 376 output.
+    // codex reports input including cache reads; pi-ai reports them disjoint.
+    const codex = await recomputeSessionCost(
+      {
+        ...BASE,
+        provider: "codex",
+        model: "gpt-5.6-luna",
+        inputTokens: 69_308,
+        cacheReadTokens: 55_680,
+        outputTokens: 376,
+      },
+      lookupFrom(book),
+    );
+    const pi = await recomputeSessionCost(
+      {
+        ...BASE,
+        provider: "pi",
+        model: "openai-codex/gpt-5.6-luna",
+        inputTokens: 69_308 - 55_680,
+        cacheReadTokens: 55_680,
+        outputTokens: 376,
+      },
+      lookupFrom(book),
+    );
+    expect(codex.costSource).toBe("pricing-table");
+    expect(pi.costSource).toBe("pricing-table");
+    expect(pi.totalCostUsd).toBeCloseTo(codex.totalCostUsd, 12);
+    expect(pi.totalCostUsd).toBeGreaterThan(0);
+  });
+});

package/src/tests/session-costs-golden.test.ts

@@ -361,6 +361,32 @@ describe("Phase 3 — session cost recompute golden fixtures", () => {
     expectExact(body.cost.totalCostUsd, expected);
   });
 
+  // Boot-seeded rows only: fx reports the swarm model string with its route
+  // prefix and no cache split, so input and output price at the table rate.
+  test("fx runs price from the seeded rates on each route", async () => {
+    const openRouter = await postCost({
+      sessionId: "fx-openrouter",
+      provider: "fx",
+      model: "openrouter/deepseek/deepseek-v4.1-flash",
+      totalCostUsd: 0,
+      inputTokens: 58_620,
+      outputTokens: 1_183,
+    });
+    expect(openRouter.cost.costSource).toBe("pricing-table");
+    expectExact(openRouter.cost.totalCostUsd, (58_620 * 0.14 + 1_183 * 0.42) / 1_000_000);
+
+    const openAi = await postCost({
+      sessionId: "fx-openai",
+      provider: "fx",
+      model: "gpt-5-mini",
+      totalCostUsd: 0,
+      inputTokens: 9_286,
+      outputTokens: 506,
+    });
+    expect(openAi.cost.costSource).toBe("pricing-table");
+    expectExact(openAi.cost.totalCostUsd, (9_286 * 0.25 + 506 * 2) / 1_000_000);
+  });
+
   test("legacy cache writes without a TTL split keep the 5m class", async () => {
     await seedModelRates("claude", "claude-legacy-cache-write", {
       input: 5,

package/src/tests/session-summaries-plans.test.ts

@@ -0,0 +1,120 @@
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  countSessions,
+  createTaskExtended,
+  createUser,
+  getDbClient,
+  initDb,
+  listRecentSessions,
+} from "../be/db";
+import {
+  getSessionReadState,
+  getSessionTree,
+  legacySessionSummaryQuery,
+  triageSessionList,
+} from "../be/db/session-tree";
+
+const TEST_DB_PATH = "./test-session-summaries-plans.sqlite";
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"])
+    await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => undefined);
+}
+
+// Runs the real caller and returns the plans of every statement it sent.
+async function plansOf(run: () => Promise<unknown>): Promise<string[]> {
+  const client = getDbClient();
+  const seen: { sql: string; params: unknown[] }[] = [];
+  const methods = ["query", "get", "run"] as const;
+  const originals = methods.map((name) => client[name].bind(client));
+  const spies = methods.map((name, i) =>
+    spyOn(client, name).mockImplementation(((sql: string, params?: unknown[]) => {
+      seen.push({ sql, params: params ?? [] });
+      return (originals[i] as (sql: string, params?: unknown[]) => unknown)(sql, params);
+    }) as never),
+  );
+  try {
+    await run();
+  } finally {
+    for (const spy of spies) spy.mockRestore();
+  }
+  expect(seen.length).toBeGreaterThan(0);
+  const plans: string[] = [];
+  for (const { sql, params } of seen) {
+    const rows = await client.query<{ detail: string }>(
+      `EXPLAIN QUERY PLAN ${sql}`,
+      params as (string | number | null)[],
+    );
+    plans.push(rows.map((row) => row.detail).join("\n"));
+  }
+  return plans;
+}
+
+let userId = "";
+
+describe("session read plans without sqlite_stat1", () => {
+  beforeAll(async () => {
+    await removeDbFiles();
+    initDb(TEST_DB_PATH);
+    userId = (await createUser({ name: "plans viewer" })).id;
+    const root = await createTaskExtended("plans root", {
+      source: "ui",
+      requestedByUserId: userId,
+    });
+    await createTaskExtended("plans child", { parentTaskId: root.id });
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles();
+  });
+
+  test("the test DB has no planner statistics, like production", async () => {
+    const stat = await getDbClient().get<{ name: string }>(
+      "SELECT name FROM sqlite_master WHERE name = 'sqlite_stat1'",
+    );
+    expect(stat).toBeNull();
+  });
+
+  const viewer = () => ({ userId, scope: "all" as const });
+  const now = "2026-10-29T12:00:00.000Z";
+  const CASES: [string, () => Promise<unknown>][] = [
+    ["list", () => listRecentSessions({ viewer: viewer(), now, slim: true, tree: true })],
+    ["list inbox", () => listRecentSessions({ viewer: viewer(), now, triage: "inbox" })],
+    ["list done", () => listRecentSessions({ viewer: viewer(), now, triage: "done" })],
+    ["list group", () => listRecentSessions({ viewer: viewer(), now, groupKey: "shared/" })],
+    ["list status", () => listRecentSessions({ viewer: viewer(), now, status: "needs" })],
+    ["list with user", () => listRecentSessions({ viewer: viewer(), now, withUserId: userId })],
+    ["count", () => countSessions({ viewer: viewer(), now, tree: true })],
+    ["count inbox", () => countSessions({ viewer: viewer(), now, triage: "inbox" })],
+    ["count source", () => countSessions({ source: ["slack"] })],
+    ["tree", () => getSessionTree({ kind: "user", userId }, now)],
+    ["tree mine", () => getSessionTree({ kind: "user", userId }, now, { mine: true })],
+    ["read state", () => getSessionReadState(userId, userId, now)],
+    ["triage list", () => triageSessionList(userId, { triage: "inbox", now }, "read")],
+  ];
+
+  for (const [name, run] of CASES) {
+    test(`${name} reads the summaries without a chain walk or task scan`, async () => {
+      for (const detail of await plansOf(run)) {
+        expect(detail).not.toContain("RECURSIVE");
+        expect(detail).not.toMatch(/\bSCAN agent_tasks\b/);
+        expect(detail).not.toMatch(/\bSCAN (r|rt|t)\b/);
+      }
+    });
+  }
+
+  test("the chain walk trips the same checks (control)", async () => {
+    const query = legacySessionSummaryQuery({ viewer: viewer(), now });
+    const [detail] = await plansOf(() => getDbClient().query(query.sql, query.params));
+    expect(detail).toMatch(/RECURSIVE|\bSCAN agent_tasks\b|\bSCAN (r|t)\b/);
+  });
+
+  test("the list reads agent_tasks only for the page roots", async () => {
+    const [detail] = await plansOf(() => listRecentSessions({ viewer: viewer(), now, slim: true }));
+    expect(detail).toContain("SEARCH r USING INDEX sqlite_autoindex_agent_tasks_1 (id=?)");
+    expect(detail).toContain("SCAN session_summaries USING INDEX idx_session_summaries_activity");
+  });
+});

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

@@ -13,11 +13,17 @@ import {
   upsertInboxState,
 } from "../be/db";
 import { findSessionSummaryDrift } from "../be/db/session-summaries";
-import { sessionSummaryQuery } from "../be/db/session-tree";
+import {
+  legacySessionSummaryQuery,
+  type SessionFilters,
+  sessionSummaryQuery,
+} from "../be/db/session-tree";
 import { deleteTask } from "../be/db/tasks/write";
 
 const dbPath = join(tmpdir(), `session-summaries-${process.pid}-${Date.now()}.sqlite`);
-const MIGRATION = join(import.meta.dir, "../be/migrations/253_session_summaries.sql");
+const MIGRATIONS = ["253_session_summaries.sql", "259_session_summaries_open_tasks.sql"].map(
+  (name) => join(import.meta.dir, "../be/migrations", name),
+);
 const BASE = Date.parse("2026-10-01T00:00:00.000Z");
 let users: string[] = [];
 
@@ -209,7 +215,7 @@ const SCHEDULE = [
 /** Each Done-marked root's read state from the chain walk equals the stored rule. */
 async function expectReopensDoneMatches() {
   const viewer = users[0]!;
-  const legacy = sessionSummaryQuery({ viewer: { userId: viewer, scope: "all" } });
+  const legacy = legacySessionSummaryQuery({ viewer: { userId: viewer, scope: "all" } });
   const rows = await client().query<{ root_id: string; readState: string; stored: string }>(
     `SELECT a.root_id, a.readState,
       CASE WHEN s.lastHumanAt > d.lastUpdatedAt THEN 'unread' ELSE 'done' END AS stored
@@ -226,6 +232,49 @@ async function expectReopensDoneMatches() {
   return rows.length;
 }
 
+/** A random filter set, as the list, count and tree send them. */
+function randomFilters(): SessionFilters {
+  const opts: SessionFilters = {
+    viewer: { userId: rand() < 0.15 ? null : pick(users), scope: pick(["all", "mine", "shared"]) },
+    now: at(),
+  };
+  if (rand() < 0.2) opts.source = [pick(["ui", "slack", "mcp", "api"])];
+  if (rand() < 0.2) opts.showSource = [pick(["ui", "slack", "api"])];
+  if (rand() < 0.2) opts.hideSource = [pick(["mcp", "system"])];
+  if (rand() < 0.4) opts.triage = pick(["inbox", "later", "done", "unread"] as const);
+  if (rand() < 0.3) opts.status = pick(["running", "failed", "needs"] as const);
+  if (rand() < 0.2) opts.withUserId = pick(users);
+  if (rand() < 0.2) opts.q = pick(["task", "ab", "zz"]);
+  if (rand() < 0.2) opts.noGroup = true;
+  else if (rand() < 0.1) opts.groupKey = "shared/";
+  if (rand() < 0.3) opts.tree = true;
+  if (rand() < 0.2) opts.mine = true;
+  return opts;
+}
+
+/** The summary query returns the chain walk's rows for random filters. */
+async function expectSummaryQueryMatchesLegacy(sets: number) {
+  const columns = `root_id, chainCount, lastActivityAt, latestStatus, readState, snoozeUntil,
+    needsYou, pendingApproval > 0 AS pendingApproval, openTasks`;
+  // Skip roots whose newest timestamp ties across chain tasks: the walk's status
+  // is arbitrary there, and so are needsYou and the status filters.
+  const untied = `(SELECT COUNT(*) FROM session_members m JOIN agent_tasks t ON t.id = m.taskId
+    WHERE m.rootId = q.root_id AND t.lastUpdatedAt = q.lastActivityAt) = 1`;
+  let rows = 0;
+  for (let i = 0; i < sets; i++) {
+    const opts = randomFilters();
+    const read = async (query: { sql: string; params: unknown[] }) =>
+      await client().query<Record<string, unknown>>(
+        `SELECT ${columns} FROM (${query.sql}) q WHERE ${untied} ORDER BY root_id`,
+        query.params as (string | number | null)[],
+      );
+    const expected = await read(legacySessionSummaryQuery(opts));
+    expect({ opts, rows: await read(sessionSummaryQuery(opts)) }).toEqual({ opts, rows: expected });
+    rows += expected.length;
+  }
+  return rows;
+}
+
 beforeAll(async () => {
   initDb(dbPath);
   users = [];
@@ -245,8 +294,9 @@ describe("session_summaries", () => {
   test("500 random writes keep the summaries equal to the chain walk", async () => {
     const counts: Record<string, number> = {};
     // The most chains, human events and pending approvals any checkpoint compared.
-    const seen = { chains: 0, humans: 0, pending: 0 };
+    const seen = { chains: 0, humans: 0, pending: 0, open: 0 };
     let doneChecks = 0;
+    let summaryRows = 0;
     for (let i = 1; i <= 500; i++) {
       const op = pick(SCHEDULE);
       counts[op] = (counts[op] ?? 0) + 1;
@@ -257,9 +307,11 @@ describe("session_summaries", () => {
           drift: [],
         });
         doneChecks += await expectReopensDoneMatches();
+        summaryRows += await expectSummaryQueryMatchesLegacy(5);
         const shape = (await client().get<typeof seen>(
           `SELECT SUM(chainCount > 2) AS chains, SUM(lastHumanAt IS NOT NULL) AS humans,
-            SUM(pendingApprovalCount > 0) AS pending FROM session_summaries`,
+            SUM(pendingApprovalCount > 0) AS pending, SUM(openTaskCount > 1) AS open
+          FROM session_summaries`,
         ))!;
         for (const key of Object.keys(seen) as (keyof typeof seen)[])
           seen[key] = Math.max(seen[key], shape[key] ?? 0);
@@ -270,7 +322,9 @@ describe("session_summaries", () => {
     expect(seen.chains).toBeGreaterThan(5);
     expect(seen.humans).toBeGreaterThan(5);
     expect(seen.pending).toBeGreaterThan(0);
+    expect(seen.open).toBeGreaterThan(0);
     expect(doneChecks).toBeGreaterThan(0);
+    expect(summaryRows).toBeGreaterThan(100);
   }, 60_000);
 
   test("the drift check reports a corrupted summary and member (positive control)", async () => {
@@ -279,13 +333,13 @@ describe("session_summaries", () => {
     expect(await findSessionSummaryDrift()).toEqual([]);
 
     await client().run(
-      "UPDATE session_summaries SET chainCount = chainCount + 5, lastHumanAt = 'x' WHERE rootId = ?",
+      "UPDATE session_summaries SET chainCount = chainCount + 5, openTaskCount = 7, lastHumanAt = 'x' WHERE rootId = ?",
       [root],
     );
     await client().run("DELETE FROM session_members WHERE taskId = ?", [child]);
     const drift = await findSessionSummaryDrift();
     expect(drift.map((d) => `${d.rootId}:${d.field}`).sort()).toEqual(
-      [`${root}:chainCount`, `${root}:lastHumanAt`, `${root}:member`].sort(),
+      [`${root}:chainCount`, `${root}:lastHumanAt`, `${root}:member`, `${root}:openTasks`].sort(),
     );
 
     await client().run("INSERT INTO session_members (taskId, rootId) VALUES (?, ?)", [child, root]);
@@ -356,18 +410,24 @@ describe("session_summaries", () => {
     await client().run("UPDATE agent_tasks SET parentTaskId = ? WHERE id = ?", [root, child]);
   });
 
-  test("the migration backfill rebuilds the same summaries", async () => {
+  test("the migration backfills rebuild the same summaries", async () => {
     const before = await client().query<Record<string, unknown>>(
       "SELECT * FROM session_summaries ORDER BY rootId",
     );
     expect(before.length).toBeGreaterThan(20);
-    const sql = await Bun.file(MIGRATION).text();
-    const backfill = sql.slice(sql.indexOf("-- Backfill:"));
-    expect(backfill).toContain("INSERT INTO session_members");
+    const backfills = await Promise.all(
+      MIGRATIONS.map(async (path) => {
+        const sql = await Bun.file(path).text();
+        return sql.slice(sql.indexOf("-- Backfill:"));
+      }),
+    );
+    expect(backfills[0]).toContain("INSERT INTO session_members");
+    expect(backfills[1]).toContain("openTaskCount");
     await client().transaction(async (tx) => {
       await tx.run("DELETE FROM session_summaries");
       await tx.run("DELETE FROM session_members");
-      for (const statement of backfill
+      for (const statement of backfills
+        .join("\n")
         .split(/;\s*\n/)
         .filter((s) => s.replace(/--.*$/gm, "").trim()))
         await tx.run(statement);

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

@@ -425,14 +425,22 @@ describe("nested source thread groups", () => {
       }
       const [sql, params] = call;
       const plan = await client.query<{ detail: string }>(`EXPLAIN QUERY PLAN ${sql}`, params);
-      expect(plan.some((p) => p.detail.startsWith("SEARCH r USING INDEX"))).toBe(true);
       expect(
         plan.some((p) =>
-          p.detail.includes("SEARCH session_thread_root USING INDEX idx_agent_tasks_asset_key"),
+          /^SEARCH session_summaries USING INDEX idx_session_summaries_(key|thread) \(key>\? AND key<\?\)/.test(
+            p.detail,
+          ),
         ),
       ).toBe(true);
       expect(
-        plan.some((p) => p.detail === "SCAN r" || p.detail === "SCAN session_thread_root"),
+        plan.some((p) =>
+          p.detail.includes("SEARCH session_thread_root USING INDEX idx_session_summaries_key"),
+        ),
+      ).toBe(true);
+      expect(
+        plan.some((p) =>
+          /^SCAN (session_summaries|session_thread_root|agent_tasks)\b/.test(p.detail),
+        ),
       ).toBe(false);
       expect(sql).not.toContain('"key" LIKE');
       expect(sql).not.toContain("INDEXED BY");