@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/src/tests/rate-limit-event.test.ts

@@ -4,6 +4,8 @@ import {
   MAX_RATE_LIMIT_RESET_MS,
   parseRateLimitWindowTelemetry,
   parseStderrForErrors,
+  redactRateLimitEvent,
+  redactRateLimitEventLine,
   SessionErrorTracker,
   trackErrorFromJson,
 } from "../utils/error-tracker";
@@ -449,6 +451,69 @@ describe("SessionErrorTracker — model-scoped rejection (Fable weekly window)",
   });
 });
 
+// Verbatim fixture from task 91175100-349d-4284-a0c1-c41d17ddf8fa, session_logs line 4,
+// 2026-09-30. Fable on a Claude Team standard seat: rejected, no rateLimitType,
+// errorCode "credits_required".
+const FIXTURE_CREDITS_REQUIRED = {
+  type: "rate_limit_event",
+  rate_limit_info: {
+    status: "rejected",
+    resetsAt: 1790812800,
+    overageDisabledReason: "member_zero_credit_limit",
+    isUsingOverage: false,
+    errorCode: "credits_required",
+    canUserPurchaseCredits: false,
+    hasChargeableSavedPaymentMethod: true,
+  },
+  uuid: "bff51e54-9777-458a-aceb-b50aaa4255b5",
+  session_id: "9d326326-0c59-4b00-b819-b9b7dd3bf99f",
+};
+
+describe("SessionErrorTracker — credits_required rejection", () => {
+  test("credits_required is a seat mismatch, never a key-wide or model-scoped limit", () => {
+    const tracker = new SessionErrorTracker();
+    tracker.processRateLimitEvent(FIXTURE_CREDITS_REQUIRED);
+    expect(tracker.getRateLimitResetAt()).toBeUndefined();
+    expect(tracker.getModelRateLimit()).toBeUndefined();
+    expect(tracker.getCreditsRequired()?.overageDisabledReason).toBe("member_zero_credit_limit");
+  });
+
+  test("a rejected event with no rateLimitType and no errorCode stays key-wide", () => {
+    const tracker = new SessionErrorTracker();
+    const { errorCode: _errorCode, ...info } = FIXTURE_CREDITS_REQUIRED.rate_limit_info;
+    tracker.processRateLimitEvent({ ...FIXTURE_CREDITS_REQUIRED, rate_limit_info: info });
+    expect(tracker.getRateLimitResetAt()).toBeDefined();
+    expect(tracker.getCreditsRequired()).toBeUndefined();
+  });
+});
+
+describe("redactRateLimitEvent — seat payload egress", () => {
+  test("drops the seat billing fields and keeps the rest", () => {
+    const redacted = redactRateLimitEvent(FIXTURE_CREDITS_REQUIRED);
+    expect(redacted.rate_limit_info).toEqual({
+      status: "rejected",
+      resetsAt: FIXTURE_CREDITS_REQUIRED.rate_limit_info.resetsAt,
+      isUsingOverage: false,
+      errorCode: "credits_required",
+    });
+    expect(redacted.uuid).toBe(FIXTURE_CREDITS_REQUIRED.uuid);
+    // The original message is not mutated.
+    expect(FIXTURE_CREDITS_REQUIRED.rate_limit_info.overageDisabledReason).toBe(
+      "member_zero_credit_limit",
+    );
+  });
+
+  test("the line form redacts JSON and returns other lines byte for byte", () => {
+    const line = redactRateLimitEventLine(JSON.stringify(FIXTURE_CREDITS_REQUIRED));
+    expect(line).not.toContain("overageDisabledReason");
+    expect(line).toContain('"errorCode":"credits_required"');
+    const other = '{"type":"assistant",  "message":{}}';
+    expect(redactRateLimitEventLine(other)).toBe(other);
+    const plainEvent = '{"type":"rate_limit_event","rate_limit_info":{"status":"allowed"}}';
+    expect(redactRateLimitEventLine(plainEvent)).toBe(plainEvent);
+  });
+});
+
 describe("trackErrorFromJson — rate_limit_event routing", () => {
   test("routes rate_limit_event to processRateLimitEvent, stashes reset time", () => {
     const tracker = new SessionErrorTracker();

package/src/tests/rate-limit-outcome.test.ts

@@ -5,6 +5,7 @@ import {
   buildFinalRateLimitWindows,
   classifyRateLimitOutcome,
 } from "../commands/rate-limit-outcome";
+import { SessionErrorTracker } from "../utils/error-tracker";
 
 describe("classifyRateLimitOutcome", () => {
   test("event source: modelRateLimit set gives kind 'model' with source 'event'", () => {
@@ -323,3 +324,92 @@ describe("buildFinalRateLimitWindows — cross-worker recovery", () => {
     ).toEqual([0]);
   });
 });
+
+describe("classifyRateLimitOutcome — seat mismatch", () => {
+  const nowMs = Date.parse("2026-09-30T12:00:00.000Z");
+  const creditsRequired = {
+    observedAt: "2026-09-30T11:59:00.000Z",
+    overageDisabledReason: "member_zero_credit_limit",
+  };
+  const observedText = "Fable 5.1 requires usage credits. Switch to another model to continue.";
+
+  test("the observed failure text is a seat outcome from text", () => {
+    expect(classifyRateLimitOutcome({}, observedText, nowMs)).toEqual({
+      kind: "seat",
+      model: "fable",
+      source: "text",
+    });
+  });
+
+  test("a credits_required event with the task model family is a seat outcome from event", () => {
+    expect(
+      classifyRateLimitOutcome({ creditsRequired }, undefined, nowMs, undefined, "fable"),
+    ).toEqual({ kind: "seat", model: "fable", source: "event" });
+  });
+
+  test("a credits_required event with no task model family and no text is not a seat outcome", () => {
+    expect(classifyRateLimitOutcome({ creditsRequired }, undefined, nowMs).kind).not.toBe("seat");
+  });
+
+  test("a seat outcome keeps an earlier key-wide rejection from the real tracker", () => {
+    // The tracker reads the real clock and clamps past resets, so use a real "now" here.
+    const nowMs = Date.now();
+    const tracker = new SessionErrorTracker();
+    const fiveHourResetsAtSec = Math.floor(nowMs / 1000) + 2 * 60 * 60;
+    tracker.processRateLimitEvent({
+      type: "rate_limit_event",
+      rate_limit_info: {
+        status: "rejected",
+        resetsAt: fiveHourResetsAtSec,
+        rateLimitType: "five_hour",
+      },
+    });
+    tracker.processRateLimitEvent({
+      type: "rate_limit_event",
+      rate_limit_info: {
+        status: "rejected",
+        resetsAt: 1790812800,
+        overageDisabledReason: "member_zero_credit_limit",
+        isUsingOverage: false,
+        errorCode: "credits_required",
+      },
+    });
+    const rateLimitResetAt = tracker.getRateLimitResetAt();
+    const creditsRequired = tracker.getCreditsRequired();
+    expect(rateLimitResetAt).toBeDefined();
+    expect(creditsRequired).toBeDefined();
+
+    const outcome = classifyRateLimitOutcome(
+      { rateLimitResetAt, creditsRequired },
+      undefined,
+      nowMs,
+      undefined,
+      "fable",
+    );
+    expect(outcome).toEqual({
+      kind: "seat",
+      model: "fable",
+      source: "event",
+      keyRateLimitedUntil: new Date(fiveHourResetsAtSec * 1000).toISOString(),
+    });
+  });
+
+  test("a seat outcome with no key-wide rejection carries no key reset", () => {
+    const outcome = classifyRateLimitOutcome({ creditsRequired }, observedText, nowMs);
+    expect(outcome).not.toHaveProperty("keyRateLimitedUntil");
+    expect(outcome).not.toHaveProperty("rateLimitedUntil");
+  });
+
+  test("buildFinalRateLimitWindows returns the session windows unchanged for a seat outcome", () => {
+    const windows = {
+      five_hour: { status: "allowed", utilization: 0.24, lastSeenAt: "2026-09-30T11:00:00.000Z" },
+    };
+    expect(
+      buildFinalRateLimitWindows(
+        windows,
+        { kind: "seat", model: "fable", source: "event" },
+        "2026-09-30T12:00:00.000Z",
+      ),
+    ).toBe(windows);
+  });
+});

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

@@ -82,7 +82,11 @@ const LEAD_ONLY_VERBS: PermissionVerb[] = [
 ];
 
 const OPERATOR_ONLY_VERBS: PermissionVerb[] = [];
-const LEAD_OR_OPERATOR_VERBS: PermissionVerb[] = ["extension.write", "extension.activate"];
+const LEAD_OR_OPERATOR_OR_USER_VERBS: PermissionVerb[] = ["extension.write", "extension.activate"];
+
+const LEAD_OR_OPERATOR_VERBS: PermissionVerb[] = ["models.catalog.write"];
+
+const AGENT_OR_OPERATOR_VERBS: PermissionVerb[] = ["models.harness-support.write"];
 
 const LEAD_OR_RESOURCE_OWNER_VERBS: PermissionVerb[] = [
   "memory.edit.any",
@@ -116,7 +120,11 @@ const REQUESTER_OWNS_TASK_VERBS: PermissionVerb[] = [
   "task.action.own",
 ];
 
-const COMPOSITE_VERBS: PermissionVerb[] = ["memory.delete.any", "task.fs.mutate"];
+const COMPOSITE_VERBS: PermissionVerb[] = [
+  "memory.delete.any",
+  "task.fs.mutate",
+  "task.progress.write",
+];
 
 // ── Resource fixtures ────────────────────────────────────────────────────────
 
@@ -178,7 +186,9 @@ describe("verb-group partition", () => {
       ...REQUESTER_OWNS_TASK_VERBS,
       ...COMPOSITE_VERBS,
       ...OPERATOR_ONLY_VERBS,
+      ...LEAD_OR_OPERATOR_OR_USER_VERBS,
       ...LEAD_OR_OPERATOR_VERBS,
+      ...AGENT_OR_OPERATOR_VERBS,
     ];
     expect(new Set(grouped).size).toBe(grouped.length);
     expect(grouped.sort()).toEqual([...PERMISSION_VERBS].sort());
@@ -251,13 +261,47 @@ describe("lead-or-operator-or-user verbs", () => {
     foreignUser: true,
     operator: true,
   };
-  for (const verb of LEAD_OR_OPERATOR_VERBS) {
+  for (const verb of LEAD_OR_OPERATOR_OR_USER_VERBS) {
     test(`${verb}: lead, operator, or user allowed`, () => {
       expectDecisions(verb, { kind: "none" }, expected);
     });
   }
 });
 
+describe("agent-or-operator verbs", () => {
+  const expected: Expected = {
+    lead: true,
+    worker: true,
+    ownerWorker: true,
+    creatorWorker: true,
+    userRequester: false,
+    foreignUser: false,
+    operator: true,
+  };
+  for (const verb of AGENT_OR_OPERATOR_VERBS) {
+    test(`${verb}: any registered agent or the operator allowed, dashboard users denied`, () => {
+      expectDecisions(verb, { kind: "none" }, expected);
+    });
+  }
+});
+
+describe("lead-or-operator verbs", () => {
+  const expected: Expected = {
+    lead: true,
+    worker: false,
+    ownerWorker: false,
+    creatorWorker: false,
+    userRequester: false,
+    foreignUser: false,
+    operator: true,
+  };
+  for (const verb of LEAD_OR_OPERATOR_VERBS) {
+    test(`${verb}: only the lead or the operator allowed`, () => {
+      expectDecisions(verb, { kind: "none" }, expected);
+    });
+  }
+});
+
 describe("extension ownership", () => {
   test("workers create extensions and write only their own existing resource", () => {
     const worker = { kind: "agent", agentId: "extension-owner", isLead: false } as const;
@@ -505,6 +549,36 @@ describe("task.fs.mutate composite (operator OR user OR lead OR assignee OR crea
   });
 });
 
+describe("task.progress.write composite (operator OR user OR lead OR assignee OR unassigned)", () => {
+  test("the creator and an unrelated worker are denied on an assigned task", () => {
+    expectDecisions("task.progress.write", TASK_RESOURCE, {
+      lead: true,
+      worker: false,
+      ownerWorker: true, // assignee (task.agentId)
+      creatorWorker: false,
+      userRequester: true,
+      foreignUser: true,
+      operator: true,
+    });
+  });
+
+  test("any agent may write an unassigned task", () => {
+    expectDecisions(
+      "task.progress.write",
+      { kind: "task", taskId: "task-2", agentId: null },
+      {
+        lead: true,
+        worker: true,
+        ownerWorker: true,
+        creatorWorker: true,
+        userRequester: true,
+        foreignUser: true,
+        operator: true,
+      },
+    );
+  });
+});
+
 // ── Audit sink seam ──────────────────────────────────────────────────────────
 
 describe("audit sink", () => {

package/src/tests/reasoning-effort.test.ts

@@ -9,11 +9,14 @@
  */
 
 import { describe, expect, test } from "bun:test";
+import { reasoningLevelsForModel } from "@desplega/model-catalog";
 import {
   applyReasoningEffort,
   REASONING_EFFORT_LEVELS,
+  type ReasoningHarness,
   reasoningCapability,
 } from "../providers/reasoning-effort";
+import { runtimeCatalogSection } from "../utils/runtime-model-catalog";
 
 describe("REASONING_EFFORT_LEVELS", () => {
   test("is the closed normalized enum", () => {
@@ -243,3 +246,109 @@ describe("applyReasoningEffort — opencode-options shape", () => {
     });
   });
 });
+
+// The offered levels, the API's validation and the harness application all read the same
+// answer. This matrix pins it per (harness, model) so the swarm app's pickers, the runtime
+// PATCH and the run-time adapters cannot drift apart.
+describe("harness × model → effort matrix", () => {
+  const matrix: {
+    harness: "claude" | "codex" | "pi" | "opencode";
+    model: string;
+    levels: string[];
+  }[] = [
+    { harness: "claude", model: "claude-opus-5-5", levels: ["low", "medium", "high", "xhigh"] },
+    { harness: "claude", model: "claude-sonnet-5-5", levels: ["low", "medium", "high", "xhigh"] },
+    { harness: "claude", model: "claude-haiku-4-5", levels: ["off", "low", "medium", "high"] },
+    {
+      harness: "codex",
+      model: "gpt-5.6-sol",
+      levels: ["off", "low", "medium", "high", "xhigh", "max"],
+    },
+    { harness: "codex", model: "gpt-6-astra", levels: ["low", "medium", "high", "xhigh", "max"] },
+    { harness: "codex", model: "gpt-5.1-codex", levels: ["low", "medium", "high"] },
+    { harness: "pi", model: "openrouter/deepseek/deepseek-v4.1-flash", levels: ["low", "high"] },
+    {
+      harness: "pi",
+      model: "openrouter/anthropic/claude-opus-5.5",
+      levels: ["low", "medium", "high", "xhigh"],
+    },
+    {
+      harness: "opencode",
+      model: "openrouter/deepseek/deepseek-v4.1-flash",
+      levels: ["low", "high"],
+    },
+    { harness: "pi", model: "openrouter/qwen/qwen3-coder-flash", levels: [] },
+    { harness: "claude", model: "totally-custom-model-xyz", levels: [] },
+  ];
+
+  for (const { harness, model, levels } of matrix) {
+    test(`${harness} ${model}: ${levels.length > 0 ? levels.join(", ") : "no effort"}`, () => {
+      expect(reasoningCapability(harness, model).levels).toEqual(levels);
+      // Every offered level is applied, every other level is dropped: what a picker offers is what
+      // reaches the harness.
+      for (const level of REASONING_EFFORT_LEVELS) {
+        const applied = applyReasoningEffort(harness, model, level);
+        const takes = levels.includes(level);
+        // opencode has no explicit off, so its `off` is a noop even when offered.
+        const expectNoop = !takes || (harness === "opencode" && level === "off");
+        expect(applied.kind === "noop").toBe(expectNoop);
+      }
+    });
+  }
+});
+
+describe("Claude CLI shortnames (the tier defaults) take effort like the model they stand for", () => {
+  test("opus, sonnet, haiku and fable resolve to their newest catalog model", () => {
+    expect(reasoningCapability("claude", "opus")).toEqual(
+      reasoningCapability("claude", "claude-opus-5-5"),
+    );
+    expect(reasoningCapability("claude", "sonnet")).toEqual(
+      reasoningCapability("claude", "claude-sonnet-5-5"),
+    );
+    expect(reasoningCapability("claude", "haiku").levels).toContain("off");
+    expect(reasoningCapability("claude", "fable").supported).toBe(true);
+  });
+
+  test("shortnames mean nothing to the other harnesses", () => {
+    expect(reasoningCapability("codex", "opus").supported).toBe(false);
+    expect(reasoningCapability("pi", "opus").supported).toBe(false);
+  });
+});
+
+// The evals app validates and lists efforts with `reasoningLevelsForModel` (packages/model-catalog);
+// the worker applies them with `reasoningCapability`. They are two entry points to one rule, and
+// this pins them together over the real snapshot so an eval can never accept a level the worker
+// would drop (or hide one it would take).
+describe("reasoningLevelsForModel agrees with reasoningCapability", () => {
+  const catalog = {
+    anthropic: { models: runtimeCatalogSection("anthropic") },
+    openai: { models: runtimeCatalogSection("openai") },
+    openrouter: { models: runtimeCatalogSection("openrouter") },
+  };
+  const pairs: [ReasoningHarness, string][] = [
+    ...Object.keys(catalog.anthropic.models).map((id): [ReasoningHarness, string] => [
+      "claude",
+      id,
+    ]),
+    ...["opus", "sonnet", "haiku", "fable"].map((id): [ReasoningHarness, string] => ["claude", id]),
+    ...Object.keys(catalog.openai.models).map((id): [ReasoningHarness, string] => ["codex", id]),
+    ...Object.keys(catalog.openrouter.models).flatMap((id): [ReasoningHarness, string][] => [
+      ["pi", `openrouter/${id}`],
+      ["opencode", `openrouter/${id}`],
+    ]),
+    ["pi", "anthropic/claude-opus-5-5"],
+    ["opencode", "openai/gpt-5.6-sol"],
+    ["claude", "not-a-model"],
+    ["pi", "no-provider-prefix"],
+  ];
+
+  test("gives the same levels for every catalog model on every harness", () => {
+    expect(pairs.length).toBeGreaterThan(100);
+    const mismatches = pairs.filter(
+      ([harness, model]) =>
+        JSON.stringify(reasoningLevelsForModel(harness, model, catalog)) !==
+        JSON.stringify(reasoningCapability(harness, model).levels),
+    );
+    expect(mismatches).toEqual([]);
+  });
+});

package/src/tests/refresh-modelsdev-carryforward.test.ts

@@ -5,7 +5,7 @@
 
 import { describe, expect, test } from "bun:test";
 import { carryForwardDelistedModels } from "../../scripts/refresh-modelsdev-pricing";
-import { FALLBACK_CODEX_MODEL_PRICING } from "../providers/codex-models";
+import { getCodexModelPricing } from "../providers/codex-models";
 
 describe("carryForwardDelistedModels", () => {
   test("models missing from the fresh fetch are carried forward; fresh data wins otherwise", () => {
@@ -42,12 +42,12 @@ describe("carryForwardDelistedModels", () => {
 
 describe("FALLBACK_CODEX_MODEL_PRICING (advisory table)", () => {
   test("gpt-6 Astra and gpt-5.6 Sol carry the published rates", () => {
-    expect(FALLBACK_CODEX_MODEL_PRICING["gpt-6-astra"]).toEqual({
+    expect(getCodexModelPricing("gpt-6-astra")).toEqual({
       inputPerMillion: 10,
       cachedInputPerMillion: 1,
       outputPerMillion: 50,
     });
-    expect(FALLBACK_CODEX_MODEL_PRICING["gpt-5.6-sol"]).toEqual({
+    expect(getCodexModelPricing("gpt-5.6-sol")).toEqual({
       inputPerMillion: 4,
       cachedInputPerMillion: 0.4,
       outputPerMillion: 20,
@@ -57,12 +57,12 @@ describe("FALLBACK_CODEX_MODEL_PRICING (advisory table)", () => {
   test("gpt-5.6 terra/luna carry the published rates", () => {
     // Direct assertions: through computeCodexCostUsd the models.dev snapshot
     // shadows this table, so drift here would otherwise go unnoticed.
-    expect(FALLBACK_CODEX_MODEL_PRICING["gpt-5.6-terra"]).toEqual({
+    expect(getCodexModelPricing("gpt-5.6-terra")).toEqual({
       inputPerMillion: 2.0,
       cachedInputPerMillion: 0.2,
       outputPerMillion: 12.0,
     });
-    expect(FALLBACK_CODEX_MODEL_PRICING["gpt-5.6-luna"]).toEqual({
+    expect(getCodexModelPricing("gpt-5.6-luna")).toEqual({
       inputPerMillion: 0.2,
       cachedInputPerMillion: 0.02,
       outputPerMillion: 1.2,

package/src/tests/runner-key-completion-outcome.test.ts

@@ -0,0 +1,112 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { reportKeyCompletionOutcome } from "../commands/runner";
+
+// A fake API that records the order in which it FINISHES handling credential
+// reports. The success reset is slow, so a fire-and-forget caller would let
+// the later auth-failure reports land first and have their bench erased.
+const handled: string[] = [];
+let clearDelayMs = 0;
+let server: ReturnType<typeof Bun.serve>;
+let apiUrl: string;
+
+const credential = { keyType: "CODEX_OAUTH", keySuffix: "d3Ove", keyIndex: 2 };
+const authFailure =
+  "[auth-error] Codex authentication failed — check OPENAI_API_KEY or ChatGPT login. Original error: workspace routing discovery unauthorized (401)";
+
+beforeAll(() => {
+  server = Bun.serve({
+    port: 0,
+    async fetch(req) {
+      const path = new URL(req.url).pathname;
+      const body = (await req.json()) as { clearAuthBench?: boolean };
+      if (path === "/api/keys/clear-rate-limit") {
+        await Bun.sleep(clearDelayMs);
+        handled.push(`clear:${body.clearAuthBench === true}`);
+        return Response.json({ success: true, cleared: true });
+      }
+      if (path === "/api/keys/report-auth-failure") {
+        handled.push("auth-failure");
+        return Response.json({
+          success: true,
+          consecutiveAuthFailures: handled.filter((h) => h === "auth-failure").length,
+          benched: false,
+          rateLimitedUntil: null,
+        });
+      }
+      return new Response("not found", { status: 404 });
+    },
+  });
+  apiUrl = `http://localhost:${server.port}`;
+});
+
+afterAll(() => {
+  server.stop(true);
+});
+
+beforeEach(() => {
+  handled.length = 0;
+  clearDelayMs = 0;
+});
+
+describe("reportKeyCompletionOutcome", () => {
+  test("a delayed success reset lands before later auth failures of the same login", async () => {
+    clearDelayMs = 200;
+    const completions = [
+      { exitCode: 0, failureReason: undefined },
+      { exitCode: 1, failureReason: authFailure },
+      { exitCode: 1, failureReason: authFailure },
+    ];
+    // Same shape as checkCompletedProcesses: one awaited report per completion.
+    for (const [i, c] of completions.entries()) {
+      await reportKeyCompletionOutcome({
+        apiUrl,
+        apiKey: "test-key",
+        credential,
+        taskId: `00000000-0000-4000-8000-00000000000${i}`,
+        ...c,
+      });
+    }
+    expect(handled).toEqual(["clear:true", "auth-failure", "auth-failure"]);
+  });
+
+  test("returns only after the success reset is handled", async () => {
+    clearDelayMs = 100;
+    await reportKeyCompletionOutcome({
+      apiUrl,
+      apiKey: "test-key",
+      credential,
+      taskId: "00000000-0000-4000-8000-000000000009",
+      exitCode: 0,
+      failureReason: undefined,
+    });
+    expect(handled).toEqual(["clear:true"]);
+  });
+
+  test("a non-auth failure sends no report", async () => {
+    await reportKeyCompletionOutcome({
+      apiUrl,
+      apiKey: "test-key",
+      credential,
+      taskId: "00000000-0000-4000-8000-00000000000b",
+      exitCode: 1,
+      failureReason: "[rate-limit] Codex API rate limit hit. Original error: 429",
+    });
+    expect(handled).toEqual([]);
+  });
+
+  // Last: its handler finishes after the test, so nothing may assert on `handled` later.
+  test("a hung success reset is bounded by the timeout and never throws", async () => {
+    clearDelayMs = 2_000;
+    const started = Date.now();
+    await reportKeyCompletionOutcome({
+      apiUrl,
+      apiKey: "test-key",
+      credential,
+      taskId: "00000000-0000-4000-8000-00000000000a",
+      exitCode: 0,
+      failureReason: undefined,
+      timeoutMs: 100,
+    });
+    expect(Date.now() - started).toBeLessThan(1_500);
+  });
+});