@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/tests/claude-thinking-tokens.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test";
+import { normalizeClaudeMessage } from "../providers/claude-session-events";
+
+const state = {
+  taskId: "task-fixture",
+  agentId: "agent-fixture",
+  model: "claude-opus-5-5",
+  contextWindowSize: 1_000_000,
+  transport: "cli" as const,
+};
+
+// Trimmed from a claude CLI stream-json `result` line.
+const resultLine = {
+  type: "result",
+  subtype: "success",
+  is_error: false,
+  duration_ms: 48_210,
+  num_turns: 6,
+  session_id: "session-fixture",
+  total_cost_usd: 0.3121,
+  usage: {
+    input_tokens: 12,
+    cache_creation_input_tokens: 20_792,
+    cache_read_input_tokens: 54_611,
+    output_tokens: 2_993,
+    output_tokens_details: { thinking_tokens: 1_304 },
+    cache_creation: { ephemeral_5m_input_tokens: 0, ephemeral_1h_input_tokens: 20_792 },
+  },
+  modelUsage: {
+    "claude-opus-5-5": {
+      inputTokens: 12,
+      outputTokens: 2_993,
+      cacheReadInputTokens: 54_611,
+      cacheCreationInputTokens: 20_792,
+      webSearchRequests: 0,
+      costUSD: 0.3121,
+      contextWindow: 1_000_000,
+    },
+  },
+};
+
+describe("claude result-line thinking tokens", () => {
+  test("records output_tokens_details.thinking_tokens without touching output or cost", () => {
+    const { cost } = normalizeClaudeMessage(resultLine, state);
+    expect(cost).toMatchObject({
+      thinkingTokens: 1_304,
+      outputTokens: 2_993,
+      totalCostUsd: 0.3121,
+    });
+  });
+
+  test("reports zero when the result line has no thinking breakdown", () => {
+    const { output_tokens_details: _, ...usage } = resultLine.usage;
+    const { cost } = normalizeClaudeMessage({ ...resultLine, usage }, state);
+    expect(cost?.thinkingTokens).toBe(0);
+  });
+});

package/src/tests/claude-worker-parity.test.ts

@@ -27,7 +27,6 @@ let sut: Sut;
 let api: ApiClient;
 let fixtureDir: string;
 let fixturePath: string;
-let pm2StubPath: string;
 let openRouterMock: Bun.Server;
 
 const fixtureSource = `#!/usr/bin/env bun
@@ -248,7 +247,7 @@ async function runTransport(transport: "cli" | "sdk", agentId: string): Promise<
   const home = await mkdtemp(join(fixtureDir, `home-${transport}-`));
   const workerEnv = {
     ...minimalEnv(),
-    PATH: `${pm2StubPath}:${process.env.PATH ?? "/usr/bin:/bin"}`,
+    PATH: process.env.PATH ?? "/usr/bin:/bin",
     HOME: home,
     AGENT_SWARM_API_KEY: sut.apiKey,
     API_KEY: sut.apiKey,
@@ -387,7 +386,7 @@ async function runCredentialRotation(): Promise<void> {
   const observationFile = join(home, "fixture-observation.json");
   const workerEnv = {
     ...minimalEnv(),
-    PATH: `${pm2StubPath}:${process.env.PATH ?? "/usr/bin:/bin"}`,
+    PATH: process.env.PATH ?? "/usr/bin:/bin",
     HOME: home,
     AGENT_SWARM_API_KEY: sut.apiKey,
     API_KEY: sut.apiKey,
@@ -537,12 +536,8 @@ describe("Claude worker transport parity", () => {
     }
     fixtureDir = await mkdtemp("/tmp/claude-worker-parity-");
     fixturePath = join(fixtureDir, "claude-fixture");
-    pm2StubPath = join(fixtureDir, "bin");
-    await Bun.$`mkdir -p ${pm2StubPath}`.quiet();
     await Bun.write(fixturePath, fixtureSource);
-    await Bun.write(join(pm2StubPath, "pm2"), "#!/bin/sh\nexit 0\n");
     await Bun.$`chmod 755 ${fixturePath}`.quiet();
-    await Bun.$`chmod 755 ${join(pm2StubPath, "pm2")}`.quiet();
     openRouterMock = Bun.serve({
       port: 0,
       fetch: () =>

package/src/tests/config-env-export-chat-sdk.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, test } from "bun:test";
+import { defaultExportToEnv } from "../utils/config-env-export";
+
+describe("defaultExportToEnv for Chat SDK rows", () => {
+  test("CHAT_SDK_* rows start server-only; other keys keep the default", () => {
+    expect(defaultExportToEnv("CHAT_SDK_TELEGRAM_BOT_TOKEN")).toBe(false);
+    expect(defaultExportToEnv("chat_sdk_adapters")).toBe(false);
+    expect(defaultExportToEnv("CHAT_SDK_ENABLED")).toBe(false);
+    expect(defaultExportToEnv("MY_TOOL_TOKEN")).toBe(true);
+  });
+});

package/src/tests/config-refs.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test } from "bun:test";
+import { ConfigRefError, isConfigRef, resolveConfigRefs } from "../be/config-refs";
+
+const values: Record<string, string> = { A: "alpha", B: "bravo" };
+const lookup = (key: string) => values[key];
+
+describe("resolveConfigRefs", () => {
+  test("resolves nested refs and refs inside arrays", () => {
+    const resolved = resolveConfigRefs<Record<string, unknown>>(
+      {
+        top: { $config: "A" },
+        nested: { deep: { value: { $config: "B" } } },
+        list: [{ $config: "A" }, "plain", { inner: { $config: "B" } }],
+      },
+      lookup,
+    );
+    expect(resolved).toEqual({
+      top: "alpha",
+      nested: { deep: { value: "bravo" } },
+      list: ["alpha", "plain", { inner: "bravo" }],
+    });
+  });
+
+  test("aggregates every missing key into one error", () => {
+    let error: unknown;
+    try {
+      resolveConfigRefs({ a: { $config: "MISSING_2" }, b: [{ $config: "MISSING_1" }] }, lookup);
+    } catch (caught) {
+      error = caught;
+    }
+    expect(error).toBeInstanceOf(ConfigRefError);
+    expect((error as ConfigRefError).missingKeys).toEqual(["MISSING_1", "MISSING_2"]);
+    expect((error as Error).message).toContain("MISSING_1, MISSING_2");
+  });
+
+  test("leaves non-ref objects and scalars untouched", () => {
+    const input = {
+      notRef: { $config: "A", extra: true },
+      emptyRef: { $config: "" },
+      numberRef: { $config: 7 },
+      n: 1,
+      b: false,
+      nil: null,
+    };
+    expect(resolveConfigRefs(input, lookup)).toEqual(input);
+  });
+
+  test("propagates a lookup that throws", () => {
+    expect(() =>
+      resolveConfigRefs({ k: { $config: "FORBIDDEN" } }, () => {
+        throw new Error("forbidden key");
+      }),
+    ).toThrow("forbidden key");
+  });
+});
+
+describe("isConfigRef", () => {
+  test("accepts only a single non-empty $config string key", () => {
+    expect(isConfigRef({ $config: "X" })).toBe(true);
+    expect(isConfigRef({ $config: "X", other: 1 })).toBe(false);
+    expect(isConfigRef({ $config: "" })).toBe(false);
+    expect(isConfigRef([{ $config: "X" }])).toBe(false);
+    expect(isConfigRef("X")).toBe(false);
+    expect(isConfigRef(null)).toBe(false);
+  });
+});

package/src/tests/context-key.test.ts

@@ -2,7 +2,10 @@ import { describe, expect, test } from "bun:test";
 import {
   agentContextKey,
   agentmailContextKey,
+  azureDevOpsContextKey,
+  azureDevOpsWorkItemContextKey,
   buildJiraContextKey,
+  chatSdkContextKey,
   githubContextKey,
   gitlabContextKey,
   linearContextKey,
@@ -124,6 +127,36 @@ describe("context-key separator safety", () => {
   });
 });
 
+describe("azure-devops work item keys", () => {
+  test("round-trips workitem keys", () => {
+    const key = azureDevOpsWorkItemContextKey({ organization: "fabrikam", workItemId: 42 });
+    expect(key).toBe("task:trackers:azure-devops:fabrikam:workitem:42");
+    expect(parseContextKey(key)).toEqual({
+      family: "trackers",
+      subFamily: "azure-devops",
+      parts: { organization: "fabrikam", kind: "workitem", workItemId: 42 },
+    });
+  });
+
+  test("the PR key still parses", () => {
+    const key = azureDevOpsContextKey({ repositoryId: "repo-1", pullRequestId: 7 });
+    expect(parseContextKey(key)).toEqual({
+      family: "trackers",
+      subFamily: "azure-devops",
+      parts: { repositoryId: "repo-1", kind: "pr", pullRequestId: 7 },
+    });
+  });
+
+  test("rejects a non-integer work item id", () => {
+    expect(() => azureDevOpsWorkItemContextKey({ organization: "o", workItemId: 1.5 })).toThrow();
+    expect(() => parseContextKey("task:trackers:azure-devops:o:workitem:abc")).toThrow();
+  });
+
+  test("rejects a workitem key with the wrong part count", () => {
+    expect(() => parseContextKey("task:trackers:azure-devops:workitem:42")).toThrow();
+  });
+});
+
 describe("parseContextKey", () => {
   test("round-trips slack keys", () => {
     const key = slackContextKey({ channelId: "C0A4J7GB0UD", threadTs: "1776800534.257079" });
@@ -134,6 +167,24 @@ describe("parseContextKey", () => {
     });
   });
 
+  test("round-trips chat-sdk keys whose thread id contains colons", () => {
+    const threadId = "telegram:-1001234567890:42";
+    const key = chatSdkContextKey(threadId);
+    expect(key).toBe("task:chat-sdk:telegram:-1001234567890%3A42");
+    expect(key.split(":")).toHaveLength(4);
+    expect(parseContextKey(key)).toEqual({
+      family: "chat-sdk",
+      parts: { adapter: "telegram", threadId },
+    });
+  });
+
+  test("chat-sdk keys reject thread ids without an adapter prefix", () => {
+    expect(() => chatSdkContextKey("no-adapter")).toThrow(/<adapter>:<id>/);
+    expect(() => chatSdkContextKey(":123")).toThrow(/<adapter>:<id>/);
+    expect(() => chatSdkContextKey("telegram:")).toThrow(/<adapter>:<id>/);
+    expect(() => parseContextKey("task:chat-sdk:telegram")).toThrow(/malformed chat-sdk/);
+  });
+
   test("round-trips agentmail keys", () => {
     const key = agentmailContextKey({ threadId: "thr_abc" });
     expect(parseContextKey(key)).toEqual({

package/src/tests/cors-allowlist.test.ts

@@ -58,6 +58,31 @@ describe("isOriginAllowedForCredentials", () => {
     expect(isOriginAllowedForCredentials("https://evil.example")).toBe(false);
   });
 
+  test("development trusts loopback origins on any port; other modes do not", () => {
+    const originalNodeEnv = process.env.NODE_ENV;
+    try {
+      process.env.NODE_ENV = "development";
+      delete process.env[ENV_KEY];
+      expect(isOriginAllowedForCredentials("http://localhost:5974")).toBe(true);
+      expect(isOriginAllowedForCredentials("http://127.0.0.1:4173")).toBe(true);
+      expect(isOriginAllowedForCredentials("http://[::1]:3000")).toBe(true);
+      expect(isOriginAllowedForCredentials("https://localhost:8443")).toBe(true);
+      expect(isOriginAllowedForCredentials("http://localhost.evil.example")).toBe(false);
+      expect(isOriginAllowedForCredentials("http://evil.example:5974")).toBe(false);
+      // A custom allowlist does not switch the loopback rule off in development.
+      process.env[ENV_KEY] = "https://app.example";
+      expect(isOriginAllowedForCredentials("http://localhost:5974")).toBe(true);
+
+      process.env.NODE_ENV = "production";
+      expect(isOriginAllowedForCredentials("http://localhost:5974")).toBe(false);
+      delete process.env.NODE_ENV;
+      expect(isOriginAllowedForCredentials("http://localhost:5974")).toBe(false);
+    } finally {
+      if (originalNodeEnv === undefined) delete process.env.NODE_ENV;
+      else process.env.NODE_ENV = originalNodeEnv;
+    }
+  });
+
   test("denies arbitrary origins when CORS_ALLOWED_ORIGINS is blank", () => {
     process.env[ENV_KEY] = "  ";
     expect(isOriginAllowedForCredentials("https://evil.example")).toBe(false);

package/src/tests/create-page-tool.test.ts

@@ -159,6 +159,24 @@ describe("create_page MCP tool", () => {
     // Parent now holds the new body.
     const row = await getPageBySlug(agentId, "upsert");
     expect(row?.body).toBe("v1");
+
+    // The counter and the next snapshot number keep climbing from MAX(version).
+    const third = (await tool.handler(
+      {
+        title: "Upsert Page",
+        slug: "upsert",
+        body: "v2",
+        contentType: "text/html",
+        authMode: "public",
+      },
+      fakeMeta,
+    )) as { structuredContent: { version: number } };
+    expect(third.structuredContent.version).toBe(3);
+    const after = await getPageVersions(first.structuredContent.id);
+    expect(after.map((v) => [v.version, v.snapshot.body])).toEqual([
+      [2, "v1"],
+      [1, "v0"],
+    ]);
   });
 
   test("missing X-Agent-ID returns an error result", async () => {

package/src/tests/credential-check.test.ts

@@ -1,7 +1,9 @@
 import { describe, expect, mock, test } from "bun:test";
+import { OPENAI_COMPATIBLE_PROVIDERS } from "@desplega/model-catalog";
 import {
   buildCredStatusReport,
   CREDENTIAL_PROVIDER_CHECKERS,
+  checkOpenAICompatibleProvider,
   checkProviderCredentials,
   isBedrockMode,
   isCredCheckDisabled,
@@ -652,6 +654,37 @@ describe("checkOpencodeCredentials", () => {
     ).toBe(true);
   });
 
+  test("strict: nan/* needs NAN_API_KEY or its HELMCODE_API_NAN alias", () => {
+    const env = { MODEL_OVERRIDE: "nan/glm5.3-flash", OPENROUTER_API_KEY: "x" };
+    const missing = checkOpencodeCredentials(env, { homeDir: HOME, fs: noFiles });
+    expect(missing.ready).toBe(false);
+    expect(missing.missing).toContain("NAN_API_KEY");
+    for (const name of ["NAN_API_KEY", "HELMCODE_API_NAN"]) {
+      expect(
+        checkOpencodeCredentials({ ...env, [name]: "x" }, { homeDir: HOME, fs: noFiles }).ready,
+      ).toBe(true);
+    }
+  });
+
+  test("strict: helmcode/* needs HELMCODE_API_KEY, not the NaN alias", () => {
+    const env = { MODEL_OVERRIDE: "helmcode/glm5.3", HELMCODE_API_NAN: "x" };
+    const missing = checkOpencodeCredentials(env, { homeDir: HOME, fs: noFiles });
+    expect(missing.ready).toBe(false);
+    expect(missing.missing).toContain("HELMCODE_API_KEY");
+    expect(
+      checkOpencodeCredentials({ ...env, HELMCODE_API_KEY: "x" }, { homeDir: HOME, fs: noFiles })
+        .ready,
+    ).toBe(true);
+  });
+
+  test("permissive: a NaN or Helmcode key alone is enough", () => {
+    for (const name of ["NAN_API_KEY", "HELMCODE_API_NAN", "HELMCODE_API_KEY"]) {
+      expect(checkOpencodeCredentials({ [name]: "x" }, { homeDir: HOME, fs: noFiles }).ready).toBe(
+        true,
+      );
+    }
+  });
+
   test("not ready when nothing is set", () => {
     const status = checkOpencodeCredentials({}, { homeDir: HOME, fs: noFiles });
     expect(status.ready).toBe(false);
@@ -923,6 +956,112 @@ describe("REQUIRED_CRED_VARS_BY_PROVIDER", () => {
     // acp is credential-free by design: the target process owns its own auth.
     expect(REQUIRED_CRED_VARS_BY_PROVIDER.acp).toEqual([]);
   });
+
+  test("pi and opencode list the NaN (both names) and Helmcode key vars", () => {
+    for (const p of ["pi", "opencode"] as const) {
+      expect(REQUIRED_CRED_VARS_BY_PROVIDER[p]).toEqual(
+        expect.arrayContaining(["NAN_API_KEY", "HELMCODE_API_NAN", "HELMCODE_API_KEY"]),
+      );
+    }
+  });
+});
+
+describe("NaN and Helmcode live probes", () => {
+  const envReady = { ready: true, missing: [], satisfiedBy: "env" as const };
+
+  function fakeProvider(status: number) {
+    const seen: Array<{ path: string; authorization: string | null }> = [];
+    const server = Bun.serve({
+      port: 0,
+      fetch(req) {
+        seen.push({
+          path: new URL(req.url).pathname,
+          authorization: req.headers.get("authorization"),
+        });
+        return new Response(status === 200 ? '{"data":[]}' : '{"error":"Invalid API key."}', {
+          status,
+        });
+      },
+    });
+    return { server, seen, baseUrl: `${server.url.toString().replace(/\/$/, "")}/v1` };
+  }
+
+  for (const [name, probe] of [
+    [
+      "nan",
+      (key: string, url: string) =>
+        checkOpenAICompatibleProvider(OPENAI_COMPATIBLE_PROVIDERS.nan, key, url),
+    ],
+    [
+      "helmcode",
+      (key: string, url: string) =>
+        checkOpenAICompatibleProvider(OPENAI_COMPATIBLE_PROVIDERS.helmcode, key, url),
+    ],
+  ] as const) {
+    test(`${name} probe lists models with a Bearer key at the injected base URL`, async () => {
+      const ok = fakeProvider(200);
+      const bad = fakeProvider(401);
+      try {
+        expect(await probe("fixture-key", `${ok.baseUrl}/`)).toMatchObject({ ok: true });
+        expect(ok.seen).toEqual([{ path: "/v1/models", authorization: "Bearer fixture-key" }]);
+        const failure = await probe("fixture-key", bad.baseUrl);
+        expect(failure.ok).toBe(false);
+        expect(failure.error).toContain("HTTP 401");
+      } finally {
+        ok.server.stop(true);
+        bad.server.stop(true);
+      }
+    });
+  }
+
+  for (const provider of ["pi", "opencode"] as const) {
+    for (const [env, url] of [
+      [{ NAN_API_KEY: "fixture-nan" }, "https://api.nan.builders/v1/models"],
+      [{ HELMCODE_API_NAN: "fixture-nan" }, "https://api.nan.builders/v1/models"],
+      [{ HELMCODE_API_KEY: "fixture-helm" }, "https://api.helmcode.com/v1/models"],
+      // `<ID>_BASE_URL` moves the probe with the provider.
+      [
+        { NAN_API_KEY: "fixture-nan", NAN_BASE_URL: "https://nan-gw.example.test/v1/" },
+        "https://nan-gw.example.test/v1/models",
+      ],
+    ] as const) {
+      test(`${provider}: ${Object.keys(env).join("+")} is probed at ${url}`, async () => {
+        const realFetch = globalThis.fetch;
+        const fetchMock = mock(async (_url: string | URL | Request, _init?: RequestInit) => {
+          return new Response("{}", { status: 200 });
+        });
+        globalThis.fetch = fetchMock as typeof fetch;
+        try {
+          const result = await validateProviderCredentials(provider, { ...env }, envReady);
+          expect(result.ok).toBe(true);
+          expect(fetchMock).toHaveBeenCalledTimes(1);
+          expect(String(fetchMock.mock.calls[0]?.[0])).toBe(url);
+          const headers = fetchMock.mock.calls[0]?.[1]?.headers as Record<string, string>;
+          expect(headers.Authorization).toBe(`Bearer ${Object.values(env)[0]}`);
+        } finally {
+          globalThis.fetch = realFetch;
+        }
+      });
+    }
+
+    test(`${provider}: an OpenRouter key keeps the probe ahead of a NaN key`, async () => {
+      const realFetch = globalThis.fetch;
+      const fetchMock = mock(async (_url: string | URL | Request, _init?: RequestInit) => {
+        return new Response("{}", { status: 200 });
+      });
+      globalThis.fetch = fetchMock as typeof fetch;
+      try {
+        await validateProviderCredentials(
+          provider,
+          { OPENROUTER_API_KEY: "fixture-or", NAN_API_KEY: "fixture-nan" },
+          envReady,
+        );
+        expect(String(fetchMock.mock.calls[0]?.[0])).not.toContain("nan.builders");
+      } finally {
+        globalThis.fetch = realFetch;
+      }
+    });
+  }
 });
 
 // ─── Migration 055: report composition + opt-out ────────────────────────────

package/src/tests/credentials.test.ts

@@ -84,4 +84,25 @@ describe("validateOpencodeCredentials", () => {
       validateOpencodeCredentials({ OPENROUTER_API_KEY: "sk-or", ANTHROPIC_API_KEY: "sk-ant" }),
     ).toBe("openrouter_api_key");
   });
+
+  test("accepts a NaN key under either name", () => {
+    expect(validateOpencodeCredentials({ NAN_API_KEY: "example-nan" })).toBe("nan_api_key");
+    expect(validateOpencodeCredentials({ HELMCODE_API_NAN: "example-nan" })).toBe("nan_api_key");
+  });
+
+  test("accepts a Helmcode key", () => {
+    expect(validateOpencodeCredentials({ HELMCODE_API_KEY: "example-helm" })).toBe(
+      "helmcode_api_key",
+    );
+  });
+
+  test("keeps OpenRouter ahead of NaN and Helmcode", () => {
+    expect(
+      validateOpencodeCredentials({
+        OPENROUTER_API_KEY: "sk-or",
+        NAN_API_KEY: "example-nan",
+        HELMCODE_API_KEY: "example-helm",
+      }),
+    ).toBe("openrouter_api_key");
+  });
 });

package/src/tests/db-runtime.test.ts

@@ -1,6 +1,11 @@
+import { Database } from "bun:sqlite";
 import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import * as facade from "../be/db";
 import * as runtime from "../be/db/runtime";
+import { CHILD_PROCESS_TEST_BUDGET_MS, expectChildOk, runChild } from "./test-proc";
 
 const runtimeExports = [
   "__resetSqliteVecExtensionPathCacheForTests",
@@ -67,4 +72,60 @@ describe("database runtime facade", () => {
       globals.__testMigrationTemplate = template;
     }
   });
+
+  // rbac-admission-e2e restarted its server on an existing DB and the server
+  // died with "Encryption key not resolved yet": boot hit SQLITE_BUSY before
+  // resolving the key, and the db-client's BUSY retry reused the half-booted
+  // handle instead of booting again. Child processes boot cold (no test
+  // template) and leave no in-process connection blocking the lock below.
+  test(
+    "a cold boot that hits SQLITE_BUSY boots again before serving queries",
+    async () => {
+      const dir = mkdtempSync(join(tmpdir(), "db-runtime-busy-"));
+      const dbPath = join(dir, "boot.sqlite");
+      const child = (source: string) =>
+        runChild([process.execPath, "--eval", source], {
+          cwd: new URL("../../", import.meta.url).pathname,
+          env: { ...process.env, DATABASE_PATH: dbPath, AGENT_SWARM_TELEMETRY_DISABLED: "1" },
+        });
+      try {
+        expectChildOk(
+          await child(`
+            const db = await import("./src/be/db");
+            db.initDb(process.env.DATABASE_PATH);
+            await db.upsertSwarmConfig({ scope: "global", key: "BOOT_BUSY_SECRET", value: "boot-busy-value", isSecret: true });
+            db.closeDb();
+          `),
+          "seed",
+        );
+
+        const holder = new Database(dbPath);
+        holder.run("PRAGMA locking_mode = EXCLUSIVE");
+        holder.run("BEGIN EXCLUSIVE");
+        let released = false;
+        const releaseLock = () => {
+          if (released) return;
+          released = true;
+          holder.run("COMMIT");
+          holder.close();
+        };
+        const release = setTimeout(releaseLock, 500);
+        try {
+          const read = await child(`
+            const db = await import("./src/be/db");
+            const configs = await db.getInjectableGlobalConfigs();
+            console.log("VALUE=" + configs.find((c) => c.key === "BOOT_BUSY_SECRET")?.value);
+          `);
+          expect(read.stderr).not.toContain("Encryption key not resolved yet");
+          expect(read.stdout).toContain("VALUE=boot-busy-value");
+        } finally {
+          clearTimeout(release);
+          releaseLock();
+        }
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS * 2,
+  );
 });

package/src/tests/db-task-read-contract.test.ts

@@ -72,6 +72,7 @@ type:McpServerFilters
 type:McpServerInsert
 type:MentionPreview
 type:PageListOptions
+type:PendingChatRelay
 type:PlanSource
 type:RecordBudgetRefusalNotificationInput
 type:ScheduledTaskFilters
@@ -237,6 +238,7 @@ value:getAgentMcpServers
 value:getAgentSkills
 value:getAgentStatusCounts
 value:getAgentWithTasks
+value:getAgentWorkingOnContextKey
 value:getAgentWorkingOnThread
 value:getAllAgentMailInboxMappings
 value:getAllAgents
@@ -298,8 +300,10 @@ value:getKv
 value:getLastReadAt
 value:getLastRunStart
 value:getLastSuccessfulRun
+value:getLatestActiveTaskByContextKey
 value:getLatestActiveTaskInThread
 value:getLatestContextVersion
+value:getLatestLeadTaskByContextKey
 value:getLatestLeadTaskInThread
 value:getLatestPageBySlug
 value:getLatestScriptRunStepTaskByContextKey
@@ -329,6 +333,7 @@ value:getPageVersion
 value:getPageVersions
 value:getPausedTasksForAgent
 value:getPendingApprovalVoteState
+value:getPendingChatRelayTasks
 value:getPendingEventWaitNames
 value:getPendingSlackRelayTasks
 value:getPendingSteeringForAgent
@@ -426,6 +431,7 @@ value:getWorkflowRunStepsByRunId
 value:getWorkflowVersion
 value:getWorkflowVersions
 value:getWorkflowsByScheduleId
+value:giveUpStaleChatRelays
 value:hasBudgetRefusalNotificationToday
 value:hasCapacity
 value:hasFirstCompletedTask
@@ -477,6 +483,9 @@ value:listUserFavorites
 value:listWorkflowRuns
 value:listWorkflowRunsPage
 value:listWorkflows
+value:markChatRelayAttempted
+value:markChatRelayDelivered
+value:markChatRelayGivenUp
 value:markFinalizedSlackRelaysDelivered
 value:markInboxMessageDelegated
 value:markInboxMessageRead
@@ -505,6 +514,7 @@ value:promoteDraftTask
 value:reassociateSessionLogs
 value:recordApprovalVotes
 value:recordBudgetRefusalNotification
+value:recordChatRelayError
 value:recordInlineScriptRun
 value:recordKeyAuthFailure
 value:recordKeyRateLimitWindows
@@ -598,6 +608,7 @@ value:upsertSwarmConfig
 value:withFavoriteFlags`.split("\n");
 const selected = `type:ExistingTrackerContextWork
 type:ExistingTrackerContextWorkReason
+type:PendingChatRelay
 type:TaskFilters
 value:findCompletedTaskInThread
 value:findExistingLinearTrackerContextWork
@@ -605,17 +616,21 @@ value:findRecentCancelledTaskInThread
 value:findTaskByGitHub
 value:findTaskByVcs
 value:getAgentCurrentTask
+value:getAgentWorkingOnContextKey
 value:getAgentWorkingOnThread
 value:getAllTasks
 value:getChildTasks
 value:getCompletedSlackTasks
 value:getInProgressSlackTasks
 value:getInProgressTasksByContextKey
+value:getLatestActiveTaskByContextKey
 value:getLatestActiveTaskInThread
+value:getLatestLeadTaskByContextKey
 value:getLatestLeadTaskInThread
 value:getLatestScriptRunStepTaskByContextKey
 value:getLatestTaskByContextKey
 value:getMostRecentTaskInThread
+value:getPendingChatRelayTasks
 value:getPendingSlackRelayTasks
 value:getRecentlyFinishedWorkerTasks
 value:getSlackTasksMissingTree
@@ -626,13 +641,18 @@ value:getTaskStats
 value:getTasksByAgentId
 value:getTasksByStatus
 value:getTasksCount
+value:giveUpStaleChatRelays
 value:hasNonTerminalRerouteDecisionChild
 value:hasNonTerminalResumeChild
 value:isLinearTrackerContextKey
+value:markChatRelayAttempted
+value:markChatRelayDelivered
+value:markChatRelayGivenUp
 value:markFinalizedSlackRelaysDelivered
 value:markSlackRelayAttempted
 value:markSlackRelayDelivered
 value:markTasksNotified
+value:recordChatRelayError
 value:resetTasksNotified`.split("\n");
 const internal = [
   "type:AgentTaskRow",