@agentdeck/bridge 1.1.0 → 1.2.1

package/dist/codex-rate-limits-live.d.ts

@@ -29,15 +29,44 @@ interface RawLiveRateLimits {
  */
 export declare function parseLiveCodexRateLimits(result: unknown, capturedAt: string): CodexRateLimits | null;
 /**
- * The account-wide limit block among what `account/rateLimits/read` returned.
+ * The account-wide limit block among what `account/rateLimits/read` returned,
+ * plus the id it should be recorded under.
  *
- * Prefers the top-level `rateLimits` (what the Codex CLI shows) and falls back
- * to the first unnamed entry of `rateLimitsByLimitId`. Returns null when every
- * family is model-scoped: "no account-wide reading" is the honest answer, and
- * the caller then keeps whatever the rollout path found rather than adopting one
- * model's quota as the account's. Exported for unit testing.
+ * Prefers the top-level `rateLimits` — what the Codex CLI itself shows, and
+ * measured correct on 2026-08-27 at the exact moment the rollout was lying (the
+ * account at 100% up there, the Spark pool only under its own map key). Falls
+ * back to an unnamed entry of `rateLimitsByLimitId`, windowed before windowless
+ * so a `premium` credit block cannot be handed back ahead of a real windowed
+ * `codex` entry on iteration order alone. Returns null when every family is
+ * model-scoped: "no account-wide reading" is the honest answer, and the caller
+ * then keeps whatever the rollout path found rather than adopting one model's
+ * quota as the account's.
+ *
+ * ## What this deliberately does NOT do any more
+ *
+ * Three successive review rounds found HIGH-severity defects in machinery added
+ * here to defend a shape that has never been observed: a top-level block that
+ * mislabels itself the way the ROLLOUT does. The defence fingerprinted every
+ * candidate against the weekly resets of the response's own named pools, and
+ * each version of it failed in a new direction — handing back a block it had
+ * just identified as a pool, admitting a pool through a rung that dropped the
+ * key test, and finally refusing everything, because the response mirrors its
+ * top-level block into the map under its own key and any account id outside a
+ * hardcoded allow-list therefore fingerprint-matched ITSELF (`codex_pro` →
+ * `null` → no live read at all, which disables the 100%-wall detection this
+ * whole path exists for, pins the mid-turn spawn skip open, and leaves the relay
+ * guard permanently unarmed).
+ *
+ * The measured discriminators are `limitName` (non-empty ⇒ scoped, across 823
+ * rollouts and every live sample) and the map key, and they are enough. Guessing
+ * at a failure the producer has not shown produced three real ones. If the live
+ * top level is ever seen mislabelling itself, the fix belongs here — with that
+ * observation attached.
  */
-export declare function pickAccountWideLiveLimits(top?: RawLiveRateLimits | null, byLimitId?: Record<string, RawLiveRateLimits> | null): RawLiveRateLimits | null;
+export declare function pickAccountWideLiveLimits(top?: RawLiveRateLimits | null, byLimitId?: Record<string, RawLiveRateLimits> | null): {
+    limits: RawLiveRateLimits;
+    limitId?: string;
+} | null;
 /**
  * How to hand the Codex binary to `spawn`.
  *
@@ -65,6 +94,58 @@ export declare function queryCodexRateLimitsLive(opts?: {
     args?: string[];
     timeoutMs?: number;
 }): Promise<CodexRateLimits | null>;
+/**
+ * Whether the live reading contradicts the passive one about WHOSE quota it is.
+ * The picker uses it to prefer the live snapshot; the throttle uses its negation
+ * to decide whether the passive snapshot's freshness may suppress the next
+ * query. One expression, because written as two they drifted immediately: the
+ * throttle compared families against a cached live snapshot with no bound at
+ * all, so once that snapshot's window elapsed the mid-turn skip was lifted
+ * permanently while the picker had already stopped honouring the same
+ * fingerprint.
+ *
+ * The two consumers still REACH it differently, and that is deliberate rather
+ * than drift. The picker settles plan disagreement first and never asks this at
+ * all when the classes differ; the throttle asks it regardless, because a cached
+ * live snapshot minted under a retired plan is itself a reason to spend a query
+ * — the answer that replaces it is the only thing that can end the disagreement.
+ * The cost is bounded by the same spawn throttles as everything else here.
+ *
+ * The throttle must NOT reuse this predicate, and that is the whole point of
+ * `liveCorroboratesPassiveFamily` below. Exported for unit testing.
+ */
+export declare function liveRejectsPassiveFamily(passive?: CodexRateLimits | null, live?: CodexRateLimits | null, nowMs?: number): boolean;
+/**
+ * True when two snapshots describe the same limit FAMILY — or when there is not
+ * enough information to say they do not.
+ *
+ * `isModelScopedCodexLimit` reads the family off the snapshot's own `limit_name`,
+ * and that discriminator stopped being reliable on the rollout path. Measured
+ * 2026-08-27, inside a single rollout file, after the account's weekly quota was
+ * exhausted:
+ *
+ *   ...T20:59:45Z  limit_id "codex"    limit_name null   weekly resets 1788274890   (the account)
+ *   ...T20:59:46Z  limit_id "premium"  limit_name null   no windows at all
+ *   ...T13:01:31Z  limit_id "codex"    limit_name null   5h + weekly resets 1788440488
+ *
+ * That third shape is `codex_bengalfox` ("GPT-5.3-Codex-Spark") wearing the
+ * account's id: `account/rateLimits/read` returned the SAME two reset instants
+ * under `rateLimitsByLimitId.codex_bengalfox` at that moment, while the account
+ * family sat at 100% with `rateLimitReachedType: "rate_limit_reached"`. So once
+ * the account limit is reached and Codex serves the turn from a per-model pool,
+ * the rollout records that pool's numbers under an unnamed `codex` label and the
+ * name-based filter admits them: the deck read 54% / 24% for an exhausted week.
+ *
+ * The live read is the only source that keys families correctly, so it is what
+ * the passive reading is checked against. Two rules keep the check honest:
+ * an unknown on either side is "no information" and matches (a pre-`limit_id`
+ * rollout, a credit plan with no weekly window), and a mismatch is resolved by
+ * preferring the LIVE snapshot rather than by dropping both — the mismatch also
+ * arises legitimately for a few minutes after the account's weekly window rolls
+ * over, and there the live answer is merely stale, never wrong about whose
+ * quota it is. Exported for unit testing.
+ */
+export declare function codexSnapshotsShareLimitFamily(a?: CodexRateLimits | null, b?: CodexRateLimits | null): boolean;
 /**
  * Choose between the passive rollout reading and the live app-server reading.
  *
@@ -75,9 +156,34 @@ export declare function queryCodexRateLimitsLive(opts?: {
  * current, and the ONLY source carrying the new tier — lost every comparison and
  * was then voided as a mismatch. A snapshot with no `capturedAt` at all loses to
  * a stamped one within its match class; ties keep the passive reading, which is
- * the on-disk ground truth. Exported for unit testing.
+ * the on-disk ground truth.
+ *
+ * Family agreement is a tie-break WITHIN the plan class, and settled before
+ * recency, which cannot see it: the rollout is appended every couple of seconds
+ * while Codex works, so a snapshot describing a per-model pool under the
+ * account's id (see `codexSnapshotsShareLimitFamily`) wins every recency
+ * comparison for as long as the session runs, and the true account reading only
+ * surfaces in the gaps where the live query gets to fire. That is the
+ * oscillation this guard removes — the same gauge alternating between an
+ * exhausted week and a half-used one depending on which source answered last.
+ *
+ * It must stay UNDER the plan test, because a plan change moves the weekly reset
+ * instant too (`1787805401` under `plus` → `1787934975` under `prolite`, same
+ * `limit_id: "codex"`, both verbatim in `codex-rate-limits.test.ts`). Ranked
+ * above it, the family guard would answer a plan change by handing back the
+ * retired-plan live snapshot — which `normalizeCodexRateLimits` then voids to a
+ * windowless block, blanking every Codex gauge for up to the failure backoff.
+ * That is precisely the regression `codexSnapshotOutranks` exists to prevent,
+ * reintroduced through the door next to it.
+ *
+ * Only a live snapshot whose own weekly window exists AND is still running gets
+ * to reject anything (`familyFingerprintCanReject`) — an expired or absent
+ * fingerprint is not evidence about which family the current window belongs to.
+ * Exported for unit testing; `nowMs` is injectable for the same reason.
  */
-export declare function pickBestCodexRateLimits(passive: CodexRateLimits | null, live: CodexRateLimits | null, accountPlan?: string): CodexRateLimits | null;
+export declare function pickBestCodexRateLimits(passive: CodexRateLimits | null, live: CodexRateLimits | null, accountPlan?: string, nowMs?: number, opts?: {
+    liveOwnsFamilyAuthority?: boolean;
+}): CodexRateLimits | null;
 /** Throttle policy, kept pure so the cadence is testable without spawning. */
 export declare function shouldQueryCodexRateLimitsLive(input: {
     nowMs: number;
@@ -88,7 +194,58 @@ export declare function shouldQueryCodexRateLimitsLive(input: {
      *  longer holds — i.e. it is about to be voided and carries no usable number.
      *  Defaults to true so callers that know no account tier behave as before. */
     passivePlanMatchesAccount?: boolean;
+    /** False when the passive snapshot describes a different limit family from the
+     *  last live answer — it is then a different QUANTITY, not a fresher reading of
+     *  the same one, so its freshness must not suppress the query that carries the
+     *  account's number. Defaults to true (no live answer yet ⇒ nothing to compare
+     *  against). */
+    passiveMatchesAccountFamily?: boolean;
 }): boolean;
+/**
+ * Whether a published Codex block may speak for the account's limit FAMILY —
+ * the question the relay path has to answer before it lets that block reject a
+ * session bridge's.
+ *
+ * It is deliberately NOT "did the live snapshot win the last pick". Identity
+ * with the pick is false in the ordinary good case: when the two readings agree
+ * on family the picker keeps the fresher rollout, which while Codex is working
+ * is every single build. Read that way, the guard switched itself off exactly
+ * when the daemon did hold a verified baseline — and a bridge sampling a
+ * mislabelled pool line a second later then won on recency, which is the
+ * oscillation this whole change removes, surviving at the one call site that
+ * had no other defence.
+ *
+ * The real question is whether a live answer exists, carries a fingerprint that
+ * may reject (`familyFingerprintCanReject`), and agrees with what was published.
+ * A plan-voided live snapshot fails the second test rather than lending its
+ * authority to a passive block that outranked it for unrelated reasons.
+ *
+ * Takes the live block rather than reading the module cache, so the rule can be
+ * driven directly instead of only through a spawn, and answers with the instant
+ * the authority lapses rather than a yes/no read against the caller's clock.
+ */
+export declare function codexLiveFamilyAuthorityExpiry(published?: CodexRateLimits | null, live?: CodexRateLimits | null): number | null;
+/**
+ * Whether the cached live answer positively vouches for the passive reading's
+ * family — the THROTTLE's question, and deliberately not the picker's.
+ *
+ * Routing the throttle through `liveRejectsPassiveFamily` deadlocked the two
+ * bounds against each other on exactly the busy machine this change is for. The
+ * skip suppresses queries while the rollout is fresh, so under continuous Codex
+ * use the cached answer is never refreshed; fifteen minutes in it loses its
+ * authority; and from then on a disagreement could no longer be REPORTED as one,
+ * because the age bound lives inside the rejection test. `passiveMatchesAccountFamily`
+ * stayed true, the skip stayed engaged, no query ever fired, and the picker fell
+ * through to recency — publishing the mislabelled pool reading for the rest of
+ * the run.
+ *
+ * So the polarity is inverted here on purpose: the skip is earned by a live
+ * answer that is present, still able to arbitrate, and in agreement. Anything
+ * else — no answer, a stale one, a disagreeing one — is a REASON to spend a
+ * query, never a reason to skip one. The spawn throttles bound the cost either
+ * way. Exported for unit testing.
+ */
+export declare function liveCorroboratesPassiveFamily(passive?: CodexRateLimits | null, live?: CodexRateLimits | null, nowMs?: number): boolean;
 /** Last live snapshot, or null if none has been obtained. */
 export declare function getLiveCodexRateLimits(): CodexRateLimits | null;
 /**
@@ -101,9 +258,22 @@ export declare function getLiveCodexRateLimits(): CodexRateLimits | null;
  * `accountPlan` is the live tier from `auth.json`. Passing it is what lets both
  * halves of this function tell "old" from "void"; omitting it keeps the previous
  * newest-wins behaviour.
+ *
+ * The third axis needs no argument: the last live answer is itself the record of
+ * which limit family belongs to the account, so a passive snapshot describing a
+ * different one is neither preferred nor allowed to throttle the next query
+ * (`codexSnapshotsShareLimitFamily`).
  */
 export declare function codexRateLimitsWithLiveRefresh(passive: CodexRateLimits | null, accountPlan?: string): CodexRateLimits | null;
 /** Test hook — clears the module-level cache and throttle state. */
-export declare function __resetCodexRateLimitsLiveForTest(): void;
+export declare function __resetCodexRateLimitsLiveForTest(seed?: {
+    cachedLive?: CodexRateLimits | null;
+    lastAttemptMs?: number;
+}): void;
+/** Throttle state, so a test can tell "a query was spent" from "the skip held".
+ *  `lastAttemptMs` moves synchronously, before any subprocess exists. */
+export declare function __peekCodexRateLimitsLiveForTest(): {
+    lastAttemptMs: number;
+};
 export {};
 //# sourceMappingURL=codex-rate-limits-live.d.ts.map

package/dist/codex-rate-limits-live.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex-rate-limits-live.d.ts","sourceRoot":"","sources":["../src/codex-rate-limits-live.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAgB,eAAe,EAAwB,MAAM,mBAAmB,CAAC;AAiD7F,UAAU,aAAa;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;mEAC+D;IAC/D,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,cAAc;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC3B;AAED,UAAU,iBAAiB;IACzB,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAC/B,SAAS,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uFAAuF;IACvF,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;CACjC;AA+BD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CA0BpG;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,CAAC,EAAE,iBAAiB,GAAG,IAAI,EAC9B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,IAAI,GACnD,iBAAiB,GAAG,IAAI,CAM1B;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAGrC;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAClE,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAyEjC;AAQD;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,eAAe,GAAG,IAAI,EAC/B,IAAI,EAAE,eAAe,GAAG,IAAI,EAC5B,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,GAAG,IAAI,CAUxB;AAED,8EAA8E;AAC9E,wBAAgB,8BAA8B,CAAC,KAAK,EAAE;IACpD,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;kFAE8E;IAC9E,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC,GAAG,OAAO,CAyBV;AAOD,6DAA6D;AAC7D,wBAAgB,sBAAsB,IAAI,eAAe,GAAG,IAAI,CAE/D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,eAAe,GAAG,IAAI,EAC/B,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,GAAG,IAAI,CAiCxB;AAED,oEAAoE;AACpE,wBAAgB,iCAAiC,IAAI,IAAI,CAKxD"}
+{"version":3,"file":"codex-rate-limits-live.d.ts","sourceRoot":"","sources":["../src/codex-rate-limits-live.ts"],"names":[],"mappings":"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"}