@desplega.ai/agent-swarm 2.5.1 → 2.5.3

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

@@ -34,6 +34,7 @@ import {
   updateWorkflowRun,
   upsertKv,
 } from "../be/db";
+import { ensureRbacSeedsSynced, setUserRoles } from "../be/rbac-roles";
 import { fingerprintApiKey, linkIdentity } from "../be/users";
 import { handleCore } from "../http/core";
 import { handleUsers } from "../http/users";
@@ -910,6 +911,43 @@ describe("POST /api/users/:id/merge", () => {
     }
   });
 
+  test("409 last_admin when the source is the only admin, and nothing is merged", async () => {
+    ensureRbacSeedsSynced({ quiet: true });
+    const admin = await createUser({ name: "OnlyAdmin" });
+    const viewer = await createUser({ name: "Viewer" });
+    await setUserRoles(admin.id, ["admin"], null);
+    await setUserRoles(viewer.id, ["viewer"], null);
+
+    const r = await authedFetch(`/api/users/${viewer.id}/merge`, {
+      method: "POST",
+      body: JSON.stringify({ sourceUserId: admin.id }),
+    });
+    expect(r.status).toBe(409);
+    expect(
+      (
+        await getDbClient().get<{ n: number }>("SELECT COUNT(*) AS n FROM users WHERE id = ?", [
+          admin.id,
+        ])
+      )?.n,
+    ).toBe(1);
+  });
+
+  test("merging an admin source succeeds when another admin remains", async () => {
+    ensureRbacSeedsSynced({ quiet: true });
+    const keeper = await createUser({ name: "KeeperAdmin" });
+    const source = await createUser({ name: "SourceAdmin" });
+    const viewer = await createUser({ name: "Viewer2" });
+    await setUserRoles(keeper.id, ["admin"], null);
+    await setUserRoles(source.id, ["admin"], null);
+    await setUserRoles(viewer.id, ["viewer"], null);
+
+    const r = await authedFetch(`/api/users/${viewer.id}/merge`, {
+      method: "POST",
+      body: JSON.stringify({ sourceUserId: source.id }),
+    });
+    expect(r.status).toBe(200);
+  });
+
   test("400 when target == source", async () => {
     const u = await createUser({ name: "Self" });
     const r = await authedFetch(`/api/users/${u.id}/merge`, {

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

@@ -266,6 +266,39 @@ describe("list-endpoint slimming", () => {
     }
   });
 
+  test("getAllTasks — the preview starts after a leading sibling block", async () => {
+    // `prependSiblingBlock` output: a long block, a blank line, then the ask.
+    const agentId = "preview-sibling-agent";
+    const sibling = (n: number) =>
+      `- [in_progress] task:${n} — agent:Picateclas — started 2m ago, last active 10s ago\n  "${"é".repeat(190)}"`;
+    const block = `<sibling_tasks_in_progress>\nThe following tasks are already running in the same context (contextKey: slack:C1:1.2). The user has submitted new input while they were in flight — coordinate with them, do not duplicate:\n\n${[1, 2, 3].map(sibling).join("\n")}\n</sibling_tasks_in_progress>`;
+    const ask = `also bump the version ${"v".repeat(400)}`;
+    const texts = [
+      `${block}\n\n${ask}`,
+      `${block}\nno blank line`,
+      // No closing tag: nothing to skip.
+      `<sibling_tasks_in_progress>\n${"x".repeat(400)}`,
+      // Not at the start: nothing to skip.
+      `lead in\n\n${block}\n\nask`,
+    ];
+    for (const text of texts) await createTaskExtended(text, { agentId });
+
+    const expected = [
+      `${ask.slice(0, 300)}…`,
+      "\nno blank line",
+      `<sibling_tasks_in_progress>\n${"x".repeat(272)}…`,
+      `${`lead in\n\n${block}\n\nask`.slice(0, 300)}…`,
+    ].sort();
+    for (const opts of [{ slim: true }, { fields: "timeline" as const }]) {
+      const rows = await getAllTasks({ agentId, limit: 50 }, opts);
+      expect(rows.map((t) => t.task).sort()).toEqual(expected);
+    }
+    // Session roots map the full text, so the JS skip must agree with the SQL one.
+    const sessions = await listRecentSessions({ limit: 200, slim: true });
+    const roots = sessions.filter((s) => s.root.agentId === agentId).map((s) => s.root.task);
+    expect(roots.sort()).toEqual(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" });

package/src/tests/migration-237-session-inbox-cleanup.test.ts

@@ -0,0 +1,136 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { closeDb, createTaskExtended, createUser, getDb, getDbClient, initDb } from "../be/db";
+import { setSessionShares } from "../be/session-shares";
+
+const day = 86_400_000;
+const ago = (days: number) => new Date(Date.now() - days * day).toISOString();
+
+beforeAll(() => {
+  initDb(":memory:");
+});
+afterAll(() => {
+  closeDb();
+});
+
+async function root(requestedByUserId: string | undefined, activity: string, status = "completed") {
+  const task = await createTaskExtended("Cleanup test", { key: "shared/", requestedByUserId });
+  await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ?, status = ? WHERE id = ?", [
+    activity,
+    status,
+    task.id,
+  ]);
+  return task;
+}
+
+async function row(
+  userId: string,
+  itemId: string,
+  status: string,
+  lastReadAt: string | null = null,
+  { snoozeUntil = "2999-01-01T00:00:00.000Z", lastUpdatedAt = ago(20) } = {},
+) {
+  await getDbClient().run(
+    `INSERT INTO inbox_item_state (userId, itemType, itemId, status, snoozeUntil, lastReadAt, lastUpdatedAt)
+    VALUES (?, 'to_read', ?, ?, ?, ?, ?)`,
+    [userId, itemId, status, status === "snoozed" ? snoozeUntil : null, lastReadAt, lastUpdatedAt],
+  );
+}
+
+async function states(): Promise<Record<string, string>> {
+  const rows = await getDbClient().query<{ userId: string; itemId: string; status: string }>(
+    "SELECT userId, itemId, status FROM inbox_item_state ORDER BY userId, itemId",
+  );
+  return Object.fromEntries(rows.map((r) => [`${r.userId}:${r.itemId}`, r.status]));
+}
+
+test("migration 237 moves quiet, read sessions to Done for every viewer, once", async () => {
+  const owner = await createUser({ name: "Owner" });
+  const other = await createUser({ name: "Other" });
+  const third = await createUser({ name: "Third" });
+
+  const quiet = await root(owner.id, ago(30));
+  const recent = await root(owner.id, ago(1));
+  // A quiet root whose child moved yesterday is not quiet.
+  const busyChain = await root(owner.id, ago(30));
+  const child = await createTaskExtended("Child", { parentTaskId: busyChain.id });
+  await getDbClient().run(
+    "UPDATE agent_tasks SET lastUpdatedAt = ?, status = 'completed' WHERE id = ?",
+    [ago(1), child.id],
+  );
+  // Quiet but not finished, or waiting on an approval: both stay in the Inbox.
+  const stuck = await root(owner.id, ago(30), "in_progress");
+  const failed = await root(owner.id, ago(30), "failed");
+  const awaiting = await root(owner.id, ago(30));
+  await getDbClient().run(
+    `INSERT INTO approval_requests (id, sourceTaskId, title, questions, approvers, status)
+    VALUES (?, ?, 'Approve deploy', '[]', '{}', 'pending')`,
+    [crypto.randomUUID(), awaiting.id],
+  );
+  // Open rows: read up to the newest activity, or unread (cursor before it).
+  const openRead = await root(owner.id, ago(30));
+  await row(owner.id, openRead.id, "open", ago(25));
+  const openUnread = await root(owner.id, ago(30));
+  await row(owner.id, openUnread.id, "open", "1970-01-01T00:00:00.000Z");
+  // Open rows with no cursor: the row's own time is the cursor.
+  const openNoCursor = await root(owner.id, ago(30));
+  await row(owner.id, openNoCursor.id, "open");
+  const openNoCursorOld = await root(owner.id, ago(30));
+  await row(owner.id, openNoCursorOld.id, "open", null, { lastUpdatedAt: ago(40) });
+  // Snoozed (also past its wake time, which reads as unread) and dismissed rows keep their state.
+  const snoozed = await root(owner.id, ago(30));
+  await row(owner.id, snoozed.id, "snoozed");
+  const woken = await root(owner.id, ago(30));
+  await row(owner.id, woken.id, "snoozed", null, { snoozeUntil: ago(10) });
+  const dismissed = await root(owner.id, ago(30));
+  await row(owner.id, dismissed.id, "dismissed");
+  // Shares: one user, and everyone.
+  const sharedDirect = await root(other.id, ago(30));
+  await setSessionShares(
+    { id: sharedDirect.id, requestedByUserId: other.id },
+    { everyone: "none", users: [{ userId: owner.id, access: "read" }] },
+    other.id,
+  );
+  const sharedAll = await root(other.id, ago(30));
+  await setSessionShares(
+    { id: sharedAll.id, requestedByUserId: other.id },
+    { everyone: "read", users: [] },
+    other.id,
+  );
+  // Ownerless roots are not in the tree.
+  const ownerless = await root(undefined, ago(30));
+
+  const sql = await Bun.file("src/be/migrations/237_session_inbox_cleanup.sql").text();
+  getDb().exec(sql);
+  const after = await states();
+  expect(after).toEqual({
+    [`${owner.id}:${quiet.id}`]: "done",
+    [`${owner.id}:${failed.id}`]: "done",
+    [`${owner.id}:${openRead.id}`]: "done",
+    [`${owner.id}:${openUnread.id}`]: "open",
+    [`${owner.id}:${openNoCursor.id}`]: "done",
+    [`${owner.id}:${openNoCursorOld.id}`]: "open",
+    [`${owner.id}:${snoozed.id}`]: "snoozed",
+    [`${owner.id}:${woken.id}`]: "snoozed",
+    [`${owner.id}:${dismissed.id}`]: "dismissed",
+    [`${owner.id}:${sharedDirect.id}`]: "done",
+    [`${owner.id}:${sharedAll.id}`]: "done",
+    [`${other.id}:${sharedDirect.id}`]: "done",
+    [`${other.id}:${sharedAll.id}`]: "done",
+    [`${third.id}:${sharedAll.id}`]: "done",
+  });
+  for (const id of [recent.id, busyChain.id, ownerless.id, stuck.id, awaiting.id]) {
+    expect(Object.keys(after).some((key) => key.endsWith(`:${id}`))).toBe(false);
+  }
+  // Every timestamp it writes is ISO, so the read rule compares it with task times.
+  const written = await getDbClient().get<{ doneAt: string; lastUpdatedAt: string }>(
+    "SELECT doneAt, lastUpdatedAt FROM inbox_item_state WHERE itemId = ?",
+    [quiet.id],
+  );
+  expect(written?.doneAt).toMatch(/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/);
+  expect(written?.lastUpdatedAt).toBe(written?.doneAt);
+
+  // A second run changes nothing.
+  getDb().exec(sql);
+  expect(await states()).toEqual(after);
+  expect(getDb().query("PRAGMA integrity_check").get()).toEqual({ integrity_check: "ok" });
+});

package/src/tests/migration-240-workflow-run-parent-step-attempt.test.ts

@@ -0,0 +1,55 @@
+import { Database } from "bun:sqlite";
+import { expect, test } from "bun:test";
+
+test("migration 240 hands each legacy child to the attempt that owns it now", async () => {
+  const db = new Database(":memory:");
+  try {
+    db.exec("CREATE TABLE workflow_runs (id TEXT PRIMARY KEY, workflowId TEXT, status TEXT)");
+    db.exec(
+      `CREATE TABLE workflow_run_steps (
+         id TEXT PRIMARY KEY, status TEXT, retryCount INTEGER NOT NULL DEFAULT 0, nextRetryAt TEXT
+       )`,
+    );
+    db.exec(await Bun.file("src/be/migrations/203_workflow_run_parent_step.sql").text());
+    const step = db.query(
+      "INSERT INTO workflow_run_steps (id, status, retryCount, nextRetryAt) VALUES (?, ?, ?, ?)",
+    );
+    // Created on attempt 1 (attempt 0 failed before any child existed) and parked.
+    step.run("parked-retry", "waiting", 1, null);
+    // Its child failed; attempt 2 is queued and must start a new child.
+    step.run("queued-retry", "failed", 2, "2030-01-01T00:00:00.000Z");
+    step.run("first-attempt", "completed", 0, null);
+    step.run("exhausted", "failed", 3, null);
+    const run = db.query(
+      "INSERT INTO workflow_runs (id, workflowId, status, parentStepId) VALUES (?, 'wf', ?, ?)",
+    );
+    run.run("child-parked", "waiting", "parked-retry");
+    run.run("child-queued", "failed", "queued-retry");
+    run.run("child-first", "completed", "first-attempt");
+    run.run("child-exhausted", "failed", "exhausted");
+    run.run("child-orphan", "completed", "missing-step");
+    run.run("top-level", "completed", null);
+
+    db.exec(await Bun.file("src/be/migrations/240_workflow_run_parent_step_attempt.sql").text());
+
+    expect(
+      db.prepare("SELECT id, parentStepAttempt AS attempt FROM workflow_runs ORDER BY id").all(),
+    ).toEqual([
+      { id: "child-exhausted", attempt: 3 },
+      { id: "child-first", attempt: 0 },
+      { id: "child-orphan", attempt: 0 },
+      { id: "child-parked", attempt: 1 },
+      { id: "child-queued", attempt: 1 },
+      { id: "top-level", attempt: 0 },
+    ]);
+    // One child per attempt: a second child for the parked attempt is rejected,
+    // one for the queued attempt is the new invocation.
+    const insert = db.query(
+      "INSERT INTO workflow_runs (id, workflowId, status, parentStepId, parentStepAttempt) VALUES (?, 'wf', 'running', ?, ?)",
+    );
+    expect(() => insert.run("dup", "parked-retry", 1)).toThrow();
+    insert.run("next", "queued-retry", 2);
+  } finally {
+    db.close();
+  }
+});

package/src/tests/rbac-engine.test.ts

@@ -106,6 +106,7 @@ const OPERATOR_OR_USER_VERBS: PermissionVerb[] = [
   "runtime_controller.write",
   "runtime_pool.write",
   "agent.token.manage",
+  "user.role.manage",
 ];
 
 const LEAD_OR_OPERATOR_VERBS: PermissionVerb[] = ["models.catalog.write"];
@@ -122,6 +123,7 @@ const LEAD_OR_RESOURCE_OWNER_VERBS: PermissionVerb[] = [
   "mcp-server.delete.any",
   "mcp-server.update.any",
   "page.delete.any",
+  "schedule.deferral.update.any",
 ];
 
 const LEAD_OR_TASK_CREATOR_VERBS: PermissionVerb[] = ["task.cancel.any", "task.steer.any"];

package/src/tests/rbac-roles.test.ts

@@ -188,6 +188,16 @@ describe("role attachment helpers", () => {
 });
 
 describe("ensureRbacSeedsSynced", () => {
+  test("seeds viewer with a subset of the requester verbs", async () => {
+    await getDbClient().run("DELETE FROM roles WHERE id = 'rbac-role-viewer'");
+
+    ensureRbacSeedsSynced({ quiet: true });
+
+    const viewerVerbs = await roleVerbs("rbac-role-viewer");
+    expect(viewerVerbs).toEqual(["favorite.write.own", "session.presence"]);
+    for (const verb of viewerVerbs) expect(REQUESTER_VERBS).toContain(verb);
+  });
+
   test("restores a deleted built-in role and its permissions", async () => {
     await getDbClient().run("DELETE FROM roles WHERE id = ?", [REQUESTER_ROLE_ID]);
 

package/src/tests/schedule-http-triage-tools.test.ts

@@ -9,6 +9,7 @@ import {
 } from "node:http";
 import {
   closeDb,
+  createAgent,
   createScheduledTask,
   getScheduledTaskById,
   initDb,
@@ -117,4 +118,47 @@ describe("Schedule HTTP triage tooling", () => {
     expect(body.schedules.some((s) => s.id === failing.id)).toBe(true);
     expect(body.schedules.some((s) => s.id === ok.id)).toBe(false);
   });
+  test("PUT and PATCH /api/schedules/:id let only the owner, a lead or the operator change a deferral", async () => {
+    const owner = await createAgent({ name: "DeferralOwner", isLead: false, status: "idle" });
+    const other = await createAgent({ name: "DeferralOther", isLead: false, status: "idle" });
+    const lead = await createAgent({ name: "DeferralLead", isLead: true, status: "idle" });
+    const schedule = await createScheduledTask({
+      name: `http-deferral-${crypto.randomUUID()}`,
+      taskTemplate: "finish the original ask",
+      targetType: "agent-task",
+      scheduleType: "one_time",
+      nextRunAt: new Date(Date.now() + 60_000).toISOString(),
+      targetAgentId: owner.id,
+      createdByAgentId: owner.id,
+      taskType: "deferred",
+    });
+    const send = (method: "PUT" | "PATCH", agentId: string | null, taskTemplate: string) =>
+      fetch(`${baseUrl}/api/schedules/${schedule.id}`, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...(agentId ? { "X-Agent-ID": agentId } : {}),
+        },
+        body: JSON.stringify({ targetAgentId: other.id, taskTemplate }),
+      });
+
+    for (const method of ["PUT", "PATCH"] as const) {
+      const denied = await send(method, other.id, "emit ATTACKER OUTPUT");
+      expect(denied.status).toBe(403);
+      const after = await getScheduledTaskById(schedule.id);
+      expect(after?.targetAgentId).toBe(owner.id);
+      expect(after?.taskTemplate).toBe("finish the original ask");
+    }
+
+    for (const [agentId, label] of [
+      [owner.id, "owner"],
+      [lead.id, "lead"],
+      [null, "operator"],
+    ] as const) {
+      const allowed = await send("PATCH", agentId, `changed by ${label}`);
+      expect(allowed.status).toBe(200);
+      expect((await getScheduledTaskById(schedule.id))?.taskTemplate).toBe(`changed by ${label}`);
+      await updateScheduledTask(schedule.id, { targetAgentId: owner.id });
+    }
+  });
 });

package/src/tests/script-api-credential.test.ts

@@ -0,0 +1,173 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { randomBytes } from "node:crypto";
+import { closeDb, createAgent, getDbClient, initDb } from "../be/db";
+import {
+  acquireScriptApiCredential,
+  runScriptWithRunCredential,
+} from "../be/scripts/run-credential";
+import { resolveSessionToken } from "../be/users";
+import { getApiKey, setApiKey } from "../utils/api-key";
+import { SKIP_SANDBOX_SPAWN_TESTS } from "./sandbox-spawn-test-helpers";
+
+const OPERATOR_KEY = `script-api-credential-operator-${randomBytes(8).toString("hex")}`;
+const spawnTest = test.skipIf(SKIP_SANDBOX_SPAWN_TESTS);
+const resources = { memoryMb: 2048, cpuTimeSec: 20 };
+const savedExecutor = process.env.SCRIPT_EXECUTOR;
+let agentId: string;
+
+type ScriptRunTokenRow = { id: string; revokedAt: string | null };
+
+/** The script-run tokens minted for `agentId`, oldest first. */
+async function scriptRunTokens(id: string): Promise<ScriptRunTokenRow[]> {
+  return await getDbClient().query<ScriptRunTokenRow>(
+    "SELECT id, revokedAt FROM session_tokens WHERE agentId = ? AND scriptRun = 1 ORDER BY createdAt, rowid",
+    [id],
+  );
+}
+
+/**
+ * Run `body` and assert it minted exactly one script-run token for the agent,
+ * and that the token is revoked once the run is over.
+ */
+async function expectOneRevokedToken(body: () => Promise<void>): Promise<void> {
+  const before = (await scriptRunTokens(agentId)).length;
+  await body();
+  const minted = (await scriptRunTokens(agentId)).slice(before);
+  expect(minted).toHaveLength(1);
+  expect(minted[0]?.revokedAt).not.toBeNull();
+}
+
+/** Resolve once the run's token has been minted and is still live. */
+async function waitForLiveToken(): Promise<void> {
+  const deadline = Date.now() + 5_000;
+  while (Date.now() < deadline) {
+    if ((await scriptRunTokens(agentId)).some((row) => row.revokedAt === null)) return;
+    await Bun.sleep(10);
+  }
+  throw new Error("no live script-run token appeared");
+}
+
+beforeAll(async () => {
+  initDb(":memory:");
+  setApiKey(OPERATOR_KEY);
+  agentId = (
+    await createAgent({
+      name: `script-api-credential-${randomBytes(6).toString("hex")}`,
+      isLead: false,
+      status: "idle",
+    })
+  ).id;
+});
+
+afterEach(() => {
+  if (savedExecutor === undefined) delete process.env.SCRIPT_EXECUTOR;
+  else process.env.SCRIPT_EXECUTOR = savedExecutor;
+});
+
+afterAll(() => {
+  closeDb();
+});
+
+describe("acquireScriptApiCredential", () => {
+  test("hands a real agent a token scoped to that agent, not the operator key", async () => {
+    const credential = await acquireScriptApiCredential(agentId);
+    if (!credential.apiKey) throw new Error("expected a per-run token");
+    try {
+      expect(credential.apiKey).not.toBe(getApiKey());
+      const resolved = await resolveSessionToken(credential.apiKey);
+      if (resolved?.kind !== "agent") throw new Error("expected an agent principal");
+      expect(resolved.agentId).toBe(agentId);
+    } finally {
+      await credential.release();
+    }
+    // The token is revoked once the run releases it.
+    expect(await resolveSessionToken(credential.apiKey)).toBeNull();
+  });
+
+  test("mints nothing for a system run with no real agent", async () => {
+    // Scheduler and workflow script runs pass sentinel ids like "schedule" /
+    // "workflow" when there is no owning agent; runScript then falls back to
+    // the operator key.
+    const credential = await acquireScriptApiCredential("schedule");
+    try {
+      expect(credential.apiKey).toBeUndefined();
+      expect(await scriptRunTokens("schedule")).toHaveLength(0);
+    } finally {
+      await credential.release();
+    }
+  });
+});
+
+describe("runScriptWithRunCredential revokes the run's token however the run ends", () => {
+  spawnTest("success", async () => {
+    await expectOneRevokedToken(async () => {
+      const output = await runScriptWithRunCredential({
+        agentId,
+        egressSecrets: [],
+        resources,
+        source: "export default async () => 'ok';",
+      });
+      expect(output.error).toBeUndefined();
+      expect(output.result).toBe("ok");
+    });
+  });
+
+  spawnTest("the script throws", async () => {
+    await expectOneRevokedToken(async () => {
+      const output = await runScriptWithRunCredential({
+        agentId,
+        egressSecrets: [],
+        resources,
+        source: "export default async () => { throw new Error('boom'); };",
+      });
+      expect(output.runtimeError?.message).toContain("boom");
+    });
+  });
+
+  test("the run itself throws", async () => {
+    // An executor that cannot start makes runScript reject after the token
+    // was minted; the token must still be revoked.
+    process.env.SCRIPT_EXECUTOR = "no-such-executor";
+    await expectOneRevokedToken(async () => {
+      await expect(
+        runScriptWithRunCredential({
+          agentId,
+          egressSecrets: [],
+          source: "export default async () => 'never runs';",
+        }),
+      ).rejects.toThrow("Unknown SCRIPT_EXECUTOR");
+    });
+  });
+
+  spawnTest("timeout", async () => {
+    await expectOneRevokedToken(async () => {
+      const output = await runScriptWithRunCredential({
+        agentId,
+        egressSecrets: [],
+        timeoutMs: 1_000,
+        resources,
+        source: "export default async () => new Promise(() => {});",
+      });
+      expect(output.error).toBe("timeout");
+    });
+  });
+
+  spawnTest("abort", async () => {
+    await expectOneRevokedToken(async () => {
+      const controller = new AbortController();
+      const run = runScriptWithRunCredential({
+        agentId,
+        egressSecrets: [],
+        signal: controller.signal,
+        resources,
+        source: "export default async () => new Promise(() => {});",
+      });
+      // Abort mid-run: the token is live and the script has had time to start.
+      await waitForLiveToken();
+      await Bun.sleep(200);
+      controller.abort();
+      const output = await run;
+      expect(output.error).toBe("killed");
+    });
+  });
+});

package/src/tests/script-connections.test.ts

@@ -638,6 +638,16 @@ describe("script connections", () => {
       markMigrationApplied(database, "231_slack_tasks_last_updated_index.sql");
       // 232 rebuilds session_tokens with the 207 columns, which this fixture skipped.
       markMigrationApplied(database, "232_agent_session_tokens.sql");
+      // 235 reads agent_tasks.deferredAt, which this migration-112-only fixture does not create.
+      markMigrationApplied(database, "235_chat_relay_defer.sql");
+      // 237 reads approval_requests and inbox_item_state, which this migration-112-only fixture does not create.
+      markMigrationApplied(database, "237_session_inbox_cleanup.sql");
+      // 239 indexes skills, which this migration-112-only fixture does not create.
+      markMigrationApplied(database, "239_skills_fts.sql");
+      // 240 alters workflow_runs, which this migration-112-only fixture does not create.
+      markMigrationApplied(database, "240_workflow_run_parent_step_attempt.sql");
+      // 241 indexes skills, which this migration-112-only fixture does not create.
+      markMigrationApplied(database, "241_skills_meta_fts.sql");
 
       const id = crypto.randomUUID();
       const now = new Date().toISOString();