@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/src/tests/fetch-resolved-env.test.ts

@@ -522,3 +522,49 @@ describe("memory rater config reload", () => {
     expect(process.env.MEMORY_RATERS).toBe("");
   });
 });
+
+describe("deleting a reloadable config row", () => {
+  // One key per test: the runner remembers each overridden key's boot value
+  // for the life of the process.
+  const keys = ["PI_CODEMODE", "PI_TOOL_DEFERRAL", "SWARM_ORG_NAME"];
+  const saved = new Map(keys.map((key) => [key, process.env[key]]));
+  afterEach(() => {
+    for (const [key, value] of saved) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  });
+
+  async function reload(agentId: string, configs: Array<{ key: string; value: string }>) {
+    mockResponsesByAgentId.set(agentId, { status: 200, body: { configs } });
+    const result = await fetchResolvedEnv(testUrl, "key", agentId);
+    return applyResolvedEnvToProcessEnv(result.env);
+  }
+
+  test("unset at boot: deleting the row unsets the var", async () => {
+    delete process.env.PI_CODEMODE;
+    await reload("row-delete-unset", [{ key: "PI_CODEMODE", value: "true" }]);
+    expect(process.env.PI_CODEMODE).toBe("true");
+
+    const changed = await reload("row-delete-unset", []);
+    expect(changed).toContain("PI_CODEMODE");
+    expect(process.env.PI_CODEMODE).toBeUndefined();
+  });
+
+  test("set at boot: deleting the overriding row restores the boot value", async () => {
+    process.env.PI_TOOL_DEFERRAL = "false";
+    await reload("row-delete-boot", [{ key: "PI_TOOL_DEFERRAL", value: "true" }]);
+    expect(process.env.PI_TOOL_DEFERRAL).toBe("true");
+
+    const changed = await reload("row-delete-boot", []);
+    expect(changed).toContain("PI_TOOL_DEFERRAL");
+    expect(process.env.PI_TOOL_DEFERRAL).toBe("false");
+  });
+
+  test("set at boot and never overridden: untouched", async () => {
+    process.env.SWARM_ORG_NAME = "container-org";
+    const changed = await reload("row-never-set", []);
+    expect(changed).not.toContain("SWARM_ORG_NAME");
+    expect(process.env.SWARM_ORG_NAME).toBe("container-org");
+  });
+});

package/src/tests/hang-watchdog-worker.ts

@@ -0,0 +1,47 @@
+/**
+ * Runs on its own thread, so it keeps ticking while the test file's main thread
+ * is stuck in a synchronous loop. See `hang-watchdog.ts` for why it exists.
+ */
+import { writeSync } from "node:fs";
+import { workerData } from "node:worker_threads";
+
+const { heartbeat, file, limitMs } = workerData as {
+  heartbeat: Int32Array;
+  file: string;
+  limitMs: number;
+};
+
+// Synchronous write: the process is SIGKILLed right after, which drops anything buffered.
+const log = (message: string) => writeSync(2, `[hang-watchdog] ${message}\n`);
+
+const POLL_MS = 1000;
+const WARN_MS = 10_000;
+let last = Atomics.load(heartbeat, 0);
+let lastChange = Date.now();
+let warned = false;
+
+while (true) {
+  // Sleep on a slot nobody notifies: a timed wait that does not need this thread's event loop.
+  Atomics.wait(heartbeat, 1, 0, POLL_MS);
+  const current = Atomics.load(heartbeat, 0);
+  const now = Date.now();
+  if (current !== last) {
+    last = current;
+    lastChange = now;
+    warned = false;
+    continue;
+  }
+  const stalledMs = now - lastChange;
+  if (!warned && stalledMs >= WARN_MS) {
+    warned = true;
+    log(`${file}: main thread has not yielded for ${Math.round(stalledMs / 1000)}s`);
+  }
+  if (stalledMs >= limitMs) {
+    log(
+      `${file}: main thread blocked for ${Math.round(stalledMs / 1000)}s ` +
+        `(limit ${Math.round(limitMs / 1000)}s), killing test worker pid ${process.pid}. ` +
+        "A synchronous busy loop cannot be interrupted by --timeout.",
+    );
+    process.kill(process.pid, "SIGKILL");
+  }
+}

package/src/tests/hang-watchdog.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test";
+import { CHILD_PROCESS_TEST_BUDGET_MS, runChild } from "./test-proc";
+
+const watchdogModule = JSON.stringify(`${import.meta.dir}/hang-watchdog`);
+
+/** Runs `body` in a fresh `bun` process with the watchdog armed at `limitMs` (no test preload). */
+function runWithWatchdog(body: string, limitMs: number) {
+  return runChild(
+    [
+      process.execPath,
+      "-e",
+      `import { startHangWatchdog } from ${watchdogModule}; startHangWatchdog("fixture"); ${body}`,
+    ],
+    { env: { ...process.env, TEST_HANG_WATCHDOG_MS: String(limitMs) } },
+  );
+}
+
+describe("startHangWatchdog", () => {
+  test(
+    "kills a process whose main thread is stuck in a synchronous loop, and only that one",
+    async () => {
+      const [spinning, yielding, disabled] = await Promise.all([
+        runWithWatchdog("while (true) {}", 3000),
+        // Yields every tick, so the heartbeat keeps moving well past the limit.
+        runWithWatchdog('await Bun.sleep(4500); console.log("finished");', 3000),
+        // 0 turns it off: a 4s synchronous spin is left alone.
+        runWithWatchdog(
+          'const end = Date.now() + 4000; while (Date.now() < end) {} console.log("finished");',
+          0,
+        ),
+      ]);
+
+      expect(spinning.signalCode).toBe("SIGKILL");
+      expect(spinning.stderr).toContain("[hang-watchdog] fixture: main thread blocked for");
+      expect(spinning.durationMs).toBeLessThan(10_000);
+
+      expect(yielding.exitCode).toBe(0);
+      expect(yielding.stdout).toContain("finished");
+
+      expect(disabled.exitCode).toBe(0);
+      expect(disabled.stdout).toContain("finished");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+});

package/src/tests/hang-watchdog.ts

@@ -0,0 +1,30 @@
+/**
+ * Fail a wedged test worker in seconds instead of at the CI job limit.
+ *
+ * `bun test --timeout` is a timer on the test file's own event loop. A synchronous
+ * busy loop (the intermittent `Run Tests (2/2)` hang, which spun one test worker at
+ * ~80% CPU with no syscalls for 20 minutes) starves that loop, so the timeout never
+ * fires and the job only ends at the workflow limit.
+ *
+ * The main thread bumps a shared counter every second. A second thread watches it and
+ * kills the process when the counter stops moving, which makes `bun test` report the
+ * file as failed. Tests that yield to the event loop at all never trip it.
+ *
+ * `TEST_HANG_WATCHDOG_MS=0` turns it off; any other number sets the limit (default 60s).
+ */
+import { Worker } from "node:worker_threads";
+
+const DEFAULT_LIMIT_MS = 60_000;
+
+export function startHangWatchdog(file: string = Bun.main): void {
+  const raw = process.env.TEST_HANG_WATCHDOG_MS;
+  const limitMs = raw === undefined ? DEFAULT_LIMIT_MS : Number(raw);
+  if (!Number.isFinite(limitMs) || limitMs <= 0) return;
+
+  const heartbeat = new Int32Array(new SharedArrayBuffer(8));
+  const worker = new Worker(new URL("./hang-watchdog-worker.ts", import.meta.url), {
+    workerData: { heartbeat, file, limitMs },
+  });
+  worker.unref();
+  setInterval(() => Atomics.add(heartbeat, 0, 1), 1000).unref();
+}

package/src/tests/harness-model-guard.test.ts

@@ -0,0 +1,123 @@
+// Harness model guard: a task model from another harness family never reaches a CLI.
+// Covers the heartbeat pool auto-assign filter and the worker-side spawn guard.
+// Create-time and claim-time checks live in explicit-model-validation.test.ts and
+// model-tier-resolution.test.ts.
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getDbClient,
+  getTaskById,
+  initDb,
+} from "../be/db";
+import { codeLevelTriage } from "../heartbeat/heartbeat";
+import { guardSpawnModel } from "../utils/spawn-model-guard";
+import "../tools/templates";
+
+const TEST_DB_PATH = "./test-harness-model-guard.sqlite";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(path + suffix).catch(() => undefined);
+  }
+}
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  closeDb();
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+beforeEach(async () => {
+  await getDbClient().run("DELETE FROM agent_tasks");
+  await getDbClient().run("DELETE FROM agents");
+});
+
+describe("autoAssignPoolTasks harness filter", () => {
+  test("a claude-opus-5-5 pool task goes to the idle Claude worker, not the idle Codex worker", async () => {
+    // The Codex worker sorts first, so a missing filter would pick it.
+    const codex = await createAgent({
+      name: "aaa-idle-codex",
+      isLead: false,
+      status: "idle",
+      harnessProvider: "codex",
+    });
+    const claude = await createAgent({
+      name: "zzz-idle-claude",
+      isLead: false,
+      status: "idle",
+      harnessProvider: "claude",
+    });
+    const task = await createTaskExtended("pool work", { model: "claude-opus-5-5" });
+
+    const findings = await codeLevelTriage();
+
+    expect(findings.autoAssigned).toEqual([{ taskId: task.id, agentId: claude.id }]);
+    expect((await getTaskById(task.id))?.agentId).not.toBe(codex.id);
+  });
+
+  test("with only an idle Codex worker the task stays queued", async () => {
+    await createAgent({
+      name: "only-codex",
+      isLead: false,
+      status: "idle",
+      harnessProvider: "codex",
+    });
+    const task = await createTaskExtended("pool work", { model: "claude-opus-5-5" });
+
+    const findings = await codeLevelTriage();
+
+    expect(findings.autoAssigned).toHaveLength(0);
+    expect((await getTaskById(task.id))?.status).toBe("unassigned");
+  });
+});
+
+describe("guardSpawnModel (worker spawn)", () => {
+  test("a MODEL_OVERRIDE from another harness family falls back to the adapter default with a warning", () => {
+    const decision = guardSpawnModel({
+      taskModel: "",
+      configModel: "gpt-6-luna",
+      harness: "claude",
+      role: "worker",
+    });
+    expect(decision).toEqual({
+      kind: "ok",
+      model: "",
+      warning:
+        "[worker] MODEL_OVERRIDE gpt-6-luna does not run on the claude harness; using the adapter default",
+    });
+  });
+
+  test("a compatible MODEL_OVERRIDE, a shortname, and an unpinned harness pass through", () => {
+    expect(
+      guardSpawnModel({ taskModel: "", configModel: "gpt-6-luna", harness: "codex", role: "w" }),
+    ).toEqual({ kind: "ok", model: "gpt-6-luna" });
+    expect(
+      guardSpawnModel({ taskModel: "", configModel: "opus", harness: "codex", role: "w" }),
+    ).toEqual({ kind: "ok", model: "opus" });
+    expect(
+      guardSpawnModel({ taskModel: "claude-opus-5-5", configModel: "", harness: "pi", role: "w" }),
+    ).toEqual({ kind: "ok", model: "claude-opus-5-5" });
+  });
+
+  test("a task model from another harness family is a mismatch, so the runner never spawns", () => {
+    const decision = guardSpawnModel({
+      taskModel: "claude-opus-5-5",
+      configModel: "gpt-6-luna",
+      harness: "codex",
+      role: "worker",
+    });
+    expect(decision.kind).toBe("mismatch");
+    expect(decision.kind === "mismatch" && decision.reason).toBe(
+      '[model-harness-mismatch] Model "claude-opus-5-5" does not run on the codex harness of this worker. The task pinned a model from another harness family. Re-create the task with modelTier or with a codex model.',
+    );
+  });
+});

package/src/tests/harness-model-support.test.ts

@@ -0,0 +1,374 @@
+// Model-catalog phase 4: harness CLI model support, CLI-unsupported fallback
+// and fail-fast at claim, and the worker-side outcome reporter.
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, createAgent, createTaskExtended, getDbClient, initDb } from "../be/db";
+import {
+  getHarnessModelSupport,
+  recordHarnessModelSupport,
+  setAgentHarnessCliVersion,
+} from "../be/harness-model-support";
+import { type ModelCatalogEntry, replaceModelCatalog } from "../be/model-catalog-store";
+import { invalidateTierResolutionCatalog } from "../be/model-tier-resolution";
+import { handlePoll } from "../http/poll";
+import {
+  parseCliVersion,
+  reportHarnessModelOutcome,
+  resetHarnessCliVersionForTests,
+} from "../utils/harness-cli-version";
+import { isUnknownModelError } from "../utils/harness-model-error";
+
+const TEST_DB_PATH = "./test-harness-model-support.sqlite";
+const DAY = 24 * 60 * 60 * 1000;
+const CLI = "2.1.283";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+function entry(modelId: string, daysOld: number): ModelCatalogEntry {
+  return {
+    provider: "anthropic",
+    modelId,
+    releaseDate: new Date(Date.now() - daysOld * DAY).toISOString().slice(0, 10),
+    pricing: { input: 5, output: 25 },
+    checkedAt: Date.now(),
+  };
+}
+
+type Trigger = { type: string; taskId: string; task: Record<string, unknown> };
+
+async function callPoll(agentId: string): Promise<Trigger | null> {
+  let bodyStr = "";
+  const req = {
+    method: "GET",
+    url: "/api/poll",
+    headers: { "x-agent-id": agentId },
+  } as unknown as Parameters<typeof handlePoll>[0];
+  const res = {
+    setHeader() {},
+    writeHead() {},
+    end(body?: string) {
+      bodyStr = body ?? "";
+    },
+  } as unknown as Parameters<typeof handlePoll>[1];
+  await handlePoll(req, res, ["api", "poll"], new URLSearchParams(), agentId);
+  return (JSON.parse(bodyStr) as { trigger: Trigger | null }).trigger;
+}
+
+async function worker(name: string) {
+  const agent = await createAgent({
+    name,
+    isLead: false,
+    status: "idle",
+    maxTasks: 1,
+    harnessProvider: "claude",
+  });
+  await setAgentHarnessCliVersion(agent.id, CLI);
+  return agent;
+}
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+beforeEach(async () => {
+  const client = getDbClient();
+  await client.run("DELETE FROM agent_tasks");
+  await client.run("DELETE FROM agents");
+  await client.run("DELETE FROM harness_model_support");
+  await client.run("DELETE FROM model_alias_resolutions");
+  await replaceModelCatalog([
+    entry("claude-opus-5", 200),
+    entry("claude-opus-5-5", 30),
+    entry("claude-sonnet-5-5", 10),
+  ]);
+  invalidateTierResolutionCatalog();
+  delete process.env.MODEL_TIER_CLAUDE_SMART;
+});
+
+describe("claim-time CLI support", () => {
+  test("alias resolving to an unsupported model falls back within the family", async () => {
+    process.env.MODEL_TIER_CLAUDE_SMART = "latest:anthropic/opus@stable";
+    await recordHarnessModelSupport({
+      harness: "claude",
+      cliVersion: CLI,
+      modelId: "claude-opus-5-5",
+      status: "unsupported",
+      error: "There's an issue with the selected model (claude-opus-5-5).",
+    });
+    const w = await worker("w-fallback");
+    const task = await createTaskExtended("smart work", { agentId: w.id, modelTier: "smart" });
+
+    const trigger = await callPoll(w.id);
+    expect(trigger?.task.resolvedModel).toBe("claude-opus-5");
+    expect(trigger?.task.modelSource).toBe("fallback:cli-unsupported");
+    const row = await getDbClient().get<{ resolvedModel: string; modelSource: string }>(
+      "SELECT resolvedModel, modelSource FROM agent_tasks WHERE id = ?",
+      [task.id],
+    );
+    expect(row).toEqual({
+      resolvedModel: "claude-opus-5",
+      modelSource: "fallback:cli-unsupported",
+    });
+    delete process.env.MODEL_TIER_CLAUDE_SMART;
+  });
+
+  test("the fallback never picks an unpriced sibling, which would run outside cost accounting", async () => {
+    process.env.MODEL_TIER_CLAUDE_SMART = "latest:anthropic/opus@stable";
+    // Newer than the priced fallback (claude-opus-5) but with no price yet.
+    await replaceModelCatalog([
+      entry("claude-opus-5", 200),
+      entry("claude-opus-5-5", 30),
+      { ...entry("claude-opus-5-4", 60), pricing: null },
+    ]);
+    invalidateTierResolutionCatalog();
+    await recordHarnessModelSupport({
+      harness: "claude",
+      cliVersion: CLI,
+      modelId: "claude-opus-5-5",
+      status: "unsupported",
+    });
+    const w = await worker("w-unpriced-fallback");
+    await createTaskExtended("smart work", { agentId: w.id, modelTier: "smart" });
+
+    const trigger = await callPoll(w.id);
+    expect(trigger?.task.resolvedModel).toBe("claude-opus-5");
+    expect(trigger?.task.modelSource).toBe("fallback:cli-unsupported");
+    delete process.env.MODEL_TIER_CLAUDE_SMART;
+  });
+
+  test("explicit unsupported model fails fast: trigger carries modelUnsupported", async () => {
+    await recordHarnessModelSupport({
+      harness: "claude",
+      cliVersion: CLI,
+      modelId: "claude-opus-5-5",
+      status: "unsupported",
+    });
+    const w = await worker("w-explicit");
+    await createTaskExtended("pinned work", { agentId: w.id, model: "claude-opus-5-5" });
+    const trigger = await callPoll(w.id);
+    expect(String(trigger?.task.modelUnsupported)).toContain("claude-opus-5-5");
+    expect(trigger?.task.resolvedModel).toBeUndefined();
+  });
+
+  test("an explicit latest: alias on an unsupported model falls back, like a tier alias", async () => {
+    await recordHarnessModelSupport({
+      harness: "claude",
+      cliVersion: CLI,
+      modelId: "claude-opus-5-5",
+      status: "unsupported",
+    });
+    const w = await worker("w-explicit-alias");
+    const task = await createTaskExtended("aliased work", {
+      agentId: w.id,
+      model: "latest:anthropic/opus",
+    });
+    const trigger = await callPoll(w.id);
+    expect(trigger?.task.modelUnsupported).toBeUndefined();
+    expect(trigger?.task.resolvedModel).toBe("claude-opus-5");
+    expect(trigger?.task.modelSource).toBe("fallback:cli-unsupported");
+    // The alias the task named is still on the record.
+    expect(trigger?.task.modelAlias).toBe("latest:anthropic/opus");
+    const row = await getDbClient().get<{ modelAlias: string }>(
+      "SELECT modelAlias FROM agent_tasks WHERE id = ?",
+      [task.id],
+    );
+    expect(row?.modelAlias).toBe("latest:anthropic/opus");
+  });
+
+  test("an alias with no usable sibling keeps its resolution instead of failing the task", async () => {
+    for (const modelId of ["claude-opus-5-5", "claude-opus-5"]) {
+      await recordHarnessModelSupport({
+        harness: "claude",
+        cliVersion: CLI,
+        modelId,
+        status: "unsupported",
+      });
+    }
+    const w = await worker("w-no-sibling");
+    await createTaskExtended("aliased work", { agentId: w.id, model: "latest:anthropic/opus" });
+    const trigger = await callPoll(w.id);
+    expect(trigger?.task.modelUnsupported).toBeUndefined();
+    expect(trigger?.task.resolvedModel).toBe("claude-opus-5-5");
+    expect(trigger?.task.modelSource).toBe("model");
+  });
+
+  test("a tier default (CLI shortname) the CLI rejected falls back within its family", async () => {
+    await recordHarnessModelSupport({
+      harness: "claude",
+      cliVersion: CLI,
+      modelId: "opus",
+      status: "unsupported",
+    });
+    const w = await worker("w-tier-default");
+    await createTaskExtended("smart work", { agentId: w.id, modelTier: "smart" });
+    const trigger = await callPoll(w.id);
+    expect(trigger?.task.modelUnsupported).toBeUndefined();
+    expect(trigger?.task.resolvedModel).toBe("claude-opus-5-5");
+    expect(trigger?.task.modelSource).toBe("fallback:cli-unsupported");
+  });
+
+  test("a tier default shortname stays when only a catalog id was rejected: the CLI resolves it", async () => {
+    await recordHarnessModelSupport({
+      harness: "claude",
+      cliVersion: CLI,
+      modelId: "claude-opus-5-5",
+      status: "unsupported",
+    });
+    const w = await worker("w-shortname-ok");
+    await createTaskExtended("smart work", { agentId: w.id, modelTier: "smart" });
+    const trigger = await callPoll(w.id);
+    expect(trigger?.task.resolvedModel).toBe("opus");
+    expect(trigger?.task.modelSource).toBe("tier-default");
+  });
+
+  test("a concrete id from a tier config value falls back; only a pinned task model fails fast", async () => {
+    process.env.MODEL_TIER_CLAUDE_SMART = "claude-opus-5-5";
+    await recordHarnessModelSupport({
+      harness: "claude",
+      cliVersion: CLI,
+      modelId: "claude-opus-5-5",
+      status: "unsupported",
+    });
+    const w = await worker("w-tier-config");
+    await createTaskExtended("smart work", { agentId: w.id, modelTier: "smart" });
+    const trigger = await callPoll(w.id);
+    expect(trigger?.task.resolvedModel).toBe("claude-opus-5");
+    expect(trigger?.task.modelSource).toBe("fallback:cli-unsupported");
+    delete process.env.MODEL_TIER_CLAUDE_SMART;
+  });
+
+  test("unknown support (no row) is allowed; other CLI versions are unaffected", async () => {
+    await recordHarnessModelSupport({
+      harness: "claude",
+      cliVersion: "2.0.0",
+      modelId: "claude-opus-5-5",
+      status: "unsupported",
+    });
+    const w = await worker("w-unknown");
+    await createTaskExtended("pinned work", { agentId: w.id, model: "claude-opus-5-5" });
+    const trigger = await callPoll(w.id);
+    expect(trigger?.task.resolvedModel).toBe("claude-opus-5-5");
+    expect(trigger?.task.modelUnsupported).toBeUndefined();
+  });
+
+  test("an ok row is never downgraded to unknown", async () => {
+    const base = { harness: "claude", cliVersion: CLI, modelId: "claude-opus-5-5" };
+    await recordHarnessModelSupport({ ...base, status: "ok" });
+    await recordHarnessModelSupport({ ...base, status: "unknown" });
+    expect(await getHarnessModelSupport("claude", CLI, "claude-opus-5-5")).toBe("ok");
+  });
+});
+
+describe("worker outcome reporting", () => {
+  test("parses CLI versions and recognizes unknown-model errors", () => {
+    expect(parseCliVersion("2.1.283 (Claude Code)")).toBe("2.1.283");
+    expect(parseCliVersion("codex-cli 0.157.1")).toBe("0.157.1");
+    expect(isUnknownModelError("There's an issue with the selected model (claude-x).")).toBe(true);
+    expect(isUnknownModelError("The model `gpt-9` does not exist or you do not have access")).toBe(
+      true,
+    );
+    expect(isUnknownModelError("rate limit reached")).toBe(false);
+  });
+
+  test("with a model id, only a rejection that names that model counts", () => {
+    const rejection = "There's an issue with the selected model (claude-x). It may not exist.";
+    expect(isUnknownModelError(rejection, "claude-x")).toBe(true);
+    expect(isUnknownModelError(rejection, "CLAUDE-X")).toBe(true);
+    expect(isUnknownModelError("The model `gpt-9` does not exist", "gpt-9")).toBe(true);
+    expect(isUnknownModelError("unknown model 'gpt-9'\nstack trace", "gpt-9")).toBe(true);
+    // Rejection text for another model, or phrase-only text from an unrelated failure.
+    expect(isUnknownModelError(rejection, "claude-y")).toBe(false);
+    expect(isUnknownModelError("tool call failed: invalid model output", "claude-x")).toBe(false);
+    expect(isUnknownModelError("unknown model type in schema\nran claude-x fine", "claude-x")).toBe(
+      false,
+    );
+  });
+
+  test("an unrelated failure containing a rejection phrase does not report unsupported", async () => {
+    resetHarnessCliVersionForTests({ claude: CLI });
+    const bodies: unknown[] = [];
+    const fetchImpl = (async (_url: string, init: RequestInit) => {
+      bodies.push(JSON.parse(String(init.body)));
+      return new Response("{}", { status: 200 });
+    }) as unknown as typeof fetch;
+
+    await reportHarnessModelOutcome({
+      apiUrl: "http://x",
+      agentId: "a",
+      harness: "claude",
+      fetchImpl,
+      model: "m1",
+      exitCode: 1,
+      failureReason: "Tool call failed: invalid model output from the summarizer",
+    });
+
+    expect(bodies).toEqual([]);
+    resetHarnessCliVersionForTests();
+  });
+
+  test("sends unsupported on a model rejection, ok once on success, nothing on other failures", async () => {
+    resetHarnessCliVersionForTests({ claude: CLI });
+    const bodies: unknown[] = [];
+    const fetchImpl = (async (_url: string, init: RequestInit) => {
+      bodies.push(JSON.parse(String(init.body)));
+      return new Response("{}", { status: 200 });
+    }) as unknown as typeof fetch;
+    const base = { apiUrl: "http://x", agentId: "a", harness: "claude", fetchImpl };
+
+    await reportHarnessModelOutcome({ ...base, model: "m1", exitCode: 1, failureReason: "boom" });
+    await reportHarnessModelOutcome({
+      ...base,
+      model: "m1",
+      exitCode: 1,
+      failureReason: "There's an issue with the selected model (m1).",
+    });
+    await reportHarnessModelOutcome({ ...base, model: "m2", exitCode: 0 });
+    await reportHarnessModelOutcome({ ...base, model: "m2", exitCode: 0 });
+
+    expect(bodies).toMatchObject([
+      { modelId: "m1", status: "unsupported", cliVersion: CLI },
+      { modelId: "m2", status: "ok" },
+    ]);
+    resetHarnessCliVersionForTests();
+  });
+
+  test("scrubs secrets from the failure text before it leaves the worker", async () => {
+    resetHarnessCliVersionForTests({ claude: CLI });
+    const token = "ghp_abcdefghijklmnopqrstuvwxyz0123456789";
+    const bodies: Array<{ error?: string }> = [];
+    const fetchImpl = (async (_url: string, init: RequestInit) => {
+      bodies.push(JSON.parse(String(init.body)));
+      return new Response("{}", { status: 200 });
+    }) as unknown as typeof fetch;
+
+    await reportHarnessModelOutcome({
+      apiUrl: "http://x",
+      agentId: "a",
+      harness: "claude",
+      fetchImpl,
+      model: "m1",
+      exitCode: 1,
+      failureReason: `There's an issue with the selected model (m1). token=${token}`,
+    });
+
+    expect(bodies).toHaveLength(1);
+    expect(bodies[0]?.error).toContain("selected model");
+    expect(bodies[0]?.error).not.toContain(token);
+    resetHarnessCliVersionForTests();
+  });
+});