@intentic/sandbox-contract 1.344.0 → 1.346.0

package/src/models/plan-pools.test.ts

@@ -1,13 +1,18 @@
 import {
+    answerCovers,
     bindingWindow,
     currentWindows,
     gatesModel,
     gatingWindows,
-    headroomState,
+    judgedReading,
+    fleetCapacity,
+    readingHeadroom,
     preferredAccount,
     refusalVerdict,
+    refusedPoolReset,
     roomiestAccount,
     scopedWindow,
+    uncoveredModels,
     serviceState,
     serviceStates,
     windowLive,
@@ -155,14 +160,14 @@ const at = (measuredAt: number, ...windows: UsageWindow[]): AccountUsage => ({ w
 const refusal = (over: Partial<ProviderRefusal> & Pick<ProviderRefusal, "kind">): ProviderRefusal => ({ at: 1_000, message: "no.", ...over });
 
 test("spent is the contract's one line: 99.5% still has room, 100% is spent until its last full pool reopens", () => {
-    expect(headroomState(usage(window({ kind: "five_hour", utilization: 99.5 })))).toEqual({ kind: "ready", room: 0.5 });
+    expect(readingHeadroom(usage(window({ kind: "five_hour", utilization: 99.5 })))).toEqual({ kind: "ready", room: 0.5 });
     expect(
-        headroomState(usage(window({ kind: "five_hour", utilization: 100, resetsAt: 50 }), window({ kind: "seven_day", utilization: 100, resetsAt: 900 }))),
+        readingHeadroom(usage(window({ kind: "five_hour", utilization: 100, resetsAt: 50 }), window({ kind: "seven_day", utilization: 100, resetsAt: 900 }))),
     ).toEqual({ kind: "spent", reopensAt: 900 });
-    expect(headroomState(usage(window({ kind: "five_hour", utilization: 100 })))).toEqual({ kind: "spent" });
-    expect(headroomState(undefined)).toEqual({ kind: "unknown" });
-    expect(headroomState(CLAUDE, { id: "claude-haiku-4-5" })).toEqual({ kind: "ready", room: 70 });
-    expect(headroomState(CLAUDE, { id: "claude-opus-4-6" })).toEqual({ kind: "spent" });
+    expect(readingHeadroom(usage(window({ kind: "five_hour", utilization: 100 })))).toEqual({ kind: "spent" });
+    expect(readingHeadroom(undefined)).toEqual({ kind: "unknown" });
+    expect(readingHeadroom(CLAUDE, { id: "claude-haiku-4-5" })).toEqual({ kind: "ready", room: 70 });
+    expect(readingHeadroom(CLAUDE, { id: "claude-opus-4-6" })).toEqual({ kind: "spent", pool: "Opus" });
 });
 
 // Anthropic reports whole percents: an account read at 100 kept serving turns for hours, so that reading is the line,
@@ -170,29 +175,29 @@ test("spent is the contract's one line: 99.5% still has room, 100% is spent unti
 test("a pool read at 100 in whole percents is at the line with no room, until a refusal proves it empty", () => {
     const week = window({ kind: "seven_day", utilization: 100, resetsAt: 900, rounded: true });
     const atLine = usage(window({ kind: "five_hour", utilization: 75, rounded: true }), week);
-    expect(headroomState(atLine)).toEqual({ kind: "ready", room: 0 });
-    expect(headroomState(atLine, { id: "claude-opus-5-5" })).toEqual({ kind: "ready", room: 0 });
+    expect(readingHeadroom(atLine)).toEqual({ kind: "ready", room: 0 });
+    expect(readingHeadroom(atLine, { id: "claude-opus-5-5" })).toEqual({ kind: "ready", room: 0 });
     // A precise 100 is still spent.
-    expect(headroomState(usage(window({ kind: "seven_day", utilization: 100, resetsAt: 900 })))).toEqual({ kind: "spent", reopensAt: 900 });
+    expect(readingHeadroom(usage(window({ kind: "seven_day", utilization: 100, resetsAt: 900 })))).toEqual({ kind: "spent", reopensAt: 900 });
     // The provider refused it: spent until the pool reopens, and a reading still at the line does not answer that.
     const facts = { account: "a", usage: { ...atLine, measuredAt: 2_000 } };
     const refused = refusal({ kind: "limit", account: "a" });
     expect(refusalVerdict(refused, [facts])).toBe("standing");
-    expect(serviceStates([facts], refused).get("a")).toEqual({ kind: "spent", reopensAt: 900 });
+    expect(serviceStates([facts], [refused]).get("a")).toEqual({ kind: "spent", reopensAt: 900 });
 });
 
 test("with no model named, an account is spent only when no model can run on it", () => {
     // A full Opus slice leaves every other model the room of the fullest pool still open.
-    expect(headroomState(CLAUDE)).toEqual({ kind: "ready", room: 70 });
-    expect(headroomState(GOOGLE)).toEqual({ kind: "ready", room: 73 });
+    expect(readingHeadroom(CLAUDE)).toEqual({ kind: "ready", room: 70 });
+    expect(readingHeadroom(GOOGLE)).toEqual({ kind: "ready", room: 73 });
     // A pool gating every model, full: nothing runs, and it reopens with that pool.
-    expect(headroomState(usage(window({ kind: "seven_day", utilization: 100, resetsAt: 900 }), window({ kind: "model:Opus", utilization: 10, gates: { models: ["Opus"] } })))).toEqual({
+    expect(readingHeadroom(usage(window({ kind: "seven_day", utilization: 100, resetsAt: 900 }), window({ kind: "model:Opus", utilization: 10, gates: { models: ["Opus"] } })))).toEqual({
         kind: "spent",
         reopensAt: 900,
     });
     // Every slice full: the first to reopen lets some model run again.
     expect(
-        headroomState(
+        readingHeadroom(
             usage(
                 window({ kind: "g", utilization: 100, resetsAt: 500, gates: { models: ["gemini"] } }),
                 window({ kind: "c", utilization: 100, resetsAt: 800, gates: { models: ["claude"] } }),
@@ -229,15 +234,15 @@ test("a revoked sign-in outranks a lost seat, which outranks a bench, whatever t
 
 test("a standing refusal blocks by its kind, and a limit refusal pins only the pool its model spends", () => {
     const facts = { account: "a", usage: CLAUDE };
-    expect(serviceState(facts, refusal({ kind: "auth" }))).toEqual({ kind: "blocked", fix: "reconnect", reason: "no." });
-    expect(serviceState(facts, refusal({ kind: "entitlement" }))).toEqual({ kind: "blocked", fix: "admin", reason: "no." });
+    expect(serviceState(facts, [refusal({ kind: "auth" })])).toEqual({ kind: "blocked", fix: "reconnect", reason: "no." });
+    expect(serviceState(facts, [refusal({ kind: "entitlement" })])).toEqual({ kind: "blocked", fix: "admin", reason: "no." });
     // Refused on Haiku: the 5-hour/weekly binding pool (seven_day, 30%) reads full, so Haiku is spent too.
-    expect(serviceState(facts, refusal({ kind: "limit", model: "claude-haiku-4-5" }), { id: "claude-haiku-4-5" })).toEqual({ kind: "spent" });
+    expect(serviceState(facts, [refusal({ kind: "limit", model: "claude-haiku-4-5" })], { id: "claude-haiku-4-5" })).toEqual({ kind: "spent" });
     // Refused on Opus: its own slice was already full; Haiku keeps the room its pools show.
-    expect(serviceState(facts, refusal({ kind: "limit", model: "claude-opus-4-6" }), { id: "claude-haiku-4-5" })).toEqual({ kind: "ready", room: 70 });
+    expect(serviceState(facts, [refusal({ kind: "limit", model: "claude-opus-4-6" })], { id: "claude-haiku-4-5" })).toEqual({ kind: "ready", room: 70 });
     // No reading at all: the refusal is the evidence, unless it was about another model.
-    expect(serviceState({ account: "a" }, refusal({ kind: "limit" }))).toEqual({ kind: "spent" });
-    expect(serviceState({ account: "a" }, refusal({ kind: "limit", model: "opus" }), { id: "haiku" })).toEqual({ kind: "unknown" });
+    expect(serviceState({ account: "a" }, [refusal({ kind: "limit" })])).toEqual({ kind: "spent" });
+    expect(serviceState({ account: "a" }, [refusal({ kind: "limit", model: "opus" })], { id: "haiku" })).toEqual({ kind: "unknown" });
 });
 
 test("a refusal stands until a later reading contradicts it, and never past its account's disconnection", () => {
@@ -258,17 +263,42 @@ test("a refusal stands until a later reading contradicts it, and never past its
     expect(refusalVerdict(refusal({ kind: "limit", account: "a" }), [])).toBe("standing");
 });
 
-// 2026-10-17: Codex's team credit ran out while its weekly pool read 57% on the shared credential.
-test("an allowance no reading measures stands against every reading, until the provider's own reset", () => {
+// An admin's allowance (Cursor's team spend limit) is one the refused account's own reading does not measure.
+test("an allowance no reading measures stands against its own account's reading, until the provider's own reset", () => {
     const room = at(Date.now() + 60_000, window({ kind: "seven_day", utilization: 43 }));
     const credit = refusal({ kind: "limit", unmetered: true, at: Date.now(), resetsAt: Math.floor(Date.now() / 1000) + 3_600 });
-    expect(refusalVerdict(credit, [{ account: "a", usage: room }, { account: "b", usage: room }])).toBe("standing");
-    expect(refusalVerdict({ ...credit, resetsAt: Math.floor(Date.now() / 1000) - 1 }, [{ account: "a", usage: room }, { account: "b", usage: room }])).toBe(
-        "answered",
-    );
+    expect(refusalVerdict({ ...credit, account: "a" }, [{ account: "a", usage: room }, { account: "b", usage: room }])).toBe("standing");
+    expect(refusalVerdict(credit, [{ account: "a", usage: room }])).toBe("standing");
+    expect(refusalVerdict({ ...credit, account: "a", resetsAt: Math.floor(Date.now() / 1000) - 1 }, [{ account: "a", usage: room }])).toBe("answered");
     expect(refusalVerdict({ ...credit, resetsAt: undefined }, [{ account: "a", usage: room }])).toBe("standing");
 });
 
+// 2026-10-19: one routed refusal ("try again at 1:53 PM", filed a day out, as an admin's credit) named no account and
+// held all three Codex accounts spent for that day, two free ones reading 0% of their month used among them.
+test("a nameless refusal over several accounts is answered by any of them reading room since, whatever it named", () => {
+    const filed = Date.parse("2026-10-19T13:53:35Z");
+    const now = Date.parse("2026-10-20T09:22:10Z");
+    const monthly = at(Date.parse("2026-10-20T09:22:03Z"), window({ kind: "monthly", label: "Monthly · all models", utilization: 0 }));
+    const fiveHour = at(Date.parse("2026-10-20T09:22:03Z"), window({ kind: "five_hour", utilization: 0 }), window({ kind: "seven_day", utilization: 0 }));
+    const accounts = [
+        { account: "free-1", usage: monthly },
+        { account: "free-2", usage: monthly },
+        { account: "team", usage: fiveHour },
+    ];
+    const codex = refusal({ kind: "limit", at: filed, model: "gpt-6.1-sol", resetsAt: Date.parse("2026-10-20T13:53:00Z") / 1000, unmetered: true });
+    expect(refusalVerdict(codex, accounts, now)).toBe("answered");
+    expect(Object.fromEntries(serviceStates(accounts, [codex], undefined, now))).toEqual({
+        "free-1": { kind: "ready", room: 100 },
+        "free-2": { kind: "ready", room: 100 },
+        team: { kind: "ready", room: 100 },
+    });
+    // Until one of them is read with room after it, it stands over all of them.
+    const before = accounts.map((entry) => ({ ...entry, usage: { ...entry.usage, measuredAt: filed - 1 } }));
+    expect(refusalVerdict(codex, before, now)).toBe("standing");
+    // And never past the instant the provider named.
+    expect(refusalVerdict(codex, before, Date.parse("2026-10-20T13:53:00Z"))).toBe("answered");
+});
+
 
 // Codex's usage endpoint kept reading room while every turn was refused "try again at 3:38 PM": the provider's own
 // instant is what ends the refusal, where it is known which account it refused.
@@ -282,14 +312,92 @@ test("a spent allowance with the provider's own reset stands until that instant,
     // Over several, the translator benches the one it refused and routes on, so another's room still answers it.
     expect(refusalVerdict(refusal(until), [{ account: "a", usage: room }, { account: "b", usage: room }], 9_999)).toBe("answered");
     // Spent until the instant the provider named, not the pool's own reset.
-    expect(serviceStates([{ account: "a", usage: room }], refusal({ ...until, account: "a" }), undefined, 9_999).get("a")).toEqual({ kind: "spent", reopensAt: 10 });
+    expect(serviceStates([{ account: "a", usage: room }], [refusal({ ...until, account: "a" })], undefined, 9_999).get("a")).toEqual({ kind: "spent", reopensAt: 10 });
+});
+
+// 2026-10-20: a spent allowance the provider gave no instant for stood past the reset of the pool it was refused in, the
+// "back at" every surface showed, until the next reading landed (up to the daemon's 15-minute idle sweep).
+test("a spent allowance with no instant named is stamped with its pool's reset, and ends there everywhere at once", () => {
+    const reset = 10;
+    const filling = at(500, window({ kind: "five_hour", utilization: 96, resetsAt: reset }), window({ kind: "seven_day", utilization: 40, resetsAt: 900 }));
+    const accounts = [{ account: "a", usage: filling }];
+    const spent = refusal({ kind: "limit", account: "a", model: "gpt-6.1-sol" });
+    expect(refusedPoolReset(spent, accounts)).toBe(reset);
+    const filed = { ...spent, poolResetsAt: reset };
+    expect(refusalVerdict(filed, accounts, reset * 1000 - 1)).toBe("standing");
+    expect(serviceStates(accounts, [filed], undefined, reset * 1000 - 1).get("a")).toEqual({ kind: "spent", reopensAt: reset });
+    expect(refusalVerdict(filed, accounts, reset * 1000)).toBe("answered");
+    // Even once the reading has lapsed that pool, so the weekly one binds: the stamp, not the reading, says when.
+    const lapsed = at(500, window({ kind: "five_hour", utilization: 0, lapsedAt: reset }), window({ kind: "seven_day", utilization: 40, resetsAt: 900 }));
+    expect(refusedPoolReset(spent, [{ account: "a", usage: lapsed }])).toBe(900);
+    expect(refusalVerdict(filed, [{ account: "a", usage: lapsed }], reset * 1000)).toBe("answered");
+    expect(serviceStates([{ account: "a", usage: lapsed }], [filed], undefined, reset * 1000).get("a")).toEqual({ kind: "ready", room: 60 });
+});
+
+// 2026-10-21: Claude refused at 5h 98% and weekly 97% (rounded) with no time named, so the refusal was stamped with the
+// five-hour reset, the fullest pool then. Once that window reopened the weekly pool read 100, and the passed stamp ended
+// the refusal anyway: a rounded 100 is no proof of empty, so the account read ready with no room and every turn let
+// through was refused again. A stamp ends the refusal where nothing read since says otherwise, never over a reading.
+test("a stamped reset ends a refusal only where no reading since it says the pool is still at the line", () => {
+    const fiveHourReset = 1_800_000_000;
+    const weeklyReset = 1_800_259_200;
+    const refusedIn = at(
+        1_799_989_000_000,
+        window({ kind: "five_hour", utilization: 98, rounded: true, resetsAt: fiveHourReset }),
+        window({ kind: "seven_day", utilization: 97, rounded: true, resetsAt: weeklyReset }),
+    );
+    const spent = refusal({ kind: "limit", account: "a", at: 1_799_990_000_000 });
+    expect(refusedPoolReset(spent, [{ account: "a", usage: refusedIn }])).toBe(fiveHourReset);
+    const stamped = { ...spent, poolResetsAt: fiveHourReset };
+    const now = (fiveHourReset + 700) * 1000;
+    const weeklyFull = at(
+        (fiveHourReset + 600) * 1000,
+        window({ kind: "five_hour", utilization: 4, rounded: true, resetsAt: fiveHourReset + 18_000 }),
+        window({ kind: "seven_day", utilization: 100, rounded: true, resetsAt: weeklyReset }),
+    );
+    const unstampedVerdict = serviceStates([{ account: "a", usage: weeklyFull }], [spent], undefined, now).get("a");
+    expect(unstampedVerdict).toEqual({ kind: "spent", reopensAt: weeklyReset });
+    expect(serviceStates([{ account: "a", usage: weeklyFull }], [stamped], undefined, now).get("a")).toEqual(unstampedVerdict);
+    expect(fleetCapacity([{ account: "a", usage: weeklyFull }], [stamped], undefined, now)).toMatchObject({ kind: "spent", reopensAt: weeklyReset });
+    // Nothing read since the stamp: it ends there. Read with room since: over.
+    expect(serviceStates([{ account: "a", usage: refusedIn }], [stamped], undefined, now).get("a")).toEqual({ kind: "ready", room: 2 });
+    const roomSince = at((fiveHourReset + 600) * 1000, window({ kind: "five_hour", utilization: 4, resetsAt: fiveHourReset + 18_000 }), window({ kind: "seven_day", utilization: 60, resetsAt: weeklyReset }));
+    expect(refusalVerdict(stamped, [{ account: "a", usage: roomSince }], now)).toBe("answered");
+});
+
+test("the stamp is the refused account's pool, or the soonest of any where the refusal named none", () => {
+    const soon = at(500, window({ kind: "five_hour", utilization: 96, resetsAt: 10 }));
+    const later = at(500, window({ kind: "five_hour", utilization: 96, resetsAt: 50 }));
+    const accounts = [{ account: "b", usage: later }, { account: "a", usage: soon }];
+    expect(refusedPoolReset(refusal({ kind: "limit" }), accounts)).toBe(10);
+    expect(refusedPoolReset(refusal({ kind: "limit", account: "b" }), accounts)).toBe(50);
+    // The pool the model spends, not the account's fullest.
+    const opus = at(500, window({ kind: "five_hour", utilization: 20, resetsAt: 10 }), window({ kind: "model:Opus", label: "Opus", utilization: 99, resetsAt: 70, gates: { models: ["Opus"] } }));
+    expect(refusedPoolReset(refusal({ kind: "limit", model: "claude-opus-4-6" }), [{ account: "a", usage: opus }])).toBe(70);
+    expect(refusedPoolReset(refusal({ kind: "limit", model: "claude-haiku-4-5" }), [{ account: "a", usage: opus }])).toBe(10);
+});
+
+test("nothing is stamped where a pool's reset cannot speak for the refusal", () => {
+    const reopening = at(500, window({ kind: "five_hour", utilization: 96, resetsAt: 10 }));
+    // A reading older than the window it was refused in: that reset was over before the refusal came.
+    expect(refusedPoolReset(refusal({ kind: "limit", at: 20_000 }), [{ account: "a", usage: reopening }])).toBeUndefined();
+    expect(refusedPoolReset(refusal({ kind: "limit" }), [{ account: "a", usage: at(500, window({ kind: "monthly", utilization: 96 })) }])).toBeUndefined();
+    expect(refusedPoolReset(refusal({ kind: "limit" }), [{ account: "a" }])).toBeUndefined();
+    expect(refusedPoolReset(refusal({ kind: "limit", account: "gone" }), [{ account: "a", usage: reopening }])).toBeUndefined();
+    // The provider's own instant, an allowance no reading measures, a person's mark, and any refusal but a spent allowance.
+    expect(refusedPoolReset(refusal({ kind: "limit", resetsAt: 5 }), [{ account: "a", usage: reopening }])).toBeUndefined();
+    expect(refusedPoolReset(refusal({ kind: "limit", unmetered: true }), [{ account: "a", usage: reopening }])).toBeUndefined();
+    expect(refusedPoolReset(refusal({ kind: "limit", byHand: true }), [{ account: "a", usage: reopening }])).toBeUndefined();
+    expect(refusedPoolReset(refusal({ kind: "entitlement" }), [{ account: "a", usage: reopening }])).toBeUndefined();
+    // And a refusal filed unstamped keeps standing until a reading answers it, as before.
+    expect(refusalVerdict(refusal({ kind: "limit", account: "a" }), [{ account: "a", usage: reopening }], 9e12)).toBe("standing");
 });
 
 test("a provider's accounts are judged together: a standing refusal lands only on the account it names", () => {
     const room = at(500, window({ kind: "five_hour", utilization: 40 }));
-    const states = serviceStates([{ account: "a", usage: room }, { account: "b", usage: room }], refusal({ kind: "entitlement", account: "a" }));
+    const states = serviceStates([{ account: "a", usage: room }, { account: "b", usage: room }], [refusal({ kind: "entitlement", account: "a" })]);
     expect(Object.fromEntries(states)).toEqual({ a: { kind: "blocked", fix: "admin", reason: "no." }, b: { kind: "ready", room: 60 } });
-    const answered = serviceStates([{ account: "a", usage: at(2_000, window({ kind: "five_hour", utilization: 40 })) }], refusal({ kind: "limit", account: "a" }));
+    const answered = serviceStates([{ account: "a", usage: at(2_000, window({ kind: "five_hour", utilization: 40 })) }], [refusal({ kind: "limit", account: "a" })]);
     expect(answered.get("a")).toEqual({ kind: "ready", room: 60 });
 });
 
@@ -310,7 +418,7 @@ test("each account answers to the newest refusal on file that still stands over
         b: { kind: "blocked", fix: "reconnect", reason: "no." },
     });
     // Only the provider's last one: the first account is back at the line, no room but not proven spent.
-    expect(serviceStates(accounts, elsewhere, undefined, 9_999).get("a")).toEqual({ kind: "ready", room: 0 });
+    expect(serviceStates(accounts, [elsewhere], undefined, 9_999).get("a")).toEqual({ kind: "ready", room: 0 });
     // Past the instant the provider named, its refusal is over and the reading speaks alone.
     expect(serviceStates(accounts, [elsewhere, own], undefined, 20_000).get("a")).toEqual({ kind: "ready", room: 0 });
     // A newer refusal on the same account outranks the older one.
@@ -340,3 +448,138 @@ test("an account at the line is tried after an unmeasured one and before a spent
     expect(roomiestAccount([entry("line", atLine), entry("spent", { kind: "spent" })])).toBeUndefined();
     expect(roomiestAccount([entry("line", atLine), entry("low", { kind: "ready", room: 2 })])?.id).toBe("low");
 });
+
+// A reading covers what its pools gate, and nothing more: a model no pool names is unknown, never covered by the rest.
+test("names the served models no pool covers, and none when a pool gates every model", () => {
+    const sliced = usage(window({ kind: "google:3p-weekly", utilization: 100, gates: { models: ["claude", "gpt"] } }));
+    expect(uncoveredModels(sliced.windows, [{ id: "claude-opus-4-6-thinking" }, { id: "gemini-3.8-flash-high" }, { id: "gpt-oss-120b-medium" }])).toEqual([
+        "gemini-3.8-flash-high",
+    ]);
+    expect(uncoveredModels([window({ kind: "five_hour" })], [{ id: "opus" }, { id: "sonnet" }])).toEqual([]);
+    // A pool gated `none` is shown, never a cover.
+    expect(uncoveredModels([window({ kind: "surface:web", gates: "none" })], [{ id: "opus" }])).toEqual(["opus"]);
+});
+
+// 2026-10-19: Google's summary stopped naming the Gemini pool, and every account read spent off its full Claude pool
+// while its Gemini models served.
+test("an account whose only named pools are full, with models no pool covers, is unknown rather than spent", () => {
+    const thirdPartySpent = window({ kind: "google:3p-weekly", utilization: 100, resetsAt: 9_000, gates: { models: ["claude", "gpt"] } });
+    expect(readingHeadroom({ ...usage(thirdPartySpent), uncovered: ["gemini-3.8-flash-high"] })).toEqual({ kind: "unknown" });
+    // Without the gap it is the spent account it always was, and a model the full pool gates is spent either way.
+    expect(readingHeadroom(usage(thirdPartySpent))).toEqual({ kind: "spent", reopensAt: 9_000 });
+    expect(readingHeadroom({ ...usage(thirdPartySpent), uncovered: ["gemini-3.8-flash-high"] }, { id: "claude-opus-4-6-thinking" })).toEqual({
+        kind: "spent",
+        reopensAt: 9_000,
+    });
+    // A full pool gating every model still holds every model, covered or not.
+    expect(readingHeadroom({ ...usage(window({ kind: "seven_day", utilization: 100, resetsAt: 7_000 })), uncovered: ["x"] })).toEqual({
+        kind: "spent",
+        reopensAt: 7_000,
+    });
+});
+
+test("a reading contradicted by an answered turn holds that model's full pools at the line, not spent", () => {
+    const full = usage(window({ kind: "google:gemini-weekly", utilization: 100, resetsAt: 9_000, gates: { models: ["gemini"] } }));
+    const contradicted: AccountUsage = { ...full, contradicted: { at: 1, model: "gemini-3.8-flash-high" } };
+    expect(readingHeadroom(contradicted, { id: "gemini-3.8-flash-high" })).toEqual({ kind: "ready", room: 0 });
+    expect(readingHeadroom(contradicted)).toEqual({ kind: "ready", room: 0 });
+    // Another family's pool is not what the turn proved anything about.
+    const other: AccountUsage = { ...full, contradicted: { at: 1, model: "claude-opus-4-6-thinking" } };
+    expect(readingHeadroom(other, { id: "gemini-3.8-flash-high" })).toEqual({ kind: "spent", reopensAt: 9_000 });
+});
+
+test("a pool the provider stopped reporting is dropped once its window closes, not kept at a floor", () => {
+    const missing = window({ kind: "google:gemini-weekly", utilization: 60, resetsAt: 1_000, missingSince: 500 });
+    const live = window({ kind: "google:3p-weekly", utilization: 20, resetsAt: 9_000 });
+    expect(currentWindows(usage(missing, live), 2_000_000)).toEqual([live]);
+    expect(currentWindows(usage(missing, live), 900_000)).toEqual([missing, live]);
+});
+
+// The one rule the daemon's verdict and the editor's live re-reading both judge a standing refusal by (2026-10-20: the
+// editor drew "spent until 19:55", the pinned pool's own reset, over a daemon verdict of 15:53).
+test("a standing refusal pins the pool its model spends, reopening when the provider said, for every surface alike", () => {
+    const reading = at(2_000, window({ kind: "five_hour", utilization: 0, resetsAt: 20_000 }), window({ kind: "seven_day", utilization: 0, resetsAt: 600_000 }));
+    const said = refusal({ kind: "limit", model: "gpt-6.1-sol", resetsAt: 9_000 });
+    expect(judgedReading(reading, [said])?.windows.map((entry) => [entry.kind, entry.utilization, entry.resetsAt])).toEqual([
+        ["five_hour", 100, 9_000],
+        ["seven_day", 0, 600_000],
+    ]);
+    expect(serviceState({ account: "a", usage: reading }, [said], undefined, 0)).toEqual({ kind: "spent", reopensAt: 9_000 });
+    // Where it named no instant, the pinned pool keeps its own reset, and that is when it reopens.
+    expect(serviceState({ account: "a", usage: reading }, [{ ...said, resetsAt: undefined }], undefined, 0)).toEqual({ kind: "spent", reopensAt: 20_000 });
+    // No reading at all (a plan that publishes none): the refusal is a pool of its own, for its own model and no other's.
+    expect(judgedReading(undefined, [said])?.windows).toEqual([
+        { kind: "refused:gpt-6.1-sol", label: "GPT 6.1 Sol", utilization: 100, gates: { models: ["gpt-6.1-sol"] }, resetsAt: 9_000 },
+    ]);
+    expect(serviceState({ account: "a" }, [said], undefined, 0)).toEqual({ kind: "spent", reopensAt: 9_000, pool: "GPT 6.1 Sol" });
+    expect(serviceState({ account: "a" }, [said], { id: "gpt-6-luna" }, 0)).toEqual({ kind: "unknown" });
+});
+
+// 2026-10-09/10-20: a routed model's bench (model-cooldowns.json) and the provider's last refusal were two copies of one
+// refusal, and the picker greyed by one while the rail judged by the other. One ledger: every refusal standing over an
+// account is laid on its reading, so two models refused on two pools both read spent.
+test("every refusal standing over an account is laid on it, not only the provider's last", () => {
+    const reading = at(
+        500,
+        window({ kind: "five_hour", utilization: 10, resetsAt: 7_000 }),
+        window({ kind: "model:Opus", label: "Opus", utilization: 40, resetsAt: 8_000, gates: { models: ["opus"] } }),
+    );
+    const opus = refusal({ kind: "limit", account: "a", model: "claude-opus-5-5", at: 1_000 });
+    const sonnet = refusal({ kind: "limit", account: "a", model: "claude-sonnet-5", at: 2_000, resetsAt: 7_000 });
+    const states = (model: string) => serviceStates([{ account: "a", usage: reading }], [opus, sonnet], { id: model }, 5_000).get("a");
+    expect(states("claude-opus-5-5")).toEqual({ kind: "spent", reopensAt: 8_000, pool: "Opus" });
+    expect(states("claude-sonnet-5")).toEqual({ kind: "spent", reopensAt: 7_000 });
+    // A spent allowance refused after a refused sign-in says the sign-in worked: the newest word on the account decides.
+    const revoked = refusal({ kind: "auth", account: "a", at: 1_500 });
+    expect(serviceStates([{ account: "a", usage: reading }], [revoked, sonnet], { id: "claude-sonnet-5" }, 5_000).get("a")).toEqual({ kind: "spent", reopensAt: 7_000 });
+});
+
+// 2026-10-17: a Kimi credential benched for thirty minutes, its five-hour window two hours from reopening, was re-run at
+// thirty minutes and refused again. A bench is a floor under the account's reopening, never the reopening itself.
+test("a translator bench lifts only once the pools it holds have reopened too", () => {
+    const full = at(500, window({ kind: "five_hour", utilization: 100, resetsAt: 9_000 }));
+    expect(serviceState({ account: "a", usage: full, cooling: { until: 2_000, reason: "429" } }, [], undefined, 1_000_000)).toEqual({
+        kind: "blocked",
+        fix: "wait",
+        reason: "429",
+        until: 9_000,
+    });
+});
+
+// The answer every gate, listing and picker reads (2026-10-13: Sol subagents spawned onto a Codex whose every account
+// was refused, while the picker greyed the row; 2026-10-19: Auto read the readings alone).
+test("a provider's capacity for a model is spent only when no account can serve it, and says when one is back", () => {
+    const room = at(5_000, window({ kind: "five_hour", utilization: 30, resetsAt: 9_000 }));
+    const accounts = [
+        { account: "a", usage: room },
+        { account: "b", usage: room },
+    ];
+    const a = refusal({ kind: "limit", account: "a", model: "sol", resetsAt: 8_000, at: 4_000 });
+    const b = refusal({ kind: "limit", account: "b", model: "sol", resetsAt: 7_000, at: 4_000 });
+    expect(fleetCapacity(accounts, [a, b], { id: "sol" }, 6_000_000)).toEqual({ kind: "spent", accounts: 2, reopensAt: 7_000, pool: undefined });
+    expect(fleetCapacity(accounts, [a], { id: "sol" }, 6_000_000)).toEqual({ kind: "serving", serving: 1, accounts: 2, roomMeasuredAt: 5_000 });
+    // An account nothing has measured may still answer: it keeps the model servable.
+    expect(fleetCapacity([...accounts, { account: "c" }], [a, b], { id: "sol" }, 6_000_000)).toEqual({ kind: "serving", serving: 1, accounts: 3, roomMeasuredAt: undefined });
+    // No account at all says nothing either way.
+    expect(fleetCapacity([], [a], { id: "sol" })).toEqual({ kind: "unknown" });
+    // A plan that publishes no reading (Cursor's) is spent for a model every account refused, and only that model.
+    const cursor = [{ account: "x" }, { account: "y" }];
+    const refused = [refusal({ kind: "limit", account: "x", model: "composer-2.5" }), refusal({ kind: "limit", account: "y", model: "composer-2.5" })];
+    expect(fleetCapacity(cursor, refused, { id: "composer-2.5" }, 2_000).kind).toBe("spent");
+    expect(fleetCapacity(cursor, refused, { id: "gpt-6" }, 2_000).kind).toBe("serving");
+    // An account refused outright is blocked for every model.
+    expect(fleetCapacity([{ account: "x" }], [refusal({ kind: "entitlement", account: "x" })], { id: "gpt-6" }, 2_000).kind).toBe("spent");
+});
+
+test("an answer on one model covers another only where every pool the other spends gates it too", () => {
+    const codex = usage(window({ kind: "five_hour", utilization: 0 }), window({ kind: "seven_day", utilization: 0 }));
+    expect(answerCovers(codex, { id: "gpt-6-luna" }, { id: "gpt-6.1-sol" })).toBe(true);
+    // A plan with no entitlement to a model meters it by a pool of its own.
+    const free = usage(window({ kind: "monthly", utilization: 0 }), window({ kind: "entitlement:gpt-6.1-sol", utilization: 100, gates: { models: ["gpt-6.1-sol"] } }));
+    expect(answerCovers(free, { id: "gpt-6-luna" }, { id: "gpt-6.1-sol" })).toBe(false);
+    // Haiku's answer says nothing of Opus's own slice, and Opus's says everything of Haiku's pools.
+    expect(answerCovers(CLAUDE, { id: "claude-haiku-4-5" }, { id: "claude-opus-4-6" })).toBe(false);
+    expect(answerCovers(CLAUDE, { id: "claude-opus-4-6" }, { id: "claude-haiku-4-5" })).toBe(true);
+    // Nothing read proves nothing.
+    expect(answerCovers(undefined, { id: "gpt-6-luna" }, { id: "gpt-6.1-sol" })).toBe(false);
+});