@desplega.ai/agent-swarm 2.4.3 → 2.4.4

package/src/tests/apps-action-parent-task.test.ts

@@ -0,0 +1,295 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import { parseAppDefinition } from "../apps/definition";
+import { createApp } from "../apps/store";
+import {
+  closeDb,
+  createAgent,
+  createTask,
+  createTaskExtended,
+  createUser,
+  getTaskById,
+  initDb,
+} from "../be/db";
+import { type IdentityActor, mintToken } from "../be/users";
+import { handleApps } from "../http/apps";
+import { resolveHttpRequestAuth } from "../http/auth";
+import { SESSION_WRITE_DENIED } from "../http/session-access";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { setRequestAuth } from "../utils/request-auth-context";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = `/private/tmp/test-apps-action-parent-task-${process.pid}.sqlite`;
+const API_KEY = "example-apps-action-parent-task-key";
+const OPERATOR_ACTOR: IdentityActor = { kind: "operator", id: "apps-action-parent-task-test" };
+/** Non-lead worker: the default caller. */
+const AGENT_ID = crypto.randomUUID();
+const LEAD_ID = crypto.randomUUID();
+/** Owns the parent task the worker has no context for. */
+const OTHER_AGENT_ID = crypto.randomUUID();
+const TASK_ACTION = "generateScreen";
+const SYNC_ACTION = "syncNotes";
+const CHAIN_ISSUE = "$row, $rowIndex, $form, and $chain bindings are only allowed in action params";
+
+let server: Server;
+let base = "";
+/** A user with no share on anyone else's session. */
+let userToken = "";
+let previousApiKey: string | undefined;
+
+function createTestServer(): Server {
+  return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    setRequestAuth(req, await resolveHttpRequestAuth(req, API_KEY));
+    res.setHeader("Content-Type", "application/json");
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    const handled = await handleApps(req, res, pathSegments, queryParams, myAgentId);
+    if (!handled) {
+      res.writeHead(404);
+      res.end(JSON.stringify({ error: "not found" }));
+    }
+  });
+}
+
+/** Runs an action as an agent (default: the worker) or, with `bearer`, as a token holder. */
+async function runAction<T>(
+  appId: string,
+  body: Record<string, unknown>,
+  options: { agentId?: string; bearer?: string; action?: string } = {},
+): Promise<{ status: number; body: T }> {
+  const action = options.action ?? TASK_ACTION;
+  const response = await fetch(`${base}/api/apps/${appId}/actions/${action}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(options.bearer
+        ? { Authorization: `Bearer ${options.bearer}` }
+        : { "X-Agent-ID": options.agentId ?? AGENT_ID }),
+    },
+    body: JSON.stringify(body),
+  });
+  return { status: response.status, body: (await response.json()) as T };
+}
+
+/** A page whose Button chains a task-kind action under the chain scope's leaf task. */
+function chainedButtonPage() {
+  return {
+    root: "root",
+    elements: {
+      root: { type: "Container", props: {}, children: ["send"] },
+      send: {
+        type: "Button",
+        props: { label: "Send" },
+        on: {
+          press: [
+            {
+              action: "app.action",
+              params: {
+                name: TASK_ACTION,
+                input: { prompt: "next step" },
+                parentTaskId: { $chain: "leafTaskId" },
+              },
+            },
+          ],
+        },
+      },
+    },
+  };
+}
+
+function definitionWith(page: Record<string, unknown>) {
+  return {
+    models: {
+      note: {
+        columns: { title: { kind: "string" } },
+        // The sync action needs one (model x source) pair to be valid.
+        sources: { tracker: { connector: "swarm-tasks", joinKey: "title" } },
+      },
+    },
+    queries: { allNotes: { model: "note" } },
+    actions: {
+      [TASK_ACTION]: { kind: "task", prompt: "Generate the next screen" },
+      // A non-task action, to show parentTaskId is rejected rather than dropped.
+      [SYNC_ACTION]: { kind: "sync" },
+    },
+    pages: { main: page },
+    defaultPage: "main",
+  };
+}
+
+/** Stores the chained-Button app the way the API does: validated first. */
+async function createChainedApp(): Promise<string> {
+  const parsed = await parseAppDefinition(definitionWith(chainedButtonPage()));
+  if (!parsed.success) throw new Error(JSON.stringify(parsed.issues));
+  const app = await createApp({
+    name: `Chained ${crypto.randomUUID()}`,
+    definition: parsed.definition,
+  });
+  return app.id;
+}
+
+beforeAll(async () => {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+  // Safe to mutate: CI runs one process per test file (`bun test --parallel=4`)
+  // and afterAll restores the previous value.
+  previousApiKey = process.env.AGENT_SWARM_API_KEY;
+  process.env.AGENT_SWARM_API_KEY = API_KEY;
+  initDb(TEST_DB_PATH);
+  const user = await createUser({ name: "Parent Task User" });
+  userToken = (await mintToken(user.id, "apps-action-parent-task", OPERATOR_ACTOR)).plaintext;
+  await createAgent({ id: AGENT_ID, name: "parent-task-worker", isLead: false, status: "idle" });
+  await createAgent({ id: LEAD_ID, name: "parent-task-lead", isLead: true, status: "idle" });
+  await createAgent({
+    id: OTHER_AGENT_ID,
+    name: "parent-task-other",
+    isLead: false,
+    status: "idle",
+  });
+  server = createTestServer();
+  const port = await listenOnFreePort(server, "127.0.0.1");
+  base = `http://127.0.0.1:${port}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+  if (previousApiKey === undefined) delete process.env.AGENT_SWARM_API_KEY;
+  else process.env.AGENT_SWARM_API_KEY = previousApiKey;
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+
+describe("$chain sentinel in the page validator", () => {
+  test("accepts parentTaskId: { $chain } inside an app.action step's params", async () => {
+    const parsed = await parseAppDefinition(definitionWith(chainedButtonPage()));
+    expect(parsed.success).toBe(true);
+  });
+
+  test("accepts a $chain sentinel nested deeper inside app.action params", async () => {
+    const page = chainedButtonPage();
+    page.elements.send.on.press[0]!.params = {
+      name: TASK_ACTION,
+      input: { context: { parentTaskId: { $chain: "leafTaskId" } } },
+    };
+    const parsed = await parseAppDefinition(definitionWith(page));
+    expect(parsed.success).toBe(true);
+  });
+
+  test("rejects a $chain sentinel used as a plain prop value", async () => {
+    const page = chainedButtonPage();
+    page.elements = {
+      ...page.elements,
+      echo: { type: "Text", props: { content: { $chain: "leafTaskId" } } },
+    } as typeof page.elements;
+    page.elements.root.children = ["send", "echo"];
+    const parsed = await parseAppDefinition(definitionWith(page));
+    expect(parsed.success).toBe(false);
+    if (parsed.success) return;
+    expect(parsed.issues.some((entry) => entry.message === CHAIN_ISSUE)).toBe(true);
+  });
+});
+
+describe("POST /api/apps/:id/actions/:name with parentTaskId", () => {
+  test("chains the created task under the given parent", async () => {
+    const appId = await createChainedApp();
+    const parent = await createTask(AGENT_ID, "Previous turn of the chain");
+
+    const started = await runAction<{ ok: boolean; taskId: string; status: string }>(appId, {
+      input: { prompt: "next step" },
+      parentTaskId: parent.id,
+    });
+    expect(started.status).toBe(200);
+    expect(started.body).toMatchObject({ ok: true, status: "pending" });
+
+    const created = await getTaskById(started.body.taskId);
+    expect(created?.parentTaskId).toBe(parent.id);
+  });
+
+  test("answers 404 for an unknown parent instead of storing a dangling id", async () => {
+    const appId = await createChainedApp();
+    const missing = await runAction<{ error: string }>(appId, {
+      input: {},
+      parentTaskId: crypto.randomUUID(),
+    });
+    expect(missing.status).toBe(404);
+    expect(missing.body.error).toBe("parent task not found");
+  });
+
+  test("denies an agent caller without context for the parent, as POST /api/tasks does", async () => {
+    const appId = await createChainedApp();
+    const foreign = await createTask(OTHER_AGENT_ID, "Someone else's thread");
+
+    const denied = await runAction<{ error: string }>(appId, {
+      input: {},
+      parentTaskId: foreign.id,
+    });
+    expect(denied.status).toBe(403);
+    expect(denied.body.error).toBe(`You don't have context for parent task ${foreign.id}.`);
+
+    // A lead keeps its `task.parent.attach` grant: the gate is about identity, not the route.
+    const asLead = await runAction<{ taskId: string }>(
+      appId,
+      { input: {}, parentTaskId: foreign.id },
+      { agentId: LEAD_ID },
+    );
+    expect(asLead.status).toBe(200);
+    expect((await getTaskById(asLead.body.taskId))?.parentTaskId).toBe(foreign.id);
+  });
+
+  test("denies a user caller without a write share on the parent's session", async () => {
+    const appId = await createChainedApp();
+    const owner = await createUser({ name: "Session Owner" });
+    const theirs = await createTaskExtended("Someone else's session", {
+      agentId: OTHER_AGENT_ID,
+      requestedByUserId: owner.id,
+    });
+
+    const denied = await runAction<{ error: string }>(
+      appId,
+      { input: {}, parentTaskId: theirs.id },
+      { bearer: userToken },
+    );
+    expect(denied.status).toBe(403);
+    expect(denied.body.error).toBe(SESSION_WRITE_DENIED);
+  });
+
+  test("rejects parentTaskId on a non-task action instead of dropping it", async () => {
+    const appId = await createChainedApp();
+    const parent = await createTask(AGENT_ID, "Previous turn of the chain");
+
+    const rejected = await runAction<{ error: string }>(
+      appId,
+      { input: {}, parentTaskId: parent.id },
+      { action: SYNC_ACTION },
+    );
+    expect(rejected.status).toBe(400);
+    expect(rejected.body.error).toBe("parentTaskId is only supported for task-kind actions");
+  });
+
+  test("rejects an empty parentTaskId", async () => {
+    const appId = await createChainedApp();
+    const rejected = await runAction<{ error: string }>(appId, { input: {}, parentTaskId: "" });
+    expect(rejected.status).toBe(400);
+  });
+
+  test("still creates a parentless task when parentTaskId is omitted", async () => {
+    const appId = await createChainedApp();
+    const started = await runAction<{ ok: boolean; taskId: string }>(appId, { input: {} });
+    expect(started.status).toBe(200);
+    expect((await getTaskById(started.body.taskId))?.parentTaskId ?? null).toBeNull();
+  });
+});

package/src/tests/codex-oauth-keep-warm.test.ts

@@ -10,7 +10,8 @@ import { afterAll, afterEach, beforeAll, describe, expect, it } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import { closeDb, initDb, upsertKv } from "../be/db";
-import { handleCodexOAuthKeepWarm } from "../http/codex-oauth-keep-warm";
+import { validateConfigValue } from "../be/swarm-config-guard";
+import { handleCodexOAuthKeepWarm, keepWarmMaxAgeMs } from "../http/codex-oauth-keep-warm";
 import { handleOAuthLocks } from "../http/oauth-locks";
 import { resetFetchForTesting, setFetchForTesting } from "../providers/codex-oauth/flow.js";
 import type { CodexOAuthCredentials } from "../providers/codex-oauth/types.js";
@@ -176,6 +177,70 @@ describe("POST /api/oauth/keep-warm/codex", () => {
     expect(slots.get(1)?.access).toBe("example-at_keepwarm");
   });
 
+  it("refreshes a 6-day-old slot by default, before the ~6d20h point where OpenAI ended a session", async () => {
+    const slots = new Map<number, CodexOAuthCredentials>([
+      [
+        0,
+        {
+          access: "at_six_days",
+          refresh: "rt_six_days",
+          expires: Date.now() + 4 * 24 * 60 * 60 * 1000, // issued ~6 days ago (10d TTL)
+          accountId: "acc-six",
+        },
+      ],
+    ]);
+    installMockTransport(slots);
+    setFetchForTesting(
+      async () =>
+        new Response(
+          JSON.stringify({
+            access_token: "example-at_six_days_new",
+            refresh_token: "example-rt_six_days_new",
+            expires_in: 864000,
+          }),
+          { status: 200, headers: { "Content-Type": "application/json" } },
+        ),
+    );
+
+    const { req, res, captured } = fakeReqRes();
+    await handleCodexOAuthKeepWarm(req, res, ["api", "oauth", "keep-warm", "codex"]);
+
+    const body = JSON.parse(captured.body) as { results: Array<Record<string, unknown>> };
+    expect(body.results[0]).toMatchObject({ slot: 0, outcome: "refreshed" });
+    expect(slots.get(0)?.refresh).toBe("example-rt_six_days_new");
+  });
+
+  it("honors CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS read at sweep time", async () => {
+    const saved = process.env.CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS;
+    process.env.CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS = "168";
+    try {
+      const slots = new Map<number, CodexOAuthCredentials>([
+        [
+          0,
+          {
+            access: "at_six_days",
+            refresh: "rt_six_days",
+            expires: Date.now() + 4 * 24 * 60 * 60 * 1000, // issued ~6 days ago, under 168h
+            accountId: "acc-six",
+          },
+        ],
+      ]);
+      installMockTransport(slots);
+      setFetchForTesting(async () => {
+        throw new Error("no /oauth/token exchange should happen under a 168h threshold");
+      });
+
+      const { req, res, captured } = fakeReqRes();
+      await handleCodexOAuthKeepWarm(req, res, ["api", "oauth", "keep-warm", "codex"]);
+
+      const body = JSON.parse(captured.body) as { results: Array<Record<string, unknown>> };
+      expect(body.results[0]).toMatchObject({ slot: 0, outcome: "warm" });
+    } finally {
+      if (saved === undefined) delete process.env.CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS;
+      else process.env.CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS = saved;
+    }
+  });
+
   it("skips a slot with an active codex-auth-watch bench marker", async () => {
     const keySuffix = "c-old"; // last 5 of accountId (no chatgpt_user_id in this fixture's access token)
     await upsertKv({
@@ -284,6 +349,25 @@ describe("POST /api/oauth/keep-warm/codex", () => {
     }
   });
 
+  it("keepWarmMaxAgeMs defaults to 120h and ignores invalid or out-of-range values", () => {
+    const hour = 60 * 60 * 1000;
+    expect(keepWarmMaxAgeMs({})).toBe(120 * hour);
+    expect(keepWarmMaxAgeMs({ CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS: " 72 " })).toBe(72 * hour);
+    expect(keepWarmMaxAgeMs({ CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS: "216" })).toBe(216 * hour);
+    for (const bad of ["0", "217", "1.5", "-3", "abc", ""]) {
+      expect(keepWarmMaxAgeMs({ CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS: bad })).toBe(120 * hour);
+    }
+  });
+
+  it("the config API rejects the values keepWarmMaxAgeMs would fall back from", () => {
+    const key = "CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS";
+    expect(validateConfigValue(key, "1")).toBeNull();
+    expect(validateConfigValue(key, "216")).toBeNull();
+    expect(validateConfigValue(key, "0")).toContain("between 1 and 216");
+    expect(validateConfigValue(key, "217")).toContain("between 1 and 216");
+    expect(validateConfigValue(key, "1.5")).toContain("integer");
+  });
+
   it("does not match unrelated paths", async () => {
     const { req, res } = fakeReqRes();
     const handled = await handleCodexOAuthKeepWarm(req, res, [

package/src/tests/config-session-auth.test.ts

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { createServer, type Server } from "node:http";
 import { closeDb, createAgent, initDb, upsertSwarmConfig } from "../be/db";
+import { mintAgentToken, revokeAgentTokens } from "../be/users";
 import { handleConfig } from "../http/config";
 import { handleCore } from "../http/core";
 import { handleSessions } from "../http/sessions";
@@ -116,6 +117,19 @@ describe("config HTTP session-token authorization", () => {
     expect((await response.json()).configs[0].value).toBe("global");
   });
 
+  test("agent token resolved config without agentId reads its own agent scope", async () => {
+    const token = await mintAgentToken(workerId);
+    try {
+      const response = await fetch(`${baseUrl}/api/config/resolved?includeSecrets=true`, {
+        headers: headers(token.plaintext),
+      });
+      expect(response.status).toBe(200);
+      expect(await response.text()).toContain(SECRET);
+    } finally {
+      await revokeAgentTokens(workerId);
+    }
+  });
+
   for (const method of ["PUT", "DELETE"] as const) {
     test(`${method} cannot escalate a non-lead session by changing only X-Agent-ID`, async () => {
       const token = await mint(workerId);

package/src/tests/docs-index-footprint.test.js

@@ -103,8 +103,8 @@ describe("docs API index footprint", () => {
     expect(spec.paths["/api/agents/{id}/runtime"]?.get).toBeDefined();
 
     const generatedKeys = await generatedOperationKeys();
-    expect(operationKeys).toHaveLength(437);
-    expect(generatedKeys).toHaveLength(437);
+    expect(operationKeys).toHaveLength(440);
+    expect(generatedKeys).toHaveLength(440);
     expect(new Set(generatedKeys)).toEqual(new Set(operationKeys));
   });
 

package/src/tests/grok-adapter.test.ts

@@ -30,6 +30,7 @@ import {
 } from "../providers/grok-adapter";
 import type { ProviderEvent, ProviderSessionConfig } from "../providers/types";
 import { getModelAwareCredentialVars } from "../utils/credentials";
+import { ACP_SDK_PATH, serveFakeAcpAgent } from "./acp-fake-agent";
 
 /**
  * Recorded from a live `grok agent stdio` session (Grok CLI 1.0.46,
@@ -39,7 +40,6 @@ import { getModelAwareCredentialVars } from "../utils/credentials";
  */
 const FIXTURE = join(import.meta.dir, "fixtures", "grok", "acp-updates-recorded.jsonl");
 const PROMPT_META = join(import.meta.dir, "fixtures", "grok", "prompt-response-meta.json");
-const SDK_PATH = join(process.cwd(), "node_modules/@agentclientprotocol/sdk/dist/acp.js");
 
 const tmpDirs: string[] = [];
 
@@ -129,7 +129,7 @@ function writeFakeGrok(
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { Readable, Writable } from "node:stream";
-import { AgentSideConnection, PROTOCOL_VERSION, RequestError, ndJsonStream } from "${SDK_PATH}";
+import { PROTOCOL_VERSION, RequestError, agent, methods, ndJsonStream } from "${ACP_SDK_PATH}";
 const home = process.env.GROK_HOME ?? "";
 const read = (name) => (existsSync(join(home, name)) ? readFileSync(join(home, name), "utf8") : null);
 const capture = {
@@ -160,7 +160,7 @@ class FakeGrok {
   }
   async cancel() { this.cancelled?.(); }
 }
-new AgentSideConnection((c) => new FakeGrok(c), ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin)));
+${serveFakeAcpAgent("FakeGrok")}
 `,
   );
   const binPath = join(dir, "grok");

package/src/tests/heartbeat-jev-gate.test.ts

@@ -261,6 +261,29 @@ describe("heartbeat-jev-gate with a provider", () => {
     });
   });
 
+  test("only a bare MM-DD counts as a due tracked item", async () => {
+    const mocked = Date.now;
+    Date.now = () => Date.parse("2026-10-20T09:30:00.000Z");
+    try {
+      const { ctx } = fakeCtx({
+        configs: { TYPESAFE_API_KEY: "x" },
+        heartbeatMd: [
+          "- **2026-10-20 ~10:45Z (heartbeat 2026-10-20):** re-verified, nothing pending",
+          "- Watch: 10-20s retry window closed, nothing pending",
+          "- Watch: session 4a12-10-20-9e2f finished cleanly, nothing pending",
+          "- Watch: release on 10-20 — lift after ship",
+        ].join("\n"),
+        jev: jevSays(0.9),
+      });
+      const verdict = await run(ctx, { dryRun: true });
+      expect(verdict.state.tracked_items_mentioning_today_or_past_delete_date).toEqual([
+        "- Watch: release on 10-20 — lift after ship",
+      ]);
+    } finally {
+      Date.now = mocked;
+    }
+  });
+
   for (const ordersFirst of [true, false]) {
     test(`previous failures are not new with standing orders ${ordersFirst ? "before" : "after"} status`, async () => {
       const failures =

package/src/tests/migration-232-agent-session-tokens.test.ts

@@ -0,0 +1,67 @@
+import { Database } from "bun:sqlite";
+import { expect, test } from "bun:test";
+
+test("migration 232 preserves every token kind and adds agent-only tokens", async () => {
+  const db = new Database(":memory:");
+  try {
+    db.exec(await Bun.file("src/be/migrations/149_session_tokens.sql").text());
+    db.exec(await Bun.file("src/be/migrations/207_runtime_session_tokens.sql").text());
+    const seed = db.query(
+      `INSERT INTO session_tokens
+       (id, tokenHash, tokenPreview, agentId, taskId, runtimeId, parentRuntimeId, controllerId,
+        expiresAt, revokedAt, createdAt, lastUsedAt)
+       VALUES (?, ?, 'view', 'agent', ?, ?, ?, ?, '2030-01-01', NULL, '2025-01-01', '2025-12-01')`,
+    );
+    seed.run("acp", "acp", "task", null, null, null);
+    seed.run("runtime", "runtime", null, "runtime", null, null);
+    seed.run("child", "child", "task", null, "runtime", null);
+    seed.run("controller", "controller", null, null, null, "ctrl");
+    const before = db.query("SELECT * FROM session_tokens ORDER BY id").all();
+
+    db.exec(await Bun.file("src/be/migrations/232_agent_session_tokens.sql").text());
+
+    // prepare, not query: query() caches the statement and its pre-migration column list.
+    expect(db.prepare("SELECT * FROM session_tokens ORDER BY id").all()).toEqual(
+      before.map((row) => ({ ...(row as object), parentTokenId: null })),
+    );
+    const insert = db.query(
+      `INSERT INTO session_tokens
+       (id, tokenHash, tokenPreview, agentId, taskId, runtimeId, parentRuntimeId, controllerId,
+        parentTokenId, expiresAt)
+       VALUES (?, ?, 'view', 'agent', ?, ?, ?, ?, ?, '2030-01-01')`,
+    );
+    insert.run("worker", "worker", null, null, null, null, null);
+    insert.run("worker-child", "worker-child", "task", null, null, null, "worker");
+    expect(() => insert.run("mixed", "mixed", "task", "runtime", null, null, null)).toThrow();
+    expect(() =>
+      insert.run("two-parents", "two-parents", "task", null, "rt", null, "worker"),
+    ).toThrow();
+    expect(() =>
+      insert.run("runtime-parent-token", "runtime-parent-token", null, "rt", null, null, "worker"),
+    ).toThrow();
+    expect(() =>
+      insert.run("controller-parent", "controller-parent", null, null, null, "ctrl", "worker"),
+    ).toThrow();
+    expect(() =>
+      insert.run("agent-parent-runtime", "agent-parent-runtime", null, null, "rt", null, null),
+    ).toThrow();
+    expect(() =>
+      insert.run("agent-with-parent", "agent-with-parent", null, null, null, null, "worker"),
+    ).toThrow();
+    const indexes = db
+      .query<{ name: string }, []>("PRAGMA index_list(session_tokens)")
+      .all()
+      .map((row) => row.name);
+    for (const name of [
+      "idx_session_tokens_agentId",
+      "idx_session_tokens_runtimeId",
+      "idx_session_tokens_parentRuntimeId",
+      "idx_session_tokens_parentTokenId",
+    ]) {
+      expect(indexes).toContain(name);
+    }
+    expect(db.query("PRAGMA integrity_check").get()).toEqual({ integrity_check: "ok" });
+  } finally {
+    db.close();
+  }
+});

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

@@ -105,6 +105,7 @@ const OPERATOR_OR_USER_VERBS: PermissionVerb[] = [
   "approval.respond",
   "runtime_controller.write",
   "runtime_pool.write",
+  "agent.token.manage",
 ];
 
 const LEAD_OR_OPERATOR_VERBS: PermissionVerb[] = ["models.catalog.write"];

package/src/tests/runtime-child-token-cleanup.test.ts

@@ -9,6 +9,7 @@ import { handleSessions } from "../http/sessions";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 import { ACPAdapter } from "../providers/acp-adapter";
 import { setRequestAuth } from "../utils/request-auth-context";
+import { ACP_SDK_PATH, serveFakeAcpAgent } from "./acp-fake-agent";
 import { listenOnFreePort } from "./test-net";
 import { CHILD_PROCESS_TEST_BUDGET_MS } from "./test-proc";
 
@@ -69,12 +70,11 @@ for (const setupFails of [false, true]) {
       const api = await startApi(resolveRevoke);
       const script = join(tmpdir(), `runtime-child-${crypto.randomUUID()}.ts`);
       const capture = `${script}.auth`;
-      const sdk = join(process.cwd(), "node_modules/@agentclientprotocol/sdk/dist/acp.js");
       await Bun.write(
         script,
         `
 import { Readable, Writable } from "node:stream";
-import { AgentSideConnection, PROTOCOL_VERSION, ndJsonStream } from ${JSON.stringify(sdk)};
+import { PROTOCOL_VERSION, agent, methods, ndJsonStream } from ${JSON.stringify(ACP_SDK_PATH)};
 class Agent {
   async initialize() {
     return { protocolVersion: PROTOCOL_VERSION, agentCapabilities: { loadSession: false } };
@@ -89,7 +89,7 @@ class Agent {
   async prompt() { return { stopReason: "end_turn" }; }
   async cancel() {}
 }
-new AgentSideConnection(() => new Agent(), ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin)));
+${serveFakeAcpAgent("Agent")}
 `,
       );
       try {

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

@@ -636,6 +636,8 @@ describe("script connections", () => {
       markMigrationApplied(database, "227_inbox_item_state_last_read_at.sql");
       // 231 indexes agent_tasks columns that this fixture's id-only agent_tasks lacks.
       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");
 
       const id = crypto.randomUUID();
       const now = new Date().toISOString();

package/src/tests/session-route-posture.test.ts

@@ -25,6 +25,7 @@ import "../http/all-routes";
 import { handleActiveSessions } from "../http/active-sessions";
 import { handleApiKeys } from "../http/api-keys";
 import { handleApprovalRequests } from "../http/approval-requests";
+import { handleApps } from "../http/apps";
 import { handleContext } from "../http/context";
 import { handleCore } from "../http/core";
 import { handleEvents } from "../http/events";
@@ -76,6 +77,7 @@ const HANDLERS: Handler[] = [
   handleFs,
   handleActiveSessions,
   handleSessions,
+  handleApps,
   (req, res, segments, query) => handleApprovalRequests(req, res, segments, query),
   (req, res, segments, query) => handleApiKeys(req, res, segments, query),
   (req, res, segments, query) => handleScriptRuns(req, res, segments, query),