@desplega.ai/agent-swarm 1.156.0 → 1.158.0

package/src/tests/heartbeat-stall-cas.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Counterexamples from the TLA+ heartbeat model (specs/tla/heartbeat/).
+ *
+ * Each test replays one TLC trace against a real temp SQLite DB, calling the
+ * functions ACTIONS.md maps each trace step to. A test that passes on main
+ * means the trace was model drift, not a bug.
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getChildTasks,
+  getDbClient,
+  getTaskById,
+  initDb,
+  startTask,
+  updateTaskProgress,
+} from "../be/db";
+import { codeLevelTriage, setBeforeHeartbeatSupersedeForTests } from "../heartbeat/heartbeat";
+
+const TEST_DB_PATH = "./test-heartbeat-stall-cas.sqlite";
+
+async function backdateTask(taskId: string, isoTime: string): Promise<void> {
+  await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [
+    isoTime,
+    taskId,
+  ]);
+}
+
+describe("Heartbeat stall classifier CAS (TLA+ counterexample)", () => {
+  beforeAll(async () => {
+    try {
+      await unlink(TEST_DB_PATH);
+    } catch {
+      // File doesn't exist
+    }
+    closeDb();
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const path of [TEST_DB_PATH, `${TEST_DB_PATH}-wal`, `${TEST_DB_PATH}-shm`]) {
+      try {
+        await unlink(path);
+      } catch {
+        // Files may not exist
+      }
+    }
+  });
+
+  beforeEach(async () => {
+    setBeforeHeartbeatSupersedeForTests(null);
+    const db = getDbClient();
+    await db.run("DELETE FROM agent_tasks");
+    await db.run("DELETE FROM agents");
+    await db.run("DELETE FROM active_sessions");
+  });
+
+  // Trace: PollStart -> Age -> HbRead -> Progress -> HbWrite (NoLiveKill).
+  test("stall classifier does not supersede a task that made progress after the candidate read", async () => {
+    const agent = await createAgent({ name: "quiet-worker", isLead: false, status: "busy" });
+    const task = await createTaskExtended("Long quiet work", { agentId: agent.id });
+    await startTask(task.id);
+    await backdateTask(task.id, new Date(Date.now() - 10 * 60 * 1000).toISOString());
+
+    // The worker reports progress after the sweep read the candidate list.
+    setBeforeHeartbeatSupersedeForTests(async (candidate) => {
+      await updateTaskProgress(candidate.id, "still working");
+    });
+
+    await codeLevelTriage();
+
+    expect((await getTaskById(task.id))?.status).toBe("in_progress");
+    expect(await getChildTasks(task.id)).toHaveLength(0);
+  });
+});

package/src/tests/heartbeat.test.ts

@@ -1,10 +1,12 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import {
+  cancelTask,
   claimTask,
   closeDb,
   createAgent,
   createTaskExtended,
+  failTask,
   getActiveSessionForTask,
   getDbClient,
   getIdleWorkersWithCapacity,
@@ -280,6 +282,13 @@ describe("Heartbeat Triage", () => {
   // ==========================================================================
 
   describe("Code-Level Triage", () => {
+    test("reports approval sweep counts in staleCleanup", async () => {
+      const findings = await codeLevelTriage();
+
+      expect(typeof findings.staleCleanup.approvalAutoCancelled).toBe("number");
+      expect(typeof findings.staleCleanup.approvalTimedOut).toBe("number");
+    });
+
     test("auto-supersedes stalled task with no active session (DES-523)", async () => {
       const agent = await createAgent({ name: "dead-worker", isLead: false, status: "busy" });
       const task = await createTaskExtended("Stalled task", { agentId: agent.id });
@@ -1037,6 +1046,93 @@ describe("Heartbeat Triage", () => {
       expect(retryTask!.priority).toBe(90);
       expect(retryTask!.source).toBe("slack");
     });
+
+    async function sweptTaskWithDependent(taskType?: string) {
+      const agent = await createAgent({ name: "dead-worker", isLead: false, status: "busy" });
+      const other = await createAgent({ name: "dependent-owner", isLead: false, status: "idle" });
+      const parent = await createTaskExtended("Thread root", { agentId: other.id });
+      const swept = await createTaskExtended("Research step", { agentId: agent.id, taskType });
+      await startTask(swept.id);
+      await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [
+        new Date(Date.now() - 1000).toISOString(),
+        swept.id,
+      ]);
+      const done = await createTaskExtended("Already done", { agentId: other.id });
+      await getDbClient().run("UPDATE agent_tasks SET status = 'completed' WHERE id = ?", [
+        done.id,
+      ]);
+      const dependent = await createTaskExtended("Act on the research", {
+        agentId: other.id,
+        dependsOn: [swept.id, done.id],
+        parentTaskId: parent.id,
+        priority: 70,
+        slackChannelId: "C0TEST",
+        slackThreadTs: "1700000000.000100",
+        slackUserId: "U0TEST",
+        followUpConfig: { onCompleted: "Tell the requester" },
+      });
+      return { swept, done, dependent, parent, other };
+    }
+
+    test("reboot sweep re-points a never-started dependent to the retry child instead of failing it", async () => {
+      const { swept, done, dependent, parent, other } = await sweptTaskWithDependent();
+      const cancelled = await createTaskExtended("Cancelled for another reason", {
+        agentId: other.id,
+        dependsOn: [swept.id],
+      });
+      await cancelTask(cancelled.id, "not needed");
+
+      await runRebootSweep();
+
+      expect((await getTaskById(swept.id))?.status).toBe("failed");
+      const retryTaskId = getRebootAffectedTasks()[0]!.retryTaskId;
+      expect(retryTaskId).not.toBeNull();
+
+      const survivor = await getTaskById(dependent.id);
+      expect(survivor?.status).toBe("pending");
+      expect(survivor?.failureReason).toBeFalsy();
+      expect(survivor?.dependsOn).toEqual([retryTaskId!, done.id]);
+      expect(survivor?.agentId).toBe(other.id);
+      expect(survivor?.parentTaskId).toBe(parent.id);
+      expect(survivor?.priority).toBe(70);
+      expect(survivor?.slackChannelId).toBe("C0TEST");
+      expect(survivor?.slackThreadTs).toBe("1700000000.000100");
+      expect(survivor?.slackUserId).toBe("U0TEST");
+      expect(survivor?.followUpConfig).toEqual({ onCompleted: "Tell the requester" });
+
+      const log = await getDbClient().get<{ oldValue: string; newValue: string }>(
+        "SELECT oldValue, newValue FROM agent_log WHERE taskId = ? AND eventType = 'task_dependency_repointed'",
+        [dependent.id],
+      );
+      expect(log).toEqual({ oldValue: swept.id, newValue: retryTaskId! });
+
+      // Already terminal for another reason: untouched.
+      const stillCancelled = await getTaskById(cancelled.id);
+      expect(stillCancelled?.status).toBe("cancelled");
+      expect(stillCancelled?.dependsOn).toEqual([swept.id]);
+    });
+
+    test("reboot sweep without a retry child still cascade-fails dependents", async () => {
+      const { swept, dependent } = await sweptTaskWithDependent("heartbeat-checklist");
+
+      await runRebootSweep();
+
+      expect(getRebootAffectedTasks()[0]!.retryTaskId).toBeNull();
+      const dead = await getTaskById(dependent.id);
+      expect(dead?.status).toBe("failed");
+      expect(dead?.failureReason).toBe(`Blocked dependency ${swept.id.slice(0, 8)} was failed`);
+    });
+
+    test("a non-reboot failure still cascade-fails dependents", async () => {
+      const { swept, dependent } = await sweptTaskWithDependent();
+
+      await failTask(swept.id, "Worker reported an error");
+
+      const dead = await getTaskById(dependent.id);
+      expect(dead?.status).toBe("failed");
+      expect(dead?.failureReason).toBe(`Blocked dependency ${swept.id.slice(0, 8)} was failed`);
+      expect(dead?.dependsOn).toContain(swept.id);
+    });
   });
 
   // ==========================================================================
@@ -1083,13 +1179,13 @@ describe("Heartbeat Triage", () => {
           task.id,
         ]);
 
-        // Session with pre-boot heartbeat (stale)
+        // Session with pre-boot heartbeat, stale past the 15 min threshold
         await insertActiveSession({
           agentId: agent.id,
           taskId: task.id,
           triggerType: "task_assigned",
         });
-        const preBootHb = new Date(bootTime - 30_000).toISOString();
+        const preBootHb = new Date(bootTime - 20 * 60_000).toISOString();
         await getDbClient().run("UPDATE active_sessions SET lastHeartbeatAt = ? WHERE taskId = ?", [
           preBootHb,
           task.id,
@@ -1189,7 +1285,7 @@ describe("Heartbeat Triage", () => {
           taskId: staleTask.id,
           triggerType: "task_assigned",
         });
-        const preBootHb = new Date(bootTime - 30_000).toISOString();
+        const preBootHb = new Date(bootTime - 20 * 60_000).toISOString();
         await getDbClient().run("UPDATE active_sessions SET lastHeartbeatAt = ? WHERE taskId = ?", [
           preBootHb,
           staleTask.id,

package/src/tests/hook-mcp-config.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "bun:test";
+import { loadHookMcpConfig } from "../hooks/hook";
+
+describe("loadHookMcpConfig", () => {
+  test("falls back to the workspace config when the project has no .mcp.json", async () => {
+    const tempDir = `/tmp/hook-mcp-fallback-${crypto.randomUUID()}`;
+    const projectDir = `${tempDir}/repo`;
+    const workspaceDir = `${tempDir}/workspace`;
+    const expected = {
+      url: "http://localhost:3013/mcp",
+      headers: {
+        Authorization: "Bearer example-test-key",
+        "X-Agent-ID": "agent-test-id",
+      },
+    };
+
+    await Bun.$`mkdir -p ${projectDir} ${workspaceDir}`.quiet();
+    try {
+      await Bun.write(
+        `${workspaceDir}/.mcp.json`,
+        JSON.stringify({ mcpServers: { "agent-swarm": expected } }),
+      );
+
+      expect(await loadHookMcpConfig(projectDir, workspaceDir)).toEqual(expected);
+    } finally {
+      await Bun.$`rm -rf ${tempDir}`.quiet();
+    }
+  });
+});

package/src/tests/http-api-integration.test.ts

@@ -573,7 +573,8 @@ describe("Tasks", () => {
     expect(status).toBe(200);
     expect(body.tasks).toBeDefined();
     expect(Array.isArray(body.tasks)).toBe(true);
-    expect(body.total).toBeGreaterThanOrEqual(2);
+    // `total` is an opt-in COUNT(*): omitted unless `includeTotal=true`.
+    expect(body.total).toBeUndefined();
   });
 
   test("GET /api/tasks?status=pending — filter by status", async () => {
@@ -599,12 +600,25 @@ describe("Tasks", () => {
   });
 
   test("GET /api/tasks?limit=1 — pagination", async () => {
-    const { status, body } = await get("/api/tasks?limit=1");
+    const { status, body } = await get("/api/tasks?limit=1&includeTotal=true");
     expect(status).toBe(200);
     expect(body.tasks.length).toBe(1);
     expect(body.total).toBeGreaterThanOrEqual(2);
   });
 
+  test("GET /api/tasks?fields=timeline — narrow timeline rows", async () => {
+    const { status, body } = await get("/api/tasks?fields=timeline&orderBy=createdAt&limit=5");
+    expect(status).toBe(200);
+    expect(body.tasks.length).toBeGreaterThanOrEqual(1);
+    for (const t of body.tasks) {
+      expect(typeof t.id).toBe("string");
+      expect(typeof t.status).toBe("string");
+      expect(t.progress).toBeUndefined();
+      expect(t.tags).toBeUndefined();
+    }
+    expect(body.total).toBeUndefined();
+  });
+
   test("GET /api/tasks/:id — get specific task", async () => {
     const { status, body } = await get(`/api/tasks/${ids.task}`);
     expect(status).toBe(200);

package/src/tests/kv-storage.test.ts

@@ -9,7 +9,9 @@ import {
   getKv,
   incrKv,
   initDb,
+  type KvJsonFieldEquals,
   KvTypeCollisionError,
+  kvPrefixUpperBound,
   listKv,
   sweepExpiredKv,
   sweepExpiredKvPrefix,
@@ -200,6 +202,66 @@ describe("kv-storage helpers", () => {
     expect(exact.map((e) => e.key)).toEqual(["x_1"]);
   });
 
+  test("listKv prefix is an exact, case-sensitive range on the primary key", async () => {
+    for (const key of ["m/row/1", "m/row/2", "M/row/3", "m/rowx", "m/row", "n/row/1", "m/row/é"]) {
+      await upsertKv({ namespace: NS, key, value: 1, valueType: "integer" });
+    }
+    const rows = await listKv(NS, { prefix: "m/row/", limit: 100, offset: 0 });
+    expect(rows.map((e) => e.key)).toEqual(["m/row/1", "m/row/2", "m/row/é"]);
+    expect(await countKv(NS, { prefix: "m/row/" })).toBe(3);
+    expect(kvPrefixUpperBound("m/row/")).toBe("m/row0");
+    expect(kvPrefixUpperBound(`a${String.fromCodePoint(0x10ffff)}`)).toBe("b");
+    expect(kvPrefixUpperBound(String.fromCodePoint(0xd7ff))).toBe(String.fromCodePoint(0xe000));
+
+    const plan = await getDbClient().query<{ detail: string }>(
+      `EXPLAIN QUERY PLAN SELECT key FROM kv_entries
+        WHERE namespace = ? AND (expires_at IS NULL OR expires_at > ?) AND key >= ? AND key < ?`,
+      [NS, 0, "m/row/", "m/row0"],
+    );
+    expect(plan.map((row) => row.detail).join(" ")).toContain("key>? AND key<?");
+  });
+
+  test("listKv jsonFieldEquals narrows rows in SQL and skips corrupt JSON", async () => {
+    await upsertKv({
+      namespace: NS,
+      key: "r/1",
+      value: { run: "a", ok: true, n: 2 },
+      valueType: "json",
+    });
+    await upsertKv({
+      namespace: NS,
+      key: "r/2",
+      value: { run: "b", ok: false, n: 2 },
+      valueType: "json",
+    });
+    await upsertKv({
+      namespace: NS,
+      key: "r/3",
+      value: { run: "a", ok: false, n: 3.5 },
+      valueType: "json",
+    });
+    await getDbClient().run(
+      "INSERT INTO kv_entries (namespace, key, value, value_type) VALUES (?, ?, ?, 'json')",
+      [NS, "r/4", "{not json"],
+    );
+    const keys = async (jsonFieldEquals: KvJsonFieldEquals[]) =>
+      (await listKv(NS, { prefix: "r/", limit: 100, offset: 0, jsonFieldEquals })).map(
+        (e) => e.key,
+      );
+    expect(await keys([])).toEqual(["r/1", "r/2", "r/3", "r/4"]);
+    expect(await keys([{ field: "run", value: "a" }])).toEqual(["r/1", "r/3"]);
+    expect(await keys([{ field: "ok", value: true }])).toEqual(["r/1"]);
+    // Non-safe-integer numbers are not prefiltered (the caller re-checks).
+    expect(await keys([{ field: "n", value: 3.5 }])).toEqual(["r/1", "r/2", "r/3", "r/4"]);
+    expect(
+      await keys([
+        { field: "run", value: "a" },
+        { field: "n", value: 2 },
+      ]),
+    ).toEqual(["r/1"]);
+    expect(await keys([{ field: "missing", value: "a" }])).toEqual([]);
+  });
+
   test("incrKv creates from missing", async () => {
     const entry = await incrKv(NS, "counter", 3);
     expect(entry.value).toBe(3);

package/src/tests/linear-outbound-sync.test.ts

@@ -2,7 +2,12 @@ import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, mock, tes
 import { unlink } from "node:fs/promises";
 import { closeDb, initDb } from "../be/db";
 import { createTrackerSync, getTrackerSync, updateTrackerSync } from "../be/db-queries/tracker";
-import { initLinearOutboundSync, teardownLinearOutboundSync } from "../linear/outbound";
+import {
+  formatLinearOutcomeBody,
+  initLinearOutboundSync,
+  LINEAR_BODY_MAX,
+  teardownLinearOutboundSync,
+} from "../linear/outbound";
 import { taskSessionMap } from "../linear/sync";
 import { workflowEventBus } from "../workflows/event-bus";
 
@@ -79,8 +84,8 @@ describe("Linear Outbound Sync", () => {
     const callArgs = mockCreateComment.mock.calls[0] as unknown[];
     const arg = callArgs[0] as { issueId: string; body: string };
     expect(arg.issueId).toBe("LIN-OUT-COMPLETED");
-    expect(arg.body).toContain("Task completed");
-    expect(arg.body).toContain("All done!");
+    // The output is the whole comment: no boilerplate, no collapsed `+++` section.
+    expect(arg.body).toBe("All done!");
 
     // Verify sync record updated
     const updated = await getTrackerSync("linear", "task", "outbound-task-completed");
@@ -107,8 +112,118 @@ describe("Linear Outbound Sync", () => {
     const callArgs = mockCreateComment.mock.calls[0] as unknown[];
     const arg = callArgs[0] as { issueId: string; body: string };
     expect(arg.issueId).toBe("LIN-OUT-FAILED");
-    expect(arg.body).toContain("Task failed");
-    expect(arg.body).toContain("Build error in module X");
+    expect(arg.body).toBe("Task failed.\n\nBuild error in module X");
+  });
+
+  test("task.completed with an AgentSession posts ONE response activity carrying the full output", async () => {
+    const taskId = "outbound-session-completed";
+    await createTrackerSync({
+      provider: "linear",
+      entityType: "task",
+      swarmId: taskId,
+      externalId: "LIN-OUT-SESSION-COMPLETED",
+      syncDirection: "bidirectional",
+    });
+    taskSessionMap.set(taskId, "session-completed");
+    // Longer than the old 2000-char cut, shorter than the Linear body cap.
+    const output = `## Answer\n\n${"x".repeat(5000)}`;
+
+    workflowEventBus.emit("task.completed", { taskId, output });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockEndAgentSession).toHaveBeenCalledTimes(1);
+    expect(mockEndAgentSession.mock.calls[0] as unknown[]).toEqual([
+      "session-completed",
+      output,
+      "response",
+    ]);
+    expect(mockCreateComment).not.toHaveBeenCalled();
+    expect(taskSessionMap.has(taskId)).toBe(false);
+  });
+
+  test("task.failed with an AgentSession posts ONE error activity with the plain reason", async () => {
+    const taskId = "outbound-session-failed";
+    await createTrackerSync({
+      provider: "linear",
+      entityType: "task",
+      swarmId: taskId,
+      externalId: "LIN-OUT-SESSION-FAILED",
+      syncDirection: "bidirectional",
+    });
+    taskSessionMap.set(taskId, "session-failed");
+
+    workflowEventBus.emit("task.failed", { taskId, failureReason: "tsc:check failed" });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockEndAgentSession).toHaveBeenCalledTimes(1);
+    expect(mockEndAgentSession.mock.calls[0] as unknown[]).toEqual([
+      "session-failed",
+      "Task failed.\n\ntsc:check failed",
+      "error",
+    ]);
+    expect(mockCreateComment).not.toHaveBeenCalled();
+  });
+
+  test("task.completed with no output still ends the session with a short body", async () => {
+    const taskId = "outbound-session-empty";
+    await createTrackerSync({
+      provider: "linear",
+      entityType: "task",
+      swarmId: taskId,
+      externalId: "LIN-OUT-SESSION-EMPTY",
+      syncDirection: "bidirectional",
+    });
+    taskSessionMap.set(taskId, "session-empty");
+
+    workflowEventBus.emit("task.completed", { taskId, output: "  " });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockEndAgentSession.mock.calls[0] as unknown[]).toEqual([
+      "session-empty",
+      "Task completed.",
+      "response",
+    ]);
+  });
+
+  describe("formatLinearOutcomeBody", () => {
+    const savedDashboard = process.env.SWARM_DASHBOARD_URL;
+    const savedApp = process.env.APP_URL;
+
+    afterEach(() => {
+      if (savedDashboard === undefined) delete process.env.SWARM_DASHBOARD_URL;
+      else process.env.SWARM_DASHBOARD_URL = savedDashboard;
+      if (savedApp === undefined) delete process.env.APP_URL;
+      else process.env.APP_URL = savedApp;
+    });
+
+    test("returns text at the cap unchanged", () => {
+      const text = "a".repeat(LINEAR_BODY_MAX);
+      expect(formatLinearOutcomeBody(text, "t1")).toBe(text);
+    });
+
+    test("caps oversized text with a visible note linking the swarm task", () => {
+      delete process.env.SWARM_DASHBOARD_URL;
+      process.env.APP_URL = "https://swarm.example.com/";
+      const text = "b".repeat(LINEAR_BODY_MAX + 500);
+
+      const body = formatLinearOutcomeBody(text, "task-123");
+
+      expect(body.length).toBeLessThanOrEqual(LINEAR_BODY_MAX);
+      expect(body.startsWith("b".repeat(1000))).toBe(true);
+      expect(body).toContain(`of ${text.length} characters`);
+      expect(body.endsWith("Full text: https://swarm.example.com/tasks/task-123_")).toBe(true);
+      expect(body).not.toContain("+++");
+    });
+
+    test("names the task id when no dashboard URL is configured", () => {
+      delete process.env.SWARM_DASHBOARD_URL;
+      delete process.env.APP_URL;
+
+      const body = formatLinearOutcomeBody("c".repeat(LINEAR_BODY_MAX + 1), "task-456");
+
+      expect(body.length).toBeLessThanOrEqual(LINEAR_BODY_MAX);
+      expect(body.endsWith("Full text: swarm task `task-456`_")).toBe(true);
+    });
   });
 
   test("no-op when no tracker_sync mapping exists", async () => {

package/src/tests/list-endpoint-slimming.test.ts

@@ -11,6 +11,7 @@ import {
   getAgentById,
   getAllAgents,
   getAllTasks,
+  getDbClient,
   getScheduledTasks,
   initDb,
   listAllPages,
@@ -227,6 +228,96 @@ describe("list-endpoint slimming", () => {
     expect(full?.totalCostUsd).toBeCloseTo(0.0168, 6);
   });
 
+  test("getAllTasks — SQL-side preview matches truncating the full text", async () => {
+    // The SQL cut counts UTF-8 bytes while JS slices UTF-16 units, so pin the
+    // boundary with astral (surrogate-pair) and multibyte characters. SQLite's
+    // text functions stop at an embedded NUL, so pin that too, plus a leading
+    // BOM a default TextDecoder would strip. The BOM goes in as SQL bytes:
+    // bun:sqlite drops a leading BOM when it binds a string.
+    const agentId = "preview-parity-agent";
+    const marker = "preview-parity-";
+    const texts = [
+      `${marker}${"a".repeat(285)}`, // exactly 300 units
+      `${marker}${"a".repeat(286)}`, // 301 units
+      `${marker}${"😀".repeat(200)}`,
+      `${marker}${"é".repeat(284)}😀`,
+      `${marker}${"ñ".repeat(500)}`,
+      `${marker}short`,
+      "a\u0000b",
+      `\u0000${"x".repeat(350)}`,
+    ];
+    for (const text of texts) await createTaskExtended(text, { agentId });
+    const bom = await createTaskExtended(`${marker}bom`, { agentId });
+    texts.push(`\uFEFF${marker}bom`);
+    await getDbClient().run(
+      "UPDATE agent_tasks SET task = CAST(x'EFBBBF' AS TEXT) || task WHERE id = ?",
+      [bom.id],
+    );
+
+    const full = await getAllTasks({ agentId, limit: 50 });
+    expect(full.map((t) => t.task).sort()).toEqual([...texts].sort());
+    for (const opts of [{ slim: true }, { fields: "timeline" as const }]) {
+      const rows = await getAllTasks({ agentId, limit: 50 }, opts);
+      expect(rows.map((t) => t.id)).toEqual(full.map((t) => t.id));
+      for (const [i, row] of full.entries()) {
+        const expected = row.task.length > 300 ? `${row.task.slice(0, 300)}…` : row.task;
+        expect(rows[i]!.task).toBe(expected);
+      }
+    }
+  });
+
+  test("getAllTasks — slim and full pages hold the same rows in the same order", async () => {
+    for (let i = 0; i < 12; i++) {
+      await createTaskExtended(`page-parity ${i}`, { agentId: "slim-agent-1" });
+    }
+    for (const orderBy of ["lastUpdatedAt", "createdAt"] as const) {
+      for (const offset of [0, 5, 10]) {
+        const filters = { search: "page-parity", limit: 5, offset, orderBy };
+        const slimIds = (await getAllTasks(filters, { slim: true })).map((t) => t.id);
+        const fullIds = (await getAllTasks(filters)).map((t) => t.id);
+        const timelineIds = (await getAllTasks(filters, { fields: "timeline" })).map((t) => t.id);
+        expect(slimIds).toEqual(fullIds);
+        expect(timelineIds).toEqual(fullIds);
+      }
+    }
+  });
+
+  test("getAllTasks — timeline projection carries only what the timeline draws", async () => {
+    const task = await createTaskExtended(`timeline-row ${"T".repeat(1000)}`, {
+      agentId: "slim-agent-1",
+      tags: ["timeline"],
+    });
+    await createSessionCost({
+      sessionId: "timeline-cost-session",
+      taskId: task.id,
+      agentId: "slim-agent-1",
+      totalCostUsd: 0.25,
+      durationMs: 1000,
+      numTurns: 1,
+      model: "test-model",
+    });
+
+    const [row] = await getAllTasks({ search: "timeline-row", limit: 1 }, { fields: "timeline" });
+    expect(Object.keys(row!).sort()).toEqual(
+      [
+        "agentId",
+        "createdAt",
+        "finishedAt",
+        "id",
+        "lastUpdatedAt",
+        "parentTaskId",
+        "peakContextTokens",
+        "status",
+        "task",
+        "title",
+        "totalCostUsd",
+      ].sort(),
+    );
+    expect(row!.id).toBe(task.id);
+    expect(row!.task).toBe(`${task.task.slice(0, 300)}…`);
+    expect(row!.totalCostUsd).toBeCloseTo(0.25, 6);
+  });
+
   test("listRecentSessions — slim root is a truncated task summary", async () => {
     const longText = "Q".repeat(2000);
     await createTaskExtended(longText, { agentId: "slim-agent-1" });