@intentic/sandbox-contract 1.344.0 → 1.345.0

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

@@ -1,13 +1,17 @@
 import {
+    answerCovers,
     bindingWindow,
     currentWindows,
     gatesModel,
     gatingWindows,
-    headroomState,
+    pinRefused,
+    readingHeadroom,
     preferredAccount,
     refusalVerdict,
+    refusedHeadroom,
     roomiestAccount,
     scopedWindow,
+    uncoveredModels,
     serviceState,
     serviceStates,
     windowLive,
@@ -155,14 +159,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" });
 });
 
 // Anthropic reports whole percents: an account read at 100 kept serving turns for hours, so that reading is the line,
@@ -170,10 +174,10 @@ 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" });
@@ -183,16 +187,16 @@ test("a pool read at 100 in whole percents is at the line with no room, until a
 
 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"] } }),
@@ -258,17 +262,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.
@@ -340,3 +369,82 @@ 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(pinRefused(reading, said)?.windows.map((entry) => [entry.kind, entry.utilization, entry.resetsAt])).toEqual([
+        ["five_hour", 100, 9_000],
+        ["seven_day", 0, 600_000],
+    ]);
+    expect(refusedHeadroom(reading, said)).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(refusedHeadroom(reading, { ...said, resetsAt: undefined })).toEqual({ kind: "spent", reopensAt: 20_000 });
+    // No pool to pin: the refusal itself is the evidence for its own model, and none for another's.
+    expect(pinRefused(undefined, said)).toBeUndefined();
+    expect(refusedHeadroom(undefined, said)).toEqual({ kind: "spent", reopensAt: 9_000 });
+    expect(refusedHeadroom(undefined, said, { id: "gpt-6-luna" })).toEqual({ kind: "unknown" });
+    // The daemon's verdict is this rule.
+    expect(serviceState({ account: "a", usage: reading }, said, undefined, 0)).toEqual(refusedHeadroom(reading, said));
+});
+
+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);
+});

package/src/models/plan-pools.ts

@@ -47,6 +47,11 @@ const nameMatches = (name: string, model: ModelRef): boolean => {
 export const gatesModel = (gates: WindowGates, model: ModelRef): boolean =>
     gates === "all" ? true : gates === "none" ? false : gates.models.some((name) => nameMatches(name, model));
 
+// Served models no pool in `windows` gates: what a reading cannot say anything about. A pool gated `none` covers
+// nothing, and one gated `all` covers every model.
+export const uncoveredModels = (windows: readonly UsageWindow[], served: readonly ModelRef[]): string[] =>
+    served.filter((model) => !windows.some((window) => gatesModel(window.gates, model))).map((model) => model.id);
+
 // Pools that gate this model, or, with no model given, every pool that gates anything.
 export const gatingWindows = (usage: AccountUsage | undefined, model?: ModelRef): readonly UsageWindow[] =>
     (usage?.windows ?? []).filter((window) => (model === undefined ? window.gates !== "none" : gatesModel(window.gates, model)));
@@ -58,6 +63,17 @@ const fullest = (windows: readonly UsageWindow[]): UsageWindow | undefined =>
 // nothing was measured) — distinct from a measured 0%.
 export const bindingWindow = (usage: AccountUsage | undefined, model?: ModelRef): UsageWindow | undefined => fullest(gatingWindows(usage, model));
 
+/**
+ * Whether a turn answered on `served` proves `other` had room on this account too: every pool `other` spends gates
+ * `served` as well, so the answer went through each of them. False where nothing is read, and where `other` spends a pool
+ * of its own (Claude's Opus slice, a model the plan has no entitlement to), which another model's answer says nothing
+ * about. Codex meters every model from one allowance, so a Luna turn going through proves Sol's allowance open as well.
+ */
+export const answerCovers = (usage: AccountUsage | undefined, served: ModelRef, other: ModelRef): boolean => {
+    const pools = gatingWindows(usage, other);
+    return pools.length > 0 && pools.every((window) => gatesModel(window.gates, served));
+};
+
 // The model's own metered pool, by most specific name match; distinct from bindingWindow, which may answer with an
 // all-models pool. Two matches tied in specificity return undefined rather than guess.
 export const scopedWindow = (usage: AccountUsage | undefined, model: ModelRef): UsageWindow | undefined => {
@@ -160,12 +176,19 @@ const lapsedWindow = (window: UsageWindow, measuredAt: number): UsageWindow => {
 // while the weekly rows stayed, a partial card that reads as complete. The floor of 0 is what dropping it already meant
 // to every verdict (an absent pool binds nothing). A reading with no window still current says nothing about now and
 // answers none, so the account reads as unmeasured. Idempotent: a pool already lapsed stays as it is.
+// A pool the provider stopped reporting (`missingSince`) is dropped instead once its window closes: nothing will read it
+// again, so its floor of 0 would be a pool that is not there.
 export const currentWindows = (usage: AccountUsage, now: number): UsageWindow[] => {
     const live = (window: UsageWindow): boolean => window.lapsedAt === undefined && windowLive(window, usage.measuredAt, now);
     if (!usage.windows.some(live)) {
         return [];
     }
-    return usage.windows.map((window) => (window.lapsedAt !== undefined || live(window) ? window : lapsedWindow(window, usage.measuredAt)));
+    return usage.windows.flatMap((window) => {
+        if (window.lapsedAt !== undefined || live(window)) {
+            return [window];
+        }
+        return window.missingSince === undefined ? [lapsedWindow(window, usage.measuredAt)] : [];
+    });
 };
 
 // Whether an account can serve a turn: the one rule every picker and surface reads (AccountState). The daemon runs it and
@@ -188,10 +211,12 @@ export interface ServiceFacts {
 
 // A spent allowance is over once a reading with room lands after it; a refused credential once any reading does (the
 // token worked). Nothing a reading says answers an entitlement refusal: a seatless account authenticates and reads fine.
-// Nor does any reading answer an allowance it does not measure (`unmetered`: an admin's credit).
-const answers = (refusal: ProviderRefusal, facts: ServiceFacts): boolean => {
+// Nor does the refused account's own reading answer an allowance it does not measure (`unmetered`: an admin's credit).
+// `measured` says whether this reading can speak to the allowance at all: false for that account's own, true for any
+// account's where nothing says which one refused (refusalVerdict).
+const answers = (refusal: ProviderRefusal, facts: ServiceFacts, measured: boolean = refusal.unmetered !== true): boolean => {
     const measuredAt = facts.usage?.measuredAt;
-    if (refusal.kind === "entitlement" || refusal.unmetered === true || measuredAt === undefined || measuredAt <= refusal.at) {
+    if (refusal.kind === "entitlement" || !measured || measuredAt === undefined || measuredAt <= refusal.at) {
         return false;
     }
     if (refusal.kind === "auth") {
@@ -203,8 +228,9 @@ const answers = (refusal: ProviderRefusal, facts: ServiceFacts): boolean => {
 
 /**
  * How a provider's last refusal stands against everything read since, over every account the provider holds: `gone` once
- * the account it named is disconnected, `answered` once that account (or, for a refusal naming none, any account) has a
- * later reading that contradicts it, else `standing`. An empty list is one not loaded yet, so the refusal stands.
+ * the account it named is disconnected, `answered` once the instant it named has passed or once that account (or, for a
+ * refusal naming none, any account) has a later reading that contradicts it, else `standing`. An empty list is one not
+ * loaded yet, so the refusal stands.
  */
 export const refusalVerdict = (
     refusal: ProviderRefusal,
@@ -215,14 +241,24 @@ export const refusalVerdict = (
     if (refusal.account !== undefined && named.length === 0) {
         return accounts.length === 0 ? "standing" : "gone";
     }
-    // Where the provider named when to try again, and it is known which account it refused (it named one, or there is
-    // only one), its own words outrank a usage endpoint that kept showing room while it refused: over at that instant,
-    // and not before. A nameless refusal over several accounts is still answered by any of them reading room, since the
-    // translator benches the one it refused and routes on.
-    if (refusal.kind === "limit" && refusal.resetsAt !== undefined && (refusal.account !== undefined || accounts.length <= 1 || refusal.unmetered === true)) {
-        return refusal.resetsAt * 1000 <= now ? "answered" : "standing";
+    // The provider's own "try again at" is over at that instant, whichever account it refused.
+    if (refusal.kind === "limit" && refusal.resetsAt !== undefined && refusal.resetsAt * 1000 <= now) {
+        return "answered";
     }
-    return (refusal.account === undefined ? accounts : named).some((facts) => answers(refusal, facts)) ? "answered" : "standing";
+    // Where it is known which account it refused (it named one, or there is only one), the provider's own instant
+    // outranks a usage endpoint that kept showing room while it refused: over at that instant, and not before.
+    const known = refusal.account !== undefined || accounts.length <= 1;
+    if (refusal.kind === "limit" && refusal.resetsAt !== undefined && known) {
+        return "standing";
+    }
+    if (known) {
+        return (refusal.account === undefined ? accounts : named).some((facts) => answers(refusal, facts)) ? "answered" : "standing";
+    }
+    /* A nameless refusal over several accounts is one of them saying no, and nothing says which: the translator benches
+       the one it refused and routes on, so any of them reading room since answers it, whatever kind of allowance it was
+       and whatever instant it named. Held to its instant, or to an allowance no reading measures, one team account's
+       refusal held every Codex account spent for a day, the two free ones reading 0% used included (2026-10-19). */
+    return accounts.some((facts) => answers(refusal, facts, true)) ? "answered" : "standing";
 };
 
 // The account reopens for this question when the pools holding it shut do: all of them for a model's own question (or
@@ -234,41 +270,88 @@ const reopening = (full: readonly UsageWindow[], first: boolean): number | undef
 
 const spent = (reopensAt: number | undefined): AccountState => (reopensAt === undefined ? { kind: "spent" } : { kind: "spent", reopensAt });
 
+// A turn on the model this reading was contradicted for went through while the pool read full: the pool is at the line,
+// not proven empty, exactly as a rounded one is (provenFull).
+const answeredDespite = (usage: AccountUsage | undefined, window: UsageWindow): boolean =>
+    usage?.contradicted !== undefined && gatesModel(window.gates, { id: usage.contradicted.model });
+
+// The pools holding the account shut: for a model, every full pool it spends; with none, the full pools gating every
+// model, else every per-model slice once all of them are full; nothing while one is open.
+const holdingPools = (full: readonly UsageWindow[], open: readonly UsageWindow[], model: ModelRef | undefined): readonly UsageWindow[] => {
+    if (model !== undefined) {
+        return full;
+    }
+    const wholePlan = full.filter((window) => window.gates === "all");
+    if (wholePlan.length > 0) {
+        return wholePlan;
+    }
+    return open.length === 0 ? full : [];
+};
+
 /**
+ * What the polled reading ALONE says, never whether the account can serve: that is `serviceState`, which also reads the
+ * refusals on file, ask it through the daemon's `serviceability`/`allowanceWall` or the editor's `accountState`. A
+ * provider that rounds its percentages (Claude does, every pool) is never proven spent here, so a caller reading this
+ * as the verdict sees every spent account as open: a pick between two spent accounts re-booked a held turn for "now"
+ * that way (2026-10-19). Imported only by the few modules lint allows (.oxlintrc.json, no-restricted-imports), and was
+ * named `headroomState` until then.
+ *
  * The plan-limit half of the verdict, at the contract's one spent line. With a model, the pools that model spends: spent
  * once any is full, else the room the fullest leaves. With none, whether the account can serve SOME turn: spent once a
  * pool gating every model is full, or every per-model slice is; a full slice alone (Opus at 100%) leaves the other
  * models their room, which is then read off the fullest pool still open.
  */
-export const headroomState = (usage: AccountUsage | undefined, model?: ModelRef): AccountState => {
-    const windows = gatingWindows(usage, model);
+export const readingHeadroom = (usage: AccountUsage | undefined, model?: ModelRef): AccountState => {
+    const windows = gatingWindows(usage, model).map((window) => (answeredDespite(usage, window) ? { ...window, rounded: true } : window));
     if (windows.length === 0) {
         return { kind: "unknown" };
     }
     const full = windows.filter(provenFull);
     const open = windows.filter((window) => !provenFull(window));
-    if (model !== undefined || full.some((window) => window.gates === "all") || open.length === 0) {
-        const holding = model !== undefined ? full : full.some((window) => window.gates === "all") ? full.filter((window) => window.gates === "all") : full;
-        if (holding.length > 0) {
-            return spent(reopening(holding, model === undefined && !holding.some((window) => window.gates === "all")));
-        }
+    const holding = holdingPools(full, open, model);
+    if (holding.length === 0) {
+        return { kind: "ready", room: Math.max(0, SPENT_UTILIZATION - Math.max(...open.map((window) => window.utilization))) };
+    }
+    const sliced = model === undefined && !holding.some((window) => window.gates === "all");
+    // Every per-model slice this reading names is full, but it names none for some models the account serves: whether
+    // those can run is unknown, not spent. Reading the account spent on this is how every Google account read out of
+    // allowance while its Gemini models, whose pool the provider had stopped reporting, still served.
+    if (sliced && (usage?.uncovered?.length ?? 0) > 0) {
+        return { kind: "unknown" };
     }
-    return { kind: "ready", room: Math.max(0, SPENT_UTILIZATION - Math.max(...open.map((window) => window.utilization))) };
+    return spent(reopening(holding, sliced));
 };
 
-// A standing limit refusal reads its pool as full, since a polled reading freezes the moment a pool actually empties: the
-// pool the refused turn's model spends, else the one asked about, else the tightest. Never another model's allowance.
-const refusedPool = (usage: AccountUsage | undefined, refusal: ProviderRefusal, model: ModelRef | undefined): AccountState => {
-    const refusedModel = refusal.model === undefined ? model : { id: refusal.model };
-    const binding = bindingWindow(usage, refusedModel);
+/**
+ * A reading as a standing limit refusal leaves it, for every surface that draws or judges it: the pool the refused turn's
+ * model spends (else the one asked about, else the tightest) read full, since a polled reading freezes the moment a pool
+ * actually empties, and reopening when the provider said to try again, where it said, over whatever the polled pool last
+ * said. Never another model's allowance. The reading as it was where it has no such pool.
+ */
+export const pinRefused = (usage: AccountUsage | undefined, refusal: ProviderRefusal, model?: ModelRef): AccountUsage | undefined => {
+    const binding = bindingWindow(usage, refusal.model === undefined ? model : { id: refusal.model });
     if (usage === undefined || binding === undefined) {
+        return usage;
+    }
+    const pinned = (window: UsageWindow): UsageWindow =>
+        refusal.resetsAt === undefined ? pinnedFull(window) : { ...pinnedFull(window), resetsAt: refusal.resetsAt };
+    return { ...usage, windows: usage.windows.map((window) => (window === binding ? pinned(window) : window)) };
+};
+
+/**
+ * The plan-limit verdict on a reading a standing limit refusal covers (pinRefused), the one rule the daemon's verdict and
+ * the editor's live re-reading both judge by. Spent until the provider's own "try again at" where it named one: the
+ * editor once re-judged the pinned pool by its own reset alone, and drew "spent until 19:55" over a daemon verdict, and a
+ * model picker, both saying 15:53 (2026-10-20).
+ */
+export const refusedHeadroom = (usage: AccountUsage | undefined, refusal: ProviderRefusal, model?: ModelRef): AccountState => {
+    const pinned = pinRefused(usage, refusal, model);
+    if (pinned === usage) {
         // No pool to pin: the refusal itself is the evidence, unless it was about a different model than this question.
         const sameModel = refusal.model === undefined || model === undefined || refusal.model === model.id;
-        return sameModel ? spent(refusal.resetsAt) : headroomState(usage, model);
+        return sameModel ? spent(refusal.resetsAt) : readingHeadroom(usage, model);
     }
-    const pinned = usage.windows.map((window) => (window === binding ? pinnedFull(window) : window));
-    const state = headroomState({ ...usage, windows: pinned }, model);
-    // The provider's own "try again at" is when it reopens, over whatever the polled pool last said.
+    const state = readingHeadroom(pinned, model);
     return state.kind === "spent" && refusal.resetsAt !== undefined ? spent(refusal.resetsAt) : state;
 };
 
@@ -303,7 +386,7 @@ export const serviceState = (facts: ServiceFacts, refusal?: ProviderRefusal, mod
     if (cooling?.until !== undefined && cooling.until * 1000 > now) {
         return { kind: "blocked", fix: "wait", reason: cooling.reason ?? "cooling down", until: cooling.until };
     }
-    return refusal?.kind === "limit" ? refusedPool(facts.usage, refusal, model) : headroomState(facts.usage, model);
+    return refusal?.kind === "limit" ? refusedHeadroom(facts.usage, refusal, model) : readingHeadroom(facts.usage, model);
 };
 
 /** The refusals a provider's accounts are judged against: its last one, or every one on file (each account's own beside it). */

package/src/netd/generated/netd-wire.json

@@ -874,6 +874,31 @@
           "connected"
         ],
         "type": "object"
+      },
+      {
+        "description": "A line the person typed with echo off in one of the editor's own terminal sessions (`web-…`), after a\npassword-ish question: told once, on Enter, for the daemon to hand Passwords if the owner turned remembering on\nfor sandbox terminals (2026-10-19). Never logged on either side; netd keeps nothing of it after sending.",
+        "properties": {
+          "kind": {
+            "const": "hiddenLine",
+            "type": "string"
+          },
+          "prompt": {
+            "type": "string"
+          },
+          "session": {
+            "type": "string"
+          },
+          "value": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "kind",
+          "session",
+          "prompt",
+          "value"
+        ],
+        "type": "object"
       }
     ],
     "title": "ToNode"

package/src/netd/generated/wire.ts

@@ -73,7 +73,7 @@ export type TerminalPlan = { "plan": "session", name: string, createIn?: string,
 /**
  * Everything netd sends Node.
  */
-export type ToNode = { "kind": "ask", id: number, question: Question, } | { "kind": "answer", id: number, answer: NetdAnswer, } | { "kind": "refused", id: number, message: string, } | { "kind": "tunnel", connected: boolean, reason?: string, refused?: TunnelRefusal, };
+export type ToNode = { "kind": "ask", id: number, question: Question, } | { "kind": "answer", id: number, answer: NetdAnswer, } | { "kind": "refused", id: number, message: string, } | { "kind": "tunnel", connected: boolean, reason?: string, refused?: TunnelRefusal, } | { "kind": "hiddenLine", session: string, prompt: string, value: string, };
 
 /**
  * The ingress tunnel's door, the reachability grant it presents there, and the daemon's transfer routes it announces

package/src/policy/command-classes.ts

@@ -1,5 +1,5 @@
 import { HISTORY_ROOT, WORKSPACE_ROOT } from "@intentic/constants";
-import { type CommandClass, CommandClassSchema, type CommandLocus } from "../schemas/agent.js";
+import { type CommandClass, CommandClassSchema, type CommandLocus } from "../schemas/command-admission.js";
 import { SECRET_REFERENCE } from "../schemas/needs.js";
 import { inertRegions, isLive } from "../text/shell-regions.js";
 
@@ -413,7 +413,7 @@ const findAndXargsDeletes = (command: string): CommandSpan[] => [
 const POWERSHELL_RECURSE = String.raw`\s-r(?:e(?:c(?:u(?:r(?:s(?:e)?)?)?)?)?)?(?::\$true)?(?![\w-])`;
 const WINDOWS_RECURSIVE_DELETES = [
     new RegExp(String.raw`(?<![\w-])(?:Remove-Item|ri|rd|rmdir|del|erase)\b[^|;&\n]*?${POWERSHELL_RECURSE}`, "i"),
-    new RegExp(String.raw`(?<![\w-])rm\b[^|;&\n]*?\s-recurse(?![\w-])`, "i"),
+    /(?<![\w-])rm\b[^|;&\n]*?\s-recurse(?![\w-])/i,
     /(?<![\w-])(?:rd|rmdir|del|erase)\b[^|;&\n]*?\s\/s\b/i,
     /\[(?:System\.)?IO\.Directory\]::Delete\s*\([^)]*,\s*\$true\s*\)/i,
 ];

package/src/policy/keyring-origins.test.ts

@@ -0,0 +1,132 @@
+import { KEYRING_NAME_RE, type KeyringOrigin } from "../schemas/keyring.js";
+import {
+    type CaptureCandidate,
+    entriesFor,
+    entryNameFor,
+    findCaptureTarget,
+    gitOrigin,
+    mergeRules,
+    originKey,
+    originsOfRules,
+    rememberSwitchFor,
+    rulesForOrigin,
+    rulesServe,
+    titleForOrigin,
+} from "./keyring-origins.js";
+
+const NONE = { programs: [], packages: [], hosts: [], askpass: [] };
+
+const entry = (name: string, origin: KeyringOrigin, username?: string): CaptureCandidate => ({ name, rules: rulesForOrigin(origin), username, title: titleForOrigin(origin) });
+
+describe("origins and rules", () => {
+    test("a site keeps its host, without www and case", () => {
+        expect(rulesForOrigin({ kind: "site", host: "WWW.GitHub.com" })).toEqual({ ...NONE, hosts: ["github.com"] });
+        expect(originKey({ kind: "site", host: "www.github.com." })).toBe(originKey({ kind: "site", host: "github.com" }));
+    });
+
+    test("terminal places become askpass matchers, and read back as the same places", () => {
+        const places: KeyringOrigin[] = [
+            { kind: "ssh", target: "radar@build-01" },
+            { kind: "ssh-key", path: "/home/radar/.ssh/id_ed25519" },
+            { kind: "sudo" },
+            { kind: "sudo", user: "root" },
+        ];
+        for (const place of places) {
+            expect(originsOfRules({ ...NONE, ...rulesForOrigin(place) })).toEqual([place]);
+        }
+    });
+
+    test("git answers for every repository on its host", () => {
+        expect(gitOrigin("https://github.com/intentic/intentic.git")).toBe("https://github.com");
+        const rules = rulesForOrigin({ kind: "git", url: "https://github.com/intentic/intentic" });
+        expect(rules).toEqual({ ...NONE, askpass: ["git:https://github.com"], hosts: ["github.com"] });
+        expect(rulesServe(rules, { kind: "git", url: "https://github.com/other/repo" })).toBe(true);
+        // Its site is said once, by the git chip.
+        expect(originsOfRules(rules)).toEqual([{ kind: "git", url: "https://github.com" }]);
+    });
+
+    test("a sandbox terminal's prompt places nothing on this computer", () => {
+        expect(rulesForOrigin({ kind: "prompt", text: "Password:", command: "npm login", sandbox: "https://x.intentic.dev" })).toEqual(NONE);
+    });
+
+    test("merging adds a place without repeating one", () => {
+        const a = rulesForOrigin({ kind: "site", host: "github.com" });
+        const b = rulesForOrigin({ kind: "git", url: "https://github.com" });
+        expect(mergeRules(a, b)).toEqual({ ...NONE, hosts: ["github.com"], askpass: ["git:https://github.com"] });
+    });
+});
+
+describe("serving a place", () => {
+    test("a saved site fills its subdomains, and a wildcard its domain", () => {
+        expect(rulesServe({ ...NONE, hosts: ["github.com"] }, { kind: "site", host: "gist.github.com" })).toBe(true);
+        expect(rulesServe({ ...NONE, hosts: ["*.corp.example"] }, { kind: "site", host: "corp.example" })).toBe(true);
+        expect(rulesServe({ ...NONE, hosts: ["github.com"] }, { kind: "site", host: "notgithub.com" })).toBe(false);
+    });
+
+    test("a program matches by its file name, without case or folder", () => {
+        expect(rulesServe({ ...NONE, programs: ["C:\\Program Files\\Fortinet\\FortiClient.exe"] }, { kind: "program", program: "forticlient.EXE" })).toBe(true);
+    });
+});
+
+describe("the entry a capture updates", () => {
+    const github = entry("GITHUB_COM", { kind: "site", host: "github.com" }, "radarsu");
+    const work = entry("GITHUB_COM_WORK", { kind: "site", host: "github.com" }, "radar-work");
+
+    test("the same place and account is an update", () => {
+        expect(findCaptureTarget([github, work], { kind: "site", host: "www.github.com" }, "Radarsu")?.name).toBe("GITHUB_COM");
+    });
+
+    test("another account at the same place is a new entry", () => {
+        expect(findCaptureTarget([github], { kind: "site", host: "github.com" }, "someone-else")).toBeUndefined();
+    });
+
+    test("a sandbox prompt is found again by its title", () => {
+        const origin: KeyringOrigin = { kind: "prompt", text: "Password:", command: "npm login", sandbox: "https://x.intentic.dev" };
+        expect(findCaptureTarget([entry("NPM_LOGIN", origin)], origin, undefined)?.name).toBe("NPM_LOGIN");
+    });
+
+    test("a need offers the asked-for account first", () => {
+        expect(entriesFor([github, work], { kind: "site", host: "github.com" }, "radar-work").map((found) => found.name)).toEqual(["GITHUB_COM_WORK", "GITHUB_COM"]);
+    });
+});
+
+describe("titles and names", () => {
+    test("each place reads as a person would say it", () => {
+        expect(titleForOrigin({ kind: "site", host: "www.github.com" })).toBe("github.com");
+        expect(titleForOrigin({ kind: "program", program: "C:\\x\\FortiClient.exe" })).toBe("FortiClient");
+        expect(titleForOrigin({ kind: "program", program: "FortiClient.exe", label: "FortiClient VPN" })).toBe("FortiClient VPN");
+        expect(titleForOrigin({ kind: "ssh", target: "radar@build-01" })).toBe("ssh radar@build-01");
+        expect(titleForOrigin({ kind: "git", url: "https://github.com/a/b" })).toBe("git github.com");
+        expect(titleForOrigin({ kind: "prompt", text: "Password for npm: ", command: "npm login" })).toBe("npm login");
+        expect(titleForOrigin({ kind: "site", host: "github.com" }, "  GitHub ")).toBe("GitHub");
+    });
+
+    test("a name takes the title, then the account, then a number", () => {
+        const taken = new Set<string>();
+        const name = (title: string, user?: string): string => {
+            const made = entryNameFor(title, user, (candidate) => taken.has(candidate));
+            taken.add(made);
+            return made;
+        };
+        expect(name("github.com", "radarsu@example.com")).toBe("GITHUB_COM");
+        expect(name("github.com", "radarsu@example.com")).toBe("GITHUB_COM_RADARSU");
+        expect(name("github.com", "radarsu@example.com")).toBe("GITHUB_COM_RADARSU_2");
+        expect(name("ssh radar@build-01")).toBe("SSH_RADAR_BUILD_01");
+        expect(name("1Password")).toBe("_1PASSWORD");
+        expect(name("Zürich Bank")).toBe("ZURICH_BANK");
+        expect(name("···")).toBe("PASSWORD");
+    });
+
+    test("every name fits a reference", () => {
+        for (const title of ["a".repeat(400), "ąę", "--", "x y z", "9"]) {
+            expect(entryNameFor(title, "u", () => false)).toMatch(KEYRING_NAME_RE);
+        }
+    });
+});
+
+test("deliberate acts need no remember switch", () => {
+    expect(rememberSwitchFor("browser")).toBe("browser");
+    expect(rememberSwitchFor("git")).toBe("terminal");
+    expect(rememberSwitchFor("terminal")).toBe("sandbox");
+    expect(rememberSwitchFor("import")).toBeUndefined();
+});