@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/src/tests/claude-managed-adapter.test.ts

@@ -9,8 +9,8 @@ import {
   normalizeRepoUrl,
 } from "../providers/claude-managed-adapter";
 import {
-  CLAUDE_MANAGED_MODEL_PRICING,
   computeClaudeManagedCostUsd,
+  getClaudeManagedModelPricing,
 } from "../providers/claude-managed-models";
 import type { ProviderEvent, ProviderSessionConfig } from "../providers/types";
 
@@ -885,58 +885,52 @@ describe("ClaudeManagedAdapter (Phase 4) — repo provisioning + cost data", ()
     expect(cost2).toBe(0);
   });
 
-  test("CLAUDE_MANAGED_MODEL_PRICING covers sonnet, opus, haiku at minimum", () => {
-    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-fable-5-1"]).toEqual({
+  test("catalog prices managed models: covers sonnet, opus, haiku at minimum", () => {
+    expect(getClaudeManagedModelPricing("claude-fable-5-1")).toEqual({
       inputPerMillion: 10.0,
       outputPerMillion: 50.0,
       cacheReadPerMillion: 0.25,
       cacheWritePerMillion: 12.5,
     });
-    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-mythos-5-1"]).toEqual({
-      inputPerMillion: 10.0,
-      outputPerMillion: 50.0,
-      cacheReadPerMillion: 0.25,
-      cacheWritePerMillion: 12.5,
-    });
-    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-opus-5-5"]).toEqual({
+    expect(getClaudeManagedModelPricing("claude-opus-5-5")).toEqual({
       inputPerMillion: 4.0,
       outputPerMillion: 20.0,
       cacheReadPerMillion: 0.2,
       cacheWritePerMillion: 5.0,
     });
-    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-opus-5"]).toEqual({
+    expect(getClaudeManagedModelPricing("claude-opus-5")).toEqual({
       inputPerMillion: 5.0,
       outputPerMillion: 25.0,
       cacheReadPerMillion: 0.5,
       cacheWritePerMillion: 6.25,
     });
-    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-fable-5"]).toEqual({
+    expect(getClaudeManagedModelPricing("claude-fable-5")).toEqual({
       inputPerMillion: 10.0,
       outputPerMillion: 50.0,
       cacheReadPerMillion: 1.0,
       cacheWritePerMillion: 12.5,
     });
-    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-mythos-5"]).toEqual({
+    expect(getClaudeManagedModelPricing("claude-mythos-5")).toEqual({
       inputPerMillion: 10.0,
       outputPerMillion: 50.0,
       cacheReadPerMillion: 1.0,
       cacheWritePerMillion: 12.5,
     });
-    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-5-5"]).toEqual({
+    expect(getClaudeManagedModelPricing("claude-sonnet-5-5")).toEqual({
       inputPerMillion: 2.0,
       outputPerMillion: 10.0,
       cacheReadPerMillion: 0.2,
       cacheWritePerMillion: 2.5,
     });
-    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-5"]).toEqual({
+    expect(getClaudeManagedModelPricing("claude-sonnet-5")).toEqual({
       inputPerMillion: 2.0,
       outputPerMillion: 10.0,
       cacheReadPerMillion: 0.2,
       cacheWritePerMillion: 2.5,
     });
-    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-4-6"]).toBeDefined();
-    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-opus-4-7"]).toBeDefined();
-    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-haiku-4-5"]).toBeDefined();
+    expect(getClaudeManagedModelPricing("claude-sonnet-4-6")).toBeDefined();
+    expect(getClaudeManagedModelPricing("claude-opus-4-7")).toBeDefined();
+    expect(getClaudeManagedModelPricing("claude-haiku-4-5")).toBeDefined();
   });
 
   test("session totalCostUsd = token cost + (durationMs/3.6e6) × $0.08 runtime fee", async () => {

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

@@ -1914,12 +1914,13 @@ describe("buildCodexConfig — context-mode + features", () => {
     expect(mcp["context-mode"]).toBeUndefined();
   });
 
-  test("sets features.hooks and features.plugin_hooks to true", async () => {
+  test("disables apps and enables hooks", async () => {
     delete process.env.CONTEXT_MODE_DISABLED;
     globalThis.fetch = stubFetch({ servers: [], total: 0 });
     const merged = await buildCodexConfig(cfg(), "gpt-5.4", () => {});
 
     const features = merged.features as Record<string, unknown>;
+    expect(features.apps).toBe(false);
     expect(features.hooks).toBe(true);
     expect(features.plugin_hooks).toBe(true);
   });

package/src/tests/codex-auth-failure.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test";
+import { buildPoolRevalidationFailureReason } from "../providers/codex-adapter";
+import { CodexOAuthRefreshError } from "../providers/codex-oauth/storage";
+import { isCodexAuthFailureReason } from "../utils/codex-auth-failure";
+
+describe("isCodexAuthFailureReason", () => {
+  test.each([
+    "[auth-error] Codex authentication failed — check OPENAI_API_KEY or ChatGPT login. Original error: workspace routing discovery unauthorized (401)",
+    "[auth-error] Codex authentication failed — check OPENAI_API_KEY or ChatGPT login. Original error: Failed to refresh token: 400 Bad Request: Invalid 'refresh_token': empty string",
+    '[auth-error] Codex pool slot 2 [...d3Ove] revalidation failed: refresh rejected (401 {"error":"refresh_token_invalidated"}) — credential likely revoked; re-run codex-login for this slot.',
+  ])("counts %s", (reason) => {
+    expect(isCodexAuthFailureReason(reason)).toBe(true);
+  });
+
+  test.each([
+    undefined,
+    null,
+    "",
+    "[rate-limit] Codex API rate limit hit. Original error: 429",
+    "[auth-error] Codex pool slot 2 [...d3Ove] revalidation failed: timed out waiting for the refresh lock — transient, will retry on next task.",
+    "[auth-error] Codex pool slot 2 [...d3Ove] revalidation failed: refresh rejected (429 Too Many Requests) — credential likely revoked; re-run codex-login for this slot.",
+    "[auth-error] Codex pool slot 2 [...d3Ove] revalidation failed: refresh rejected (503 Service Unavailable) — credential likely revoked; re-run codex-login for this slot.",
+    "[auth-error] Codex pool slot 2 [...d3Ove] revalidation failed: refresh rejected (unknown status ) — credential likely revoked; re-run codex-login for this slot.",
+    "[auth-error] Codex pool slot 2 [...d3Ove] revalidation failed: no credentials found in config store — the slot may have just been quarantined; the next task will pick another slot.",
+  ])("does not count %p", (reason) => {
+    expect(isCodexAuthFailureReason(reason)).toBe(false);
+  });
+
+  test.each([
+    ["network error", new TypeError("fetch failed")],
+    ["refresh-lock HTTP error", new Error("refresh lock acquire failed: HTTP 502")],
+    ["persistence error", new Error("Failed to store Codex OAuth credentials: 500")],
+    ["lock timeout", new CodexOAuthRefreshError(2, "lock_timeout", "d3Ove")],
+    ["throttled refresh", new CodexOAuthRefreshError(2, "refresh_rejected", "d3Ove", 429)],
+    ["upstream refresh error", new CodexOAuthRefreshError(2, "refresh_rejected", "d3Ove", 503)],
+  ])("a thrown %s during revalidation does not count", (_label, err) => {
+    const reason = buildPoolRevalidationFailureReason(err, 2);
+    expect(reason).toContain("[auth-error]");
+    expect(isCodexAuthFailureReason(reason)).toBe(false);
+  });
+
+  test("a confirmed refresh rejection during revalidation counts", () => {
+    const err = new CodexOAuthRefreshError(
+      2,
+      "refresh_rejected",
+      "d3Ove",
+      401,
+      '{"error":"refresh_token_invalidated"}',
+    );
+    expect(isCodexAuthFailureReason(buildPoolRevalidationFailureReason(err, 2))).toBe(true);
+  });
+});

package/src/tests/codex-gpt6-release.test.ts

@@ -5,10 +5,10 @@ import cache from "../be/modelsdev-cache.json";
 import { buildModelsDevSeedRows } from "../be/seed-pricing";
 import {
   CODEX_DEFAULT_MODEL,
-  CODEX_MODELS,
   computeCodexCostUsd,
-  FALLBACK_CODEX_MODEL_PRICING,
   getCodexContextWindow,
+  getCodexModelPricing,
+  listCodexModels,
   resolveCodexModel,
 } from "../providers/codex-models";
 import { applyReasoningEffort, reasoningCapability } from "../providers/reasoning-effort";
@@ -21,11 +21,11 @@ const releases = [
 for (const release of releases) {
   describe(release.id, () => {
     test("uses the exact bare CLI ID with verified context and base costs", () => {
-      expect(CODEX_MODELS).toContain(release.id);
+      expect(listCodexModels()).toContain(release.id);
       expect(resolveCodexModel(release.id.toUpperCase())).toBe(release.id);
       expect(getCodexContextWindow(release.id)).toBe(1_050_000);
       expect(cache.openai.models[release.id].limit.output).toBe(128_000);
-      expect(FALLBACK_CODEX_MODEL_PRICING[release.id]).toEqual({
+      expect(getCodexModelPricing(release.id)).toEqual({
         inputPerMillion: release.input,
         cachedInputPerMillion: release.read,
         outputPerMillion: release.output,
@@ -79,7 +79,7 @@ for (const release of releases) {
     test("is available through the catalog and direct UI selector", () => {
       const model = buildModelsCatalog(cache).openai?.models[release.id];
       expect(model?.limit?.context).toBe(1_050_000);
-      expect(model?.cost).toEqual({ input: release.input, output: release.output });
+      expect(model?.cost).toMatchObject({ input: release.input, output: release.output });
       const option = modelGroupsForHarness("codex", undefined, undefined)
         .flatMap((group) => group.models)
         .find((entry) => entry.id === release.id);
@@ -95,3 +95,64 @@ test("release additions preserve rollout-safe defaults and aliases", () => {
   expect(resolveCodexModel("haiku")).toBe("gpt-5.6-luna");
   expect(resolveCodexModel("opus")).toBe("gpt-5.6-sol");
 });
+
+describe("gpt-6.1-sol", () => {
+  const id = "gpt-6.1-sol";
+
+  test("uses the exact bare CLI ID with verified context and base costs", () => {
+    expect(listCodexModels()).toContain(id);
+    expect(resolveCodexModel("GPT-6.1-SOL")).toBe(id);
+    expect(getCodexContextWindow(id)).toBe(1_050_000);
+    expect(cache.openai.models[id].limit.output).toBe(128_000);
+    expect(getCodexModelPricing(id)).toEqual({
+      inputPerMillion: 2,
+      cachedInputPerMillion: 0.1,
+      outputPerMillion: 10,
+    });
+    expect(computeCodexCostUsd(id, 1_000_000, 250_000, 100_000)).toBeCloseTo(
+      2 * 0.75 + 0.1 * 0.25 + 10 * 0.1,
+      8,
+    );
+  });
+
+  test("exposes low through max without an off level", () => {
+    expect(reasoningCapability("codex", id)).toEqual({
+      supported: true,
+      levels: ["low", "medium", "high", "xhigh", "max"],
+      default: "medium",
+    });
+    expect(applyReasoningEffort("codex", id, "max")).toEqual({
+      kind: "codex-config",
+      config: { model_reasoning_effort: "max" },
+    });
+  });
+
+  test("seeds all four token classes with long-context tiers", () => {
+    const rows = buildModelsDevSeedRows(cache).filter(
+      (row) => row.provider === "codex" && row.model === id,
+    );
+    expect(Object.fromEntries(rows.map((row) => [row.tokenClass, row.pricePerMillionUsd]))).toEqual(
+      { input: 2, output: 10, cached_input: 0.1, cache_write: 2.5 },
+    );
+    expect(cache.openai.models[id].cost.tiers).toEqual([
+      {
+        input: 4,
+        output: 15,
+        cache_read: 0.2,
+        cache_write: 5,
+        tier: { type: "context", size: 272000 },
+      },
+    ]);
+  });
+
+  test("is available through the catalog and direct UI selector", () => {
+    const model = buildModelsCatalog(cache).openai?.models[id];
+    expect(model?.limit?.context).toBe(1_050_000);
+    expect(model?.cost).toMatchObject({ input: 2, output: 10 });
+    const option = modelGroupsForHarness("codex", undefined, undefined)
+      .flatMap((group) => group.models)
+      .find((entry) => entry.id === id);
+    expect(option?.label).toBe("GPT-6.1 Sol");
+    expect(option?.reasoningLevels).toEqual(["low", "medium", "high", "xhigh", "max"]);
+  });
+});

package/src/tests/codex-login.test.ts

@@ -197,6 +197,8 @@ describe("runCodexLogin", () => {
       })),
       store,
       loadAllSlots: mock(async () => []),
+      clearAuthBench: mock(async () => false),
+      readAuthFence: mock(async () => 0),
       log: () => {},
       error: () => {},
       exit: () => {},
@@ -229,6 +231,8 @@ describe("runCodexLogin", () => {
         { slot: 0, creds: { access: "", refresh: "", expires: 0, accountId: "" } },
         { slot: 1, creds: { access: "", refresh: "", expires: 0, accountId: "" } },
       ]),
+      clearAuthBench: mock(async () => false),
+      readAuthFence: mock(async () => 0),
       log: () => {},
       error: () => {},
       exit: () => {},
@@ -285,6 +289,8 @@ describe("runCodexLogin", () => {
       })),
       store,
       loadAllSlots: mock(async () => []),
+      clearAuthBench: mock(async () => false),
+      readAuthFence: mock(async () => 0),
       log: () => {},
       error: () => {},
       exit: () => {},
@@ -322,4 +328,114 @@ describe("runCodexLogin", () => {
     expect(error).toHaveBeenCalledWith(expect.stringContaining("All credential slots"));
     expect(exit).toHaveBeenCalledWith(1);
   });
+
+  it("lifts the auth-failure bench on the re-logged key after storing", async () => {
+    const calls: string[] = [];
+    const store = mock(async () => {
+      calls.push("store");
+    });
+    const clearAuthBench = mock(
+      async (_apiUrl: string, _apiKey: string, keySuffix: string, slot: number, fence: number) => {
+        calls.push(`clear:${keySuffix}@${slot} fence ${fence}`);
+        return true;
+      },
+    );
+    const readAuthFence = mock(async () => {
+      calls.push("read-fence");
+      return 7;
+    });
+
+    await runCodexLogin([], {
+      resolveConfig: async () => ({
+        apiUrl: "http://localhost:3013",
+        apiKey: "example-test-key",
+        slot: 2,
+      }),
+      login: mock(async () => ({
+        access: "at_test",
+        refresh: "rt_test",
+        expires: Date.now() + 3600000,
+        accountId: "acc-test-d3Ove",
+      })),
+      store,
+      loadAllSlots: mock(async () => []),
+      clearAuthBench,
+      readAuthFence,
+      log: () => {},
+      error: () => {},
+      exit: () => {},
+    });
+
+    // at_test has no chatgpt_user_id claim, so the suffix falls back to accountId.
+    // The fence is read BEFORE the credential write, so failures on the fresh login survive.
+    expect(calls).toEqual(["read-fence", "store", "clear:d3Ove@2 fence 7"]);
+  });
+
+  it("skips the unfenced clear when the fence cannot be read", async () => {
+    const error = mock(() => {});
+    const exit = mock(() => {});
+    const store = mock(async () => {});
+    const clearAuthBench = mock(async () => true);
+
+    await runCodexLogin([], {
+      resolveConfig: async () => ({
+        apiUrl: "http://localhost:3013",
+        apiKey: "example-test-key",
+        slot: 2,
+      }),
+      login: mock(async () => ({
+        access: "at_test",
+        refresh: "rt_test",
+        expires: Date.now() + 3600000,
+        accountId: "acc-test-d3Ove",
+      })),
+      store,
+      loadAllSlots: mock(async () => []),
+      clearAuthBench,
+      readAuthFence: mock(async () => {
+        throw new Error("keys/available returned 503");
+      }),
+      log: () => {},
+      error,
+      exit,
+    });
+
+    expect(store).toHaveBeenCalled();
+    expect(clearAuthBench).not.toHaveBeenCalled();
+    expect(error).toHaveBeenCalledWith(expect.stringContaining("keys/available returned 503"));
+    expect(exit).not.toHaveBeenCalled();
+  });
+
+  it("keeps a successful login when lifting the bench fails", async () => {
+    const error = mock(() => {});
+    const exit = mock(() => {});
+
+    await runCodexLogin([], {
+      resolveConfig: async () => ({
+        apiUrl: "http://localhost:3013",
+        apiKey: "example-test-key",
+        slot: 2,
+      }),
+      login: mock(async () => ({
+        access: "at_test",
+        refresh: "rt_test",
+        expires: Date.now() + 3600000,
+        accountId: "acc-test-d3Ove",
+      })),
+      store: mock(async () => {}),
+      loadAllSlots: mock(async () => []),
+      clearAuthBench: mock(async () => {
+        throw new Error("clear-rate-limit returned 500");
+      }),
+      readAuthFence: mock(async () => 0),
+      log: () => {},
+      error,
+      exit,
+    });
+
+    expect(error).toHaveBeenCalledWith(
+      expect.stringContaining("could not lift the auth-failure bench"),
+    );
+    expect(exit).not.toHaveBeenCalled();
+  });
 });

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

@@ -8,13 +8,12 @@ import {
 } from "../utils/context-window";
 
 describe("getContextWindowSize", () => {
-  test("returns 1M for fable and mythos models", () => {
+  // Windows come from the model catalog: a model the catalog lacks (mythos is
+  // not on models.dev) gets the 200K default until an overlay row adds it.
+  test("returns 1M for fable models", () => {
     expect(getContextWindowSize("claude-fable-5-1")).toBe(1_000_000);
-    expect(getContextWindowSize("claude-mythos-5-1")).toBe(1_000_000);
     expect(getContextWindowSize("claude-fable-5")).toBe(1_000_000);
-    expect(getContextWindowSize("claude-mythos-5")).toBe(1_000_000);
     expect(getContextWindowSize("fable")).toBe(1_000_000);
-    expect(getContextWindowSize("mythos")).toBe(1_000_000);
   });
 
   test("returns 1M for opus models", () => {
@@ -38,8 +37,11 @@ describe("getContextWindowSize", () => {
     expect(getContextWindowSize("haiku")).toBe(200_000);
   });
 
+  test("reads OpenAI windows from the catalog", () => {
+    expect(getContextWindowSize("gpt-5")).toBe(400_000);
+  });
+
   test("returns 200K default for unknown models", () => {
-    expect(getContextWindowSize("gpt-5")).toBe(200_000);
     expect(getContextWindowSize("unknown-model")).toBe(200_000);
     expect(getContextWindowSize("")).toBe(200_000);
   });

package/src/tests/credential-exhaustion-policy.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { fetchResolvedEnv } from "../commands/runner";
 import {
   type ModelFamily,
@@ -18,6 +18,9 @@ describe("resolveCredentialPools — model window exhaustion policy", () => {
   let apiUrl: string;
   const earliestResetAt = "2026-09-27T00:00:00.000Z";
   let configResponse: { configs: Array<{ key: string; value: string }> } = { configs: [] };
+  /** Blocked indices returned for `model=fable`. The seat tests below override it. */
+  const windowOnlyFableBlocks = { modelBlockedIndices: [0, 1], seatBlockedIndices: [] as number[] };
+  let fableBlocks = windowOnlyFableBlocks;
 
   beforeAll(() => {
     server = Bun.serve({
@@ -34,8 +37,9 @@ describe("resolveCredentialPools — model window exhaustion policy", () => {
               success: true,
               availableIndices: [],
               totalKeys: 2,
-              modelBlockedIndices: [0, 1],
-              earliestModelResetAt: earliestResetAt,
+              modelBlockedIndices: fableBlocks.modelBlockedIndices,
+              seatBlockedIndices: fableBlocks.seatBlockedIndices,
+              earliestModelResetAt: fableBlocks.modelBlockedIndices.length ? earliestResetAt : null,
             });
           }
           // sonnet (or any other model / no model): pool is fully available.
@@ -175,4 +179,115 @@ describe("resolveCredentialPools — model window exhaustion policy", () => {
     expect(selections.length).toBe(1);
     expect(selections[0]!.isRateLimitFallback).toBe(false);
   });
+
+  describe("seat blocks", () => {
+    const fableTask = {
+      apiUrl: "",
+      apiKey: "key",
+      provider: "claude",
+      model: "claude-fable-5-1",
+      enforceModelCapacity: true,
+    };
+
+    afterEach(() => {
+      fableBlocks = windowOnlyFableBlocks;
+    });
+
+    test("default policy: throws and names seat blocks and window blocks", async () => {
+      fableBlocks = { modelBlockedIndices: [0], seatBlockedIndices: [1] };
+      const env: Record<string, string | undefined> = { CLAUDE_CODE_OAUTH_TOKEN: "tok-a,tok-b" };
+      const err = await resolveCredentialPools(env, { ...fableTask, apiUrl }).catch((e) => e);
+      expect(err).toBeInstanceOf(ModelWindowExhaustedError);
+      const typed = err as ModelWindowExhaustedError;
+      expect(typed.seatBlockedCount).toBe(1);
+      expect(typed.modelBlockedCount).toBe(1);
+      expect(typed.message).toBe(
+        "No CLAUDE_CODE_OAUTH_TOKEN key can run Fable: 1 keys are on a seat without Fable, 1 keys have the Fable window exhausted until 2026-09-27T00:00:00.000Z. Re-dispatch with another model or modelTier.",
+      );
+    });
+
+    test("MODEL_WINDOW_EXHAUSTED_POLICY=fallback: seat blocks still throw", async () => {
+      fableBlocks = { modelBlockedIndices: [], seatBlockedIndices: [0, 1] };
+      const env: Record<string, string | undefined> = {
+        CLAUDE_CODE_OAUTH_TOKEN: "tok-a,tok-b",
+        MODEL_WINDOW_EXHAUSTED_POLICY: "fallback",
+      };
+      const err = await resolveCredentialPools(env, { ...fableTask, apiUrl }).catch((e) => e);
+      expect(err).toBeInstanceOf(ModelWindowExhaustedError);
+      const typed = err as ModelWindowExhaustedError;
+      expect(typed.earliestResetAt).toBeNull();
+      expect(typed.message).toBe(
+        "No CLAUDE_CODE_OAUTH_TOKEN key can run Fable: 2 keys are on a seat without Fable, 0 keys have the Fable window exhausted. Re-dispatch with another model or modelTier.",
+      );
+    });
+
+    test("MODEL_WINDOW_EXHAUSTED_POLICY=fallback: window blocks alone still pick a key", async () => {
+      const env: Record<string, string | undefined> = {
+        CLAUDE_CODE_OAUTH_TOKEN: "tok-a,tok-b",
+        MODEL_WINDOW_EXHAUSTED_POLICY: "fallback",
+      };
+      const selections = await resolveCredentialPools(env, { ...fableTask, apiUrl });
+      expect(selections).toHaveLength(1);
+      expect(selections[0]!.isRateLimitFallback).toBe(true);
+    });
+
+    test("MODEL_WINDOW_EXHAUSTED_POLICY=fallback: a mixed pool picks the Fable-capable key", async () => {
+      fableBlocks = { modelBlockedIndices: [1], seatBlockedIndices: [0] };
+      const env: Record<string, string | undefined> = {
+        CLAUDE_CODE_OAUTH_TOKEN: "tok-a,tok-b",
+        MODEL_WINDOW_EXHAUSTED_POLICY: "fallback",
+      };
+      const selections = await resolveCredentialPools(env, { ...fableTask, apiUrl });
+      expect(selections).toHaveLength(1);
+      expect(selections[0]!.index).toBe(1);
+      expect(selections[0]!.isRateLimitFallback).toBe(true);
+      expect(env.CLAUDE_CODE_OAUTH_TOKEN).toBe("tok-b");
+    });
+
+    test("MODEL_WINDOW_EXHAUSTED_POLICY=fallback: every key without a seat block stays reachable", async () => {
+      fableBlocks = { modelBlockedIndices: [1, 2], seatBlockedIndices: [0] };
+      const picked = new Set<number>();
+      for (let run = 0; run < 50; run++) {
+        const env: Record<string, string | undefined> = {
+          CLAUDE_CODE_OAUTH_TOKEN: "tok-a,tok-b,tok-c",
+          MODEL_WINDOW_EXHAUSTED_POLICY: "fallback",
+        };
+        const selections = await resolveCredentialPools(env, { ...fableTask, apiUrl });
+        picked.add(selections[0]!.index);
+      }
+      expect([...picked].sort()).toEqual([1, 2]);
+    });
+
+    test("default policy: a key-wide rate limit next to a seat block picks the other key", async () => {
+      fableBlocks = { modelBlockedIndices: [], seatBlockedIndices: [0] };
+      const env: Record<string, string | undefined> = { CLAUDE_CODE_OAUTH_TOKEN: "tok-a,tok-b" };
+      const selections = await resolveCredentialPools(env, { ...fableTask, apiUrl });
+      expect(selections[0]!.index).toBe(1);
+      expect(selections[0]!.isRateLimitFallback).toBe(true);
+    });
+
+    test("a taskless configuration load never throws on seat blocks", async () => {
+      fableBlocks = { modelBlockedIndices: [], seatBlockedIndices: [0, 1] };
+      const env: Record<string, string | undefined> = { CLAUDE_CODE_OAUTH_TOKEN: "tok-a,tok-b" };
+      const selections = await resolveCredentialPools(env, {
+        ...fableTask,
+        apiUrl,
+        enforceModelCapacity: undefined,
+      });
+      expect(selections).toHaveLength(1);
+      expect(selections[0]!.seatBlockedIndices).toEqual([0, 1]);
+    });
+
+    test("a sonnet task on a seat-blocked Fable pool picks a key", async () => {
+      fableBlocks = { modelBlockedIndices: [], seatBlockedIndices: [0, 1] };
+      const env: Record<string, string | undefined> = { CLAUDE_CODE_OAUTH_TOKEN: "tok-a,tok-b" };
+      const selections = await resolveCredentialPools(env, {
+        ...fableTask,
+        apiUrl,
+        model: "claude-sonnet-5",
+      });
+      expect(selections).toHaveLength(1);
+      expect(selections[0]!.isRateLimitFallback).toBe(false);
+    });
+  });
 });