@bitkyc08/opencodex 2.90.0 → 2.92.0

package/src/providers/derive.ts

@@ -3,6 +3,7 @@ import { COST_VENDOR_PRIORITY, getModelMetadata, getModelMetadataCaseInsensitive
 import { cloneFastWire } from "./fastwire";
 import { isAzureModelMetadataDestination, publishedAzureModelMetadata, type AzureModelMetadata } from "./azure-model-metadata";
 import { resolveModelPolicy } from "./resolved-model-policy";
+import { mapFill, nestedMapFill, stableUnion } from "./resolved-model-policy-merge";
 import {
   PROVIDER_REGISTRY,
   registryEntryForProviderDestination,
@@ -56,6 +57,7 @@ export interface DerivedKeyLoginProvider {
   thinkingBudgetModels?: string[];
   escapeBuiltinToolNames?: boolean;
   openaiChatEofTolerance?: boolean;
+  foldDeveloperRoleToSystem?: boolean;
   googleMode?: "ai-studio" | "vertex" | "cloud-code-assist";
   project?: string;
   location?: string;
@@ -280,6 +282,7 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     ...(entry.promptCacheKey !== undefined ? { promptCacheKey: entry.promptCacheKey } : {}),
     ...(entry.chatServiceTier !== undefined ? { chatServiceTier: entry.chatServiceTier } : {}),
     ...(entry.openaiChatEofTolerance !== undefined ? { openaiChatEofTolerance: entry.openaiChatEofTolerance } : {}),
+    ...(entry.foldDeveloperRoleToSystem !== undefined ? { foldDeveloperRoleToSystem: entry.foldDeveloperRoleToSystem } : {}),
     ...(entry.responsesPath !== undefined ? { responsesPath: entry.responsesPath } : {}),
     ...(entry.chatCompletionsPath !== undefined ? { chatCompletionsPath: entry.chatCompletionsPath } : {}),
     ...(entry.statelessResponses !== undefined ? { statelessResponses: entry.statelessResponses } : {}),
@@ -312,6 +315,9 @@ export function deriveKeyLoginMap(): Record<string, DerivedKeyLoginProvider> {
   const out: Record<string, DerivedKeyLoginProvider> = {};
   for (const entry of PROVIDER_REGISTRY) {
     if (entry.authKind !== "key") continue;
+    // A deprecated route cannot complete a login, but its entry must stay resolvable for
+    // configs saved while it still worked.
+    if (entry.deprecated) continue;
     if (!entry.dashboardUrl) throw new Error(`Registry key provider missing dashboardUrl: ${entry.id}`);
     const liveModels = registryEntrySupportsLiveModelDiscovery(entry) ? entry.liveModels : false;
     out[entry.id] = {
@@ -355,6 +361,7 @@ export function deriveKeyLoginMap(): Record<string, DerivedKeyLoginProvider> {
       ...(entry.thinkingBudgetModels ? { thinkingBudgetModels: [...entry.thinkingBudgetModels] } : {}),
       ...(entry.escapeBuiltinToolNames !== undefined ? { escapeBuiltinToolNames: entry.escapeBuiltinToolNames } : {}),
       ...(entry.openaiChatEofTolerance !== undefined ? { openaiChatEofTolerance: entry.openaiChatEofTolerance } : {}),
+      ...(entry.foldDeveloperRoleToSystem !== undefined ? { foldDeveloperRoleToSystem: entry.foldDeveloperRoleToSystem } : {}),
       ...(entry.googleMode ? { googleMode: entry.googleMode } : {}),
       ...(entry.project ? { project: entry.project } : {}),
       ...(entry.location ? { location: entry.location } : {}),
@@ -364,7 +371,7 @@ export function deriveKeyLoginMap(): Record<string, DerivedKeyLoginProvider> {
 }
 
 export function deriveInitProviders(): DerivedInitProvider[] {
-  return PROVIDER_REGISTRY.map(entry => ({
+  return PROVIDER_REGISTRY.filter(entry => !entry.deprecated).map(entry => ({
     id: entry.id,
     label: formatInitLabel(entry),
     adapter: entry.adapter,
@@ -391,6 +398,7 @@ export function deriveOAuthIds(): string[] {
 
 export function deriveProviderPresets(): DerivedProviderPreset[] {
   const presets = PROVIDER_REGISTRY
+    .filter(entry => !entry.deprecated)
     .filter(entry => entry.featured || entry.authKind === "key" || entry.dashboardPreset)
     .map(entryToPreset);
   return [...dedupePresets(presets), customPreset()];
@@ -470,13 +478,22 @@ function applyVerbosityDefaults(prov: OcxProviderConfig, entry: ProviderRegistry
  * was skipped and the reasoning ladder was advertised without summary support — exactly the
  * inconsistency that makes Codex drop the inbound reasoning object.
  *
- * Deliberately narrow: reasoning-summary, effort, and replay-compatibility metadata only, via
+ * Deliberately narrow: reasoning-summary, effort, structured-output, and replay-compatibility metadata only, via
  * `registryEntryForProviderDestination`, which matches fixed key destinations and refuses
  * templated or overridable base URLs. A custom row keeps its own identity for everything else.
  */
 function enrichReasoningMetadataByDestination(prov: OcxProviderConfig): void {
   const destination = registryEntryForProviderDestination(prov);
   applyReasoningSummaryDefaults(prov, destination?.modelSupportsReasoningSummaries);
+  if (destination?.modelDefaultReasoningEfforts) {
+    prov.modelDefaultReasoningEfforts = mapFill(destination.modelDefaultReasoningEfforts, prov.modelDefaultReasoningEfforts)[0];
+  }
+  if (destination?.modelReasoningEffortMap) {
+    prov.modelReasoningEffortMap = nestedMapFill(destination.modelReasoningEffortMap, prov.modelReasoningEffortMap)[0];
+  }
+  if (destination?.noStructuredOutputModels?.length) {
+    prov.noStructuredOutputModels = stableUnion(destination.noStructuredOutputModels, prov.noStructuredOutputModels)[0];
+  }
   if (prov.dropResponsesReasoningItems === undefined && destination?.dropResponsesReasoningItems !== undefined) {
     prov.dropResponsesReasoningItems = destination.dropResponsesReasoningItems;
   }
@@ -567,6 +584,9 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   if (prov.openaiChatEofTolerance === undefined && seed.openaiChatEofTolerance !== undefined) {
     prov.openaiChatEofTolerance = seed.openaiChatEofTolerance;
   }
+  if (prov.foldDeveloperRoleToSystem === undefined && seed.foldDeveloperRoleToSystem !== undefined) {
+    prov.foldDeveloperRoleToSystem = seed.foldDeveloperRoleToSystem;
+  }
   // Fill-only: a hand-edited path must survive, and a config saved before the registry
   // learned this route still gets backfilled.
   if (prov.responsesPath === undefined && seed.responsesPath !== undefined) prov.responsesPath = seed.responsesPath;
@@ -633,7 +653,7 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
 }
 
 export function deriveFeaturedProviderIds(): string[] {
-  return PROVIDER_REGISTRY.filter(entry => entry.featured).map(entry => entry.id);
+  return PROVIDER_REGISTRY.filter(entry => entry.featured && !entry.deprecated).map(entry => entry.id);
 }
 
 export function deriveJawcodeAliases(): Record<string, string> {

package/src/providers/mistral-transport.ts

@@ -8,6 +8,14 @@ import { RequestPacingQueueOverloadError } from "./request-pacing";
 import type { OcxProviderTransport } from "./xai-transport";
 
 const MAX_IDENTITIES = 128;
+/** Queued waiters per credential+model identity; one hot identity never refuses another. */
+const MAX_WAITERS_PER_IDENTITY = 128;
+/**
+ * Process-wide waiter bound. Model strings come from clients, so identities are not bounded by
+ * configuration; this keeps memory and pending requests finite. It is a multiple of the
+ * per-identity cap, so no single identity can fill it alone.
+ */
+const MAX_WAITERS_TOTAL = 4 * MAX_WAITERS_PER_IDENTITY;
 const DEFAULT_MAX_WAIT_MS = 60_000; // Existing retry wait budget, not an inferred rate window.
 const MINUTE_MS = 60 * 1000; // Unit named by the observed headers, never an account quota.
 type RecoveryState = { generation: number; probe?: { done: Promise<void>; finish(): void } };
@@ -61,7 +69,14 @@ export class MistralBudgetPacer {
   private readonly recoveries = new Map<string, RecoveryState>();
   /** Latest live deadline evicted at capacity; unknown identities wait it out instead of sending early. */
   private evictedUntil = 0;
-  private waiting = 0;
+  /**
+   * Parked waiters keyed by identity. A request counts only once it is about to wait, so a held
+   * credential or model fills only its own queue and a request that can send now is never answered
+   * queue_full (HTTP 429). The map holds identities with live waiters only; the total is capped by
+   * MAX_WAITERS_TOTAL.
+   */
+  private readonly waiting = new Map<string, number>();
+  private waitingTotal = 0;
 
   constructor(
     private readonly now: () => number = Date.now,
@@ -103,9 +118,18 @@ export class MistralBudgetPacer {
   /** Wait within the admission budget and return a release callback for one recovery probe. */
   async acquire(identity: string, signal?: AbortSignal, maxWaitMs = DEFAULT_MAX_WAIT_MS): Promise<(success?: boolean) => void> {
     signal?.throwIfAborted();
-    if (this.waiting >= MAX_IDENTITIES) throw new RequestPacingQueueOverloadError("mistral", "queue_full", 60);
-    this.waiting++;
     const deadline = this.now() + maxWaitMs;
+    let parked = false;
+    const park = (): void => {
+      if (parked) return;
+      const queued = this.waiting.get(identity) ?? 0;
+      if (queued >= MAX_WAITERS_PER_IDENTITY || this.waitingTotal >= MAX_WAITERS_TOTAL) {
+        throw new RequestPacingQueueOverloadError("mistral", "queue_full", 60);
+      }
+      this.waiting.set(identity, queued + 1);
+      this.waitingTotal++;
+      parked = true;
+    };
     try {
       for (;;) {
         signal?.throwIfAborted();
@@ -118,6 +142,7 @@ export class MistralBudgetPacer {
           throw new RequestPacingQueueOverloadError("mistral", "queue_expired", Math.ceil(delay / 1000));
         }
         if (readyAt !== undefined && readyAt > this.now()) {
+          park();
           await this.sleep(readyAt - this.now(), signal);
           continue;
         }
@@ -126,6 +151,7 @@ export class MistralBudgetPacer {
         if (state.probe) {
           const remaining = deadline - this.now();
           if (remaining <= 0) throw new RequestPacingQueueOverloadError("mistral", "queue_expired", 1);
+          park();
           const local = new AbortController();
           try {
             await Promise.race([state.probe.done, this.sleep(remaining, AbortSignal.any([local.signal, ...(signal ? [signal] : [])]))]);
@@ -150,7 +176,14 @@ export class MistralBudgetPacer {
           probe.finish();
         };
       }
-    } finally { this.waiting--; }
+    } finally {
+      if (parked) {
+        this.waitingTotal--;
+        const left = (this.waiting.get(identity) ?? 1) - 1;
+        if (left > 0) this.waiting.set(identity, left);
+        else this.waiting.delete(identity);
+      }
+    }
   }
 }
 

package/src/providers/model-discovery.ts

@@ -1,3 +1,4 @@
+import { extractWorkBuddyModels } from "./workbuddy-models";
 import type { OcxProviderConfig } from "../types";
 import {
   isValidModelDiscoveryModelId,
@@ -513,6 +514,7 @@ export function extractProviderModelItems(
   discovery: ResolvedProviderModelDiscovery,
 ): ProviderModelItemsResult {
   const limit = positiveIntegerAtMost(discovery.maxModels, MODEL_DISCOVERY_MAX_MODELS);
+  if (discovery.spec?.format === "workbuddy") return extractWorkBuddyModels(value, limit);
   let data: unknown[];
   let siblings: SiblingIndex | null = null;
   if (Array.isArray(value)) {

package/src/providers/model-rename-fields.ts

@@ -153,6 +153,7 @@ export const PROVIDER_MODEL_RENAME_ROLES = {
   desktopExecutor: "none",
   unsafeAllowNativeLocalExec: "none",
   nativeLocalExec: "none",
+  messagePhaseInference: "none",
   tlsProfile: "none",
 } as const satisfies Record<keyof OcxProviderConfig, ModelRenameRole>;
 

package/src/providers/quota/account-cache.ts

@@ -203,7 +203,7 @@ export function supportsPerAccountQuota(provider: string): boolean {
 
 export function explicitAccountReader(provider: string): boolean {
   return provider === "xai" || provider === "cursor" || provider === "kimi" || provider === "command-code"
-    || provider === "devin" || provider === "dsh-account";
+    || provider === "devin" || provider === "workbuddy-ai" || provider === "dsh-account";
 }
 
 export function providerOAuthAccountQuotaMode(provider: string): AccountQuotaMode {
@@ -558,6 +558,7 @@ export function quotaCredentialIdentity(provider: string, accountId: string, cre
     // Only credentials that carry their own endpoint (Devin tenants) extend the identity, so
     // every other provider's existing cache keys stay valid.
     ...(provider === "devin" && credential.apiBaseUrl ? [credential.apiBaseUrl] : []),
+    ...(provider === "workbuddy-ai" ? [credential.workbuddy] : []),
   ])).digest("hex");
 }
 
@@ -567,5 +568,5 @@ export function explicitQuotaDestination(provider: string, config: OcxProviderCo
   if (provider === "command-code") return isCanonicalCommandCodeBaseUrl(config.baseUrl);
   // These readers use fixed canonical billing origins, never config.baseUrl. Devin reads
   // the credential's own allowlisted api-server host instead (fetchDevinQuota revalidates it).
-  return provider === "xai" || provider === "cursor" || provider === "devin" || provider === "dsh-account";
+  return provider === "xai" || provider === "cursor" || provider === "devin" || provider === "workbuddy-ai" || provider === "dsh-account";
 }

package/src/providers/quota/antigravity.ts

@@ -3,11 +3,16 @@ import { DestinationDnsResolutionError } from "../../lib/destination-policy";
 import { PinnedHttpError, type PinnedHttpErrorCode } from "../../lib/pinned-http";
 import { ProviderOutboundPolicyError, providerOutboundPost, providerRedirectError, type ProviderOutboundDependencies } from "../../lib/provider-outbound";
 import { getValidAccessToken } from "../../oauth";
-import { getAccountCredential, getCredential } from "../../oauth/store";
+import { getAccountCredential, getAccountSet, getCredential } from "../../oauth/store";
 import { asRecord, normalizePercent, normalizeResetAt, readQuotaJson, REQUEST_TIMEOUT_MS, toFiniteNumber } from "../quota-wire";
-import { report, type ProviderQuotaReport } from "./report-cache";
+import { antigravityEvidence, report, type ProviderQuotaReport } from "./report-cache";
+import { captureAntigravityQuotaReceipt, decisionQuotaSinkActive } from "../../lib/decision-quota-sink";
+import { antigravityDecisionWindows } from "../quota-decision-publication";
+import { antigravityQuotaCredentialGeneration, isAntigravityArgonIdentity } from "../antigravity-quota-identity";
+import type { OcxProviderConfig } from "../../types";
 import { quotaCredentialIdentity } from "./account-cache";
 import type { ProviderQuota, ProviderQuotaWindow, QuotaFailureCode } from "../quota-types";
+import { httpQuotaFailure } from "./failure-codes";
 
 export function antigravityQuotaDiagnosticIdentity(accountId: string, credential = getAccountCredential("google-antigravity", accountId)): string | undefined {
   return credential ? quotaCredentialIdentity("google-antigravity", accountId, credential, {
@@ -45,11 +50,6 @@ function quotaInfoEntries(modelInfo: Record<string, unknown>): Record<string, un
   return entries;
 }
 
-/**
- * Gemini 4 Argon has its own quota pool. Its names also contain "gemini", so every family
- * decision below checks Argon first; otherwise Argon readings fill or replace the Gem family.
- */
-const ARGON_TOKEN = /(?:^|[^a-z0-9])argon(?:[^a-z0-9]|$)/i;
 const GEMINI_TOKEN = /(?:^|[^a-z0-9])gemini(?:[^a-z0-9]|$)/i;
 const CLAUDE_FAMILY_TOKEN = /(?:^|[^a-z0-9])(?:claude|3p|gpt|opus|sonnet)(?:[^a-z0-9]|$)/i;
 /** Canonical model of the Argon summary pool; tagging keeps the window out of routing. */
@@ -60,7 +60,7 @@ type AntigravitySummaryFamily = "argon" | "gem" | "cla";
 /** A bucket's own id and name decide its family when they name one; the group decides otherwise. */
 function antigravitySummaryBucketFamily(bucket: Record<string, unknown>): AntigravitySummaryFamily | undefined {
   const identity = `${typeof bucket.bucketId === "string" ? bucket.bucketId : ""} ${typeof bucket.displayName === "string" ? bucket.displayName : ""}`;
-  if (ARGON_TOKEN.test(identity)) return "argon";
+  if (isAntigravityArgonIdentity(identity)) return "argon";
   if (GEMINI_TOKEN.test(identity)) return "gem";
   if (CLAUDE_FAMILY_TOKEN.test(identity)) return "cla";
   return undefined;
@@ -69,7 +69,7 @@ function antigravitySummaryBucketFamily(bucket: Record<string, unknown>): Antigr
 function classifyAntigravityFamily(modelId: string, modelInfo: Record<string, unknown>, quotaInfo: Record<string, unknown>): "Gem" | "Cla" | null {
   const displayName = typeof modelInfo.displayName === "string" ? modelInfo.displayName : "";
   // Argon models keep their exact model rows but never seed the shared Gem family bar.
-  if (ARGON_TOKEN.test(`${modelId} ${displayName}`)) return null;
+  if (isAntigravityArgonIdentity(`${modelId} ${displayName}`)) return null;
   const tier = typeof quotaInfo.tier === "string" ? quotaInfo.tier : "";
   const haystack = `${modelId} ${displayName} ${tier}`.toLowerCase();
   if (haystack.includes("gemini")) return "Gem";
@@ -154,7 +154,7 @@ function parseAntigravityQuotaSummary(body: Record<string, unknown> | null): Pro
     const groupDisplayName = typeof group.displayName === "string" ? group.displayName : "";
     const groupName = `${groupDisplayName} ${typeof group.description === "string" ? group.description : ""}`.toLowerCase();
     // A description that merely mentions Argon must not move a whole Gemini group.
-    const groupFamily: AntigravitySummaryFamily | undefined = ARGON_TOKEN.test(groupDisplayName) ? "argon"
+    const groupFamily: AntigravitySummaryFamily | undefined = isAntigravityArgonIdentity(groupDisplayName) ? "argon"
       : groupName.includes("gemini") ? "gem"
         : groupName.includes("claude") || groupName.includes("3p") || groupName.includes("gpt") ? "cla"
           : undefined;
@@ -275,13 +275,6 @@ function quotaTransportFailure(error: unknown): QuotaFailureCode {
   return "transport_error";
 }
 
-function quotaHttpFailure(status: number): QuotaFailureCode {
-  if (status >= 300 && status < 400) return "redirect_blocked";
-  if (status === 401 || status === 403) return "access_denied";
-  if (status === 429) return "rate_limited";
-  return "upstream_error";
-}
-
 function unavailableAntigravityQuota(failure: QuotaFailureCode): AntigravityQuotaProbeResult {
   return { kind: "unavailable", failure, legacy: { kind: "null" } };
 }
@@ -342,7 +335,7 @@ export async function probeAntigravityUsageQuota(accessToken: string, projectId:
       return unavailableAntigravityQuota(antigravityUnavailableFailure(summaryFailure, "redirect_blocked"));
     }
     if (!response.ok) {
-      return unavailableAntigravityQuota(antigravityUnavailableFailure(summaryFailure, quotaHttpFailure(response.status)));
+      return unavailableAntigravityQuota(antigravityUnavailableFailure(summaryFailure, httpQuotaFailure(response.status)));
     }
     const customWindows = antigravityWindowsFromModels(asRecord(await readQuotaJson(response)));
     if (!customWindows.length) {
@@ -366,13 +359,25 @@ export async function fetchAntigravityUsageQuota(accessToken: string, projectId:
   return null;
 }
 
-export async function fetchAntigravityQuota(provider: string): Promise<ProviderQuotaReport | null> {
-  const credential = getCredential("google-antigravity");
+/** Every store read uses `provider`, the same key inference resolves, so a row never probes another row's account. */
+export async function fetchAntigravityQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaReport | null> {
+  const credential = getCredential(provider);
   if (!credential?.projectId) return null;
   let accessToken: string;
-  try { accessToken = await getValidAccessToken("google-antigravity"); } catch { return null; }
+  try { accessToken = await getValidAccessToken(provider); } catch { return null; }
+  const set = decisionQuotaSinkActive() ? getAccountSet(provider) : undefined;
+  const account = set?.accounts.find(row => row.id === set.activeAccountId);
+  const probed = account?.credential.access === accessToken && account.credential.projectId === credential.projectId ? account : undefined;
+  const receipt = probed ? captureAntigravityQuotaReceipt(provider, config, probed.id, antigravityQuotaCredentialGeneration(probed.credential)) : undefined;
   const result = await probeAntigravityUsageQuota(accessToken, credential.projectId);
-  if (result.kind === "available") return report(provider, result.source, result.quota);
+  if (result.kind === "available") {
+    const value = report(provider, result.source, result.quota);
+    // Only the summary endpoint reports real family buckets. The models fallback labels one model's
+    // counter Gem/Cla, so it stays display-only: no windows, and retained summary clocks survive.
+    const windows = result.source === "google-antigravity:retrieveUserQuotaSummary" ? antigravityDecisionWindows(result.quota) : [];
+    if (value && receipt) antigravityEvidence.set(value, { receipt, windows: Object.freeze(windows.map(row => Object.freeze(row))) });
+    return value;
+  }
   if (result.legacy.kind === "throw") throw result.legacy.error;
   return null;
 }

package/src/providers/quota/report-cache.ts

@@ -1,5 +1,6 @@
-import { decisionQuotaSinkActive, invalidateDecisionKeyQuotas, publishDecisionKeyQuota } from "../../lib/decision-quota-sink";
+import { decisionQuotaSinkActive, invalidateDecisionKeyQuotas, replaceCollectedDecisionQuotas, type AntigravityQuotaObservation, type AntigravityQuotaReceipt, type DecisionKeyObservation } from "../../lib/decision-quota-sink";
 import { providerDecisionWindows } from "../quota-decision-publication";
+import type { DecisionQuotaWindow } from "../quota-decision-snapshot";
 import { createHash } from "node:crypto";
 import { effectiveCodexAuthAccountId, listCodexAuthAccountsSnapshot } from "../../codex/auth-api";
 import { withoutRetiredCodexQuota, type StoredAccountQuota } from "../../codex/quota";
@@ -21,6 +22,8 @@ export const LAST_GOOD_MAX_AGE_MS = CODEX_CAPACITY_MAX_QUOTA_AGE_MS;
 const nativeMainReportGenerations = new WeakMap<ProviderQuotaReport, number>();
 export const accountReportCurrent = new WeakMap<ProviderQuotaReport, () => boolean>();
 export const routingEvidence = new WeakMap<ProviderQuotaReport, ProviderQuotaRoutingEvidence>();
+/** Only the live Antigravity probe binds this projection; display/last-good rows cannot create it. */
+export const antigravityEvidence = new WeakMap<ProviderQuotaReport, { receipt: AntigravityQuotaReceipt; windows: readonly DecisionQuotaWindow[] }>();
 export let providerQuotaBeforePublishForTests: (() => void | Promise<void>) | null = null;
 
 /** Test-only seam for identity/config invalidation after probes but before publication. */
@@ -100,6 +103,7 @@ export function clearProviderQuotaCache(): void {
   cache = null;
   clearCachedProviderQuotas();
   clearProviderApiKeyQuotaCache();
+  invalidateDecisionKeyQuotas();
   invalidationEpoch += 1;
 }
 
@@ -350,13 +354,18 @@ export function isProviderQuotaReportCurrent(value: ProviderQuotaReport): boolea
 /** Called only by an accepted collector/cache publication, never the JEV read path. */
 export function publishCollectedDecisionQuota(reports: ProviderQuotaReport[], config: OcxConfig): void {
   if (!decisionQuotaSinkActive()) return;
-  invalidateDecisionKeyQuotas();
+  const keys: DecisionKeyObservation[] = [];
+  const oauth: AntigravityQuotaObservation[] = [];
   for (const report of reports) {
     const provider = config.providers[report.provider];
+    if (!provider || !isProviderQuotaReportCurrent(report)) continue;
+    const observation = antigravityEvidence.get(report);
+    if (observation) oauth.push({ name: report.provider, provider, ...observation });
     const evidence = routingEvidence.get(report);
-    if (provider && evidence && evidence.binding === providerQuotaRoutingBinding(report.provider, provider))
-      publishDecisionKeyQuota(report.provider, provider, providerDecisionWindows(evidence.quota));
+    if (evidence && evidence.binding === providerQuotaRoutingBinding(report.provider, provider))
+      keys.push({ name: report.provider, provider, windows: providerDecisionWindows(evidence.quota) });
   }
+  replaceCollectedDecisionQuotas(keys, oauth);
 }
 
 /**

package/src/providers/quota/vendor-probes-key.ts

@@ -47,6 +47,8 @@ const VENICE_BASE_URL = "https://api.venice.ai/api/v1";
 const SYNTHETIC_BASE_URL = "https://api.synthetic.new/v2";
 const DEEPINFRA_BASE_URL = "https://api.deepinfra.com";
 const NEURALWATT_BASE_URL = "https://api.neuralwatt.com/v1";
+const ABLITERATION_BASE_URL = "https://api.abliteration.ai";
+const ABLITERATION_CREDITS_URL = `${ABLITERATION_BASE_URL}/v1/credits`;
 
 
 function isCanonicalA6apiBaseUrl(baseUrl: string): boolean {
@@ -132,6 +134,11 @@ function isCanonicalNeuralwattBaseUrl(baseUrl: string): boolean {
   return normalizedBaseUrl(baseUrl) === NEURALWATT_BASE_URL;
 }
 
+function isCanonicalAbliterationBaseUrl(baseUrl: string): boolean {
+  const normalized = normalizedBaseUrl(baseUrl);
+  return normalized === ABLITERATION_BASE_URL || normalized === `${ABLITERATION_BASE_URL}/v1`;
+}
+
 function a6apiPayload(value: unknown): Record<string, unknown> | null {
   const body = asRecord(value);
   return asRecord(body?.data) ?? body;
@@ -1043,6 +1050,56 @@ async function fetchNeuralwattQuota(provider: string, config: OcxProviderConfig)
   return windows > 0 ? report(provider, "neuralwatt:quota", quota) : null;
 }
 
+/**
+ * Abliteration `GET /v1/credits` body: `{ data: { total_credits, total_usage } }`, both in USD.
+ * `total_credits` is everything granted or purchased and `total_usage` is finalized spend, so the
+ * balance is their difference. A well-formed reply with zero total credits is authoritative: it has
+ * no ceiling to meter against, so it clears any previous row instead of fabricating a bar. A
+ * malformed reply returns null and leaves the last-good row in place.
+ */
+export function parseAbliterationCredits(
+  body: Record<string, unknown> | null,
+): ProviderQuota | typeof AUTHORITATIVE_EMPTY_QUOTA | null {
+  const data = asRecord(body?.data);
+  const total = toFiniteNumber(data?.total_credits);
+  const used = toFiniteNumber(data?.total_usage);
+  if (total === undefined || used === undefined || total < 0 || used < 0) return null;
+  if (total === 0) return AUTHORITATIVE_EMPTY_QUOTA;
+  const percent = normalizePercent((used / total) * 100);
+  if (percent === undefined) return null;
+  return {
+    creditsUsd: { used, limit: total, remaining: Math.max(0, total - used), percent },
+    updatedAt: Date.now(),
+  };
+}
+
+/**
+ * Abliteration `GET /v1/credits` — the organization credit balance for the active project key.
+ * The balance funds every inference request on this key, so display and routing scope agree.
+ * `503 credit_balance_unavailable`, 408 and 429 are transient and keep the last-good row.
+ */
+async function fetchAbliterationQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
+  // Never send a configured API key to a lookalike host or through a redirect.
+  if (!isCanonicalAbliterationBaseUrl(config.baseUrl)) return null;
+  const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
+  if (!apiKey) return null;
+  const response = await quotaFetch(provider, config, ABLITERATION_CREDITS_URL, {
+    headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
+    redirect: "error",
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+  });
+  if (!response.ok) {
+    return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
+      ? TERMINAL_QUOTA_FAILURE
+      : null;
+  }
+  const raw = await readQuotaJson(response);
+  if (raw === QUOTA_JSON_READ_FAILURE) return null;
+  const quota = parseAbliterationCredits(asRecord(raw));
+  if (quota === null || quota === AUTHORITATIVE_EMPTY_QUOTA) return quota;
+  return keyReport(provider, "abliteration:credits", quota, config, apiKey, quota);
+}
+
 
 export function normalizedBaseUrl(value: string): string | null {
   try {
@@ -1371,6 +1428,9 @@ export function keyQuotaReaderForProvider(name: string, provider: OcxProviderCon
   if (name === "synthetic" && isCanonicalSyntheticBaseUrl(provider.baseUrl)) return fetchSyntheticQuota;
   if (name === "deepinfra" && isCanonicalDeepInfraBaseUrl(provider.baseUrl)) return fetchDeepInfraQuota;
   if (name === "neuralwatt" && isCanonicalNeuralwattBaseUrl(provider.baseUrl)) return fetchNeuralwattQuota;
+  // Abliteration has no registry preset, so it is usually a custom provider under any name; the
+  // canonical-URL guard alone decides eligibility and keeps the key off lookalike hosts.
+  if (isCanonicalAbliterationBaseUrl(provider.baseUrl)) return fetchAbliterationQuota;
   return null;
 }
 

package/src/providers/quota/workbuddy.ts

@@ -0,0 +1,83 @@
+import type { OAuthCredentials } from "../../oauth/types";
+import { workBuddyApi, WorkBuddyApiError } from "../../oauth/workbuddy";
+import { workBuddyHeaders } from "../workbuddy";
+import { parseWorkBuddyCredits, workBuddyCapacity, workBuddyRecord, type WorkBuddyCreditBalance } from "../workbuddy-credit-balance";
+import { REQUEST_TIMEOUT_MS } from "../quota-wire";
+import { TERMINAL_QUOTA_FAILURE, type ProviderQuotaProbeResult } from "./report-cache";
+
+function packageEnd(row: Record<string, unknown>): number | undefined {
+  const deduction = workBuddyCapacity(row.DeductionEndTime);
+  if (deduction && Number.isFinite(new Date(deduction).getTime())) return deduction;
+  for (const value of [row.ExpiredTime, row.CycleEndTime]) {
+    if (typeof value !== "string") continue;
+    const date = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(value)
+      ? `${value.replace(" ", "T")}+08:00` : value;
+    const parsed = Date.parse(date);
+    if (parsed > 0) return parsed;
+  }
+  return undefined;
+}
+
+export function workBuddyExpiringCredits(packages: unknown[], codes: ReadonlySet<string>, now: number): WorkBuddyCreditBalance["expiring"] {
+  let at = Infinity, amount = 0;
+  for (const raw of packages) {
+    const row = workBuddyRecord(raw);
+    if (typeof row.PackageCode !== "string" || !codes.has(row.PackageCode) || String(row.CapacityType) === "4") continue;
+    const remaining = workBuddyCapacity(row.CycleCapacityRemainPrecise || row.CycleCapacityRemain);
+    const end = packageEnd(row);
+    if (!remaining || !end || end <= now) continue;
+    if (end < at) { at = end; amount = remaining; }
+    else if (end === at) amount += remaining;
+  }
+  return Number.isFinite(at) && Number.isFinite(amount) ? { amount, at } : undefined;
+}
+
+async function expiringCredits(summary: Record<string, unknown>, headers: Record<string, string>, signal: AbortSignal, now: number) {
+  const packages = Array.isArray(summary.Packages) ? summary.Packages : [];
+  const codes = [...new Set(packages.map(raw => workBuddyRecord(raw).PackageCode)
+    .filter((code): code is string => typeof code === "string" && /^[A-Za-z0-9_-]{1,128}$/.test(code)))];
+  if (!codes.length) return undefined;
+  const day = new Date(now + 8 * 3600_000).toISOString().slice(0, 10);
+  const lists = await Promise.all(["paid", "free"].map(async kind => {
+    const accounts: unknown[] = [];
+    for (let page = 1; page <= 10; page++) {
+      const data = await workBuddyApi(`/billing/meter/get-user-resource-${kind}-packages`, headers, signal, true, {
+        PageNumber: page, PageSize: 200, Status: [0, 3], PackageCodes: codes,
+        ...(kind === "paid" ? { NeedRenewInfo: true }
+          : { SlicePeriodStartTime: `${day} 00:00:00`, SlicePeriodEndTime: `${day} 23:59:59` }),
+      });
+      if (!Array.isArray(data.Accounts) || data.Accounts.length > 200) throw new Error("Invalid WorkBuddy package list");
+      accounts.push(...data.Accounts);
+      const total = workBuddyCapacity(data.TotalCount);
+      if (data.Accounts.length < 200 || total !== undefined && accounts.length >= total) return accounts;
+    }
+    throw new Error("WorkBuddy package list exceeded page limit");
+  }));
+  return workBuddyExpiringCredits(lists.flat(), new Set(codes), now);
+}
+
+export async function fetchWorkBuddyQuota(provider: string, credential: OAuthCredentials): Promise<ProviderQuotaProbeResult> {
+  if (!credential.workbuddy) return null;
+  const signal = AbortSignal.timeout(REQUEST_TIMEOUT_MS), now = Date.now();
+  try {
+    const headers = workBuddyHeaders(credential.access, credential.workbuddy);
+    const summary = await workBuddyApi("/billing/meter/get-user-resource-summary", headers, signal, true);
+    let credits = parseWorkBuddyCredits(summary);
+    if (credential.workbuddy.enterpriseId && (!credits || credits.total === 0)) {
+      const team = await workBuddyApi("/billing/meter/get-enterprise-user-usage", headers, signal, true);
+      const total = workBuddyCapacity(team.limitNum), used = workBuddyCapacity(team.credit);
+      if (total === undefined || used === undefined) return null;
+      credits = { total, used, remaining: Math.max(0, total - used), frozen: 0, groups: [] };
+    }
+    if (!credits) return null;
+    if (credits.remaining > 0) {
+      // Optional expiry failures must not erase a successful balance reading.
+      credits.expiring = await expiringCredits(summary, headers, signal, now).catch(() => undefined);
+    }
+    const updatedAt = Date.now();
+    return { provider, label: "WorkBuddy AI", source: "WorkBuddy credits", updatedAt,
+      reverseEngineered: true, quota: { updatedAt, workbuddyCredits: credits } };
+  } catch (error) {
+    return error instanceof WorkBuddyApiError && error.status === 401 ? TERMINAL_QUOTA_FAILURE : null;
+  }
+}

package/src/providers/quota-decision-antigravity.ts

@@ -0,0 +1,64 @@
+/** Optional snapshot owner. No store reads: roster input comes only from loaded-store notifications. */
+import { getConfigDir } from "../config/paths";
+import { captureConfigGeneration } from "../lib/state-store-sweeper";
+import { ANTIGRAVITY_OAUTH_STORE_KEY, antigravityQuotaCredentialGeneration, antigravityQuotaEligible, antigravityQuotaPolicy } from "./antigravity-quota-identity";
+import type { AuthStore } from "../oauth/store";
+import type { OcxProviderConfig } from "../types";
+import type { AntigravityQuotaObservation, AntigravityQuotaReceipt } from "../lib/decision-quota-sink";
+import type { DecisionQuotaWindow } from "./quota-decision-snapshot";
+
+type Owner = { root: string; id: string; generation: string; revision: string };
+type Receipt = Owner & { owner: Owner; name: string; policy: string; configGeneration: number; epoch: number };
+let owner: Owner | undefined;
+let epoch = 0;
+const receipts = new WeakMap<AntigravityQuotaReceipt, Receipt>();
+let observations = new Map<string, { receipt: Receipt; windows: readonly DecisionQuotaWindow[] }>();
+
+/** Any roster transition retires old receipts, including switching away and back. */
+export function observeAntigravityQuotaStore(store: AuthStore): void {
+  const set = store[ANTIGRAVITY_OAUTH_STORE_KEY];
+  const account = set?.accounts.length === 1 ? set.accounts[0] : undefined;
+  const next = account && set?.activeAccountId === account.id && !account.paused && !account.needsReauth
+    && account.credential.access && account.credential.projectId
+    ? { root: getConfigDir(), id: account.id, generation: antigravityQuotaCredentialGeneration(account.credential), revision: JSON.stringify([account.loginId, account.pauseRevision, set.selectionRevision]) } : undefined;
+  if (owner?.root === next?.root && owner?.id === next?.id && owner?.generation === next?.generation && owner?.revision === next?.revision) return;
+  owner = next;
+  invalidateAntigravityQuota();
+}
+
+/** Epoch fences also retire outstanding probes on explicit cache/evidence invalidation. */
+export function invalidateAntigravityQuota(): void { epoch++; observations.clear(); }
+
+export function captureAntigravityReceipt(name: string, provider: OcxProviderConfig, id: string, generation: string): AntigravityQuotaReceipt | undefined {
+  if (!owner || owner.root !== getConfigDir() || owner.id !== id || owner.generation !== generation || !antigravityQuotaEligible(name, provider)) return undefined;
+  const token: AntigravityQuotaReceipt = Object.freeze({ kind: "antigravity" });
+  receipts.set(token, { ...owner, owner, name, policy: antigravityQuotaPolicy(name, provider), configGeneration: captureConfigGeneration(), epoch });
+  return token;
+}
+
+function current(receipt: Receipt): boolean {
+  return receipt.owner === owner && receipt.root === getConfigDir() && receipt.epoch === epoch && receipt.configGeneration === captureConfigGeneration();
+}
+
+/** Only accepted, live immutable receipts can retain omitted family rows; clocks never change. */
+export function replaceAntigravityQuotas(rows: readonly AntigravityQuotaObservation[]): void {
+  const next = new Map<string, { receipt: Receipt; windows: readonly DecisionQuotaWindow[] }>();
+  for (const row of rows.slice(0, 256)) {
+    const receipt = receipts.get(row.receipt);
+    if (!receipt) continue;
+    if (!current(receipt) || receipt.name !== row.name || !antigravityQuotaEligible(row.name, row.provider)
+      || receipt.policy !== antigravityQuotaPolicy(row.name, row.provider)) { receipts.delete(row.receipt); continue; }
+    const previous = observations.get(receipt.name);
+    const fresh = row.windows.length > 64 ? [] : row.windows.filter(window => window.family === "gem" || window.family === "cla");
+    const retained = previous && current(previous.receipt) && previous.receipt.owner === receipt.owner && previous.receipt.policy === receipt.policy
+      ? previous.windows.filter(window => !fresh.some(value => value.family === window.family && value.window === window.window)) : [];
+    next.set(receipt.name, { receipt, windows: [...retained, ...fresh].map(window => ({ ...window })) });
+  }
+  observations = next;
+}
+
+export function readAntigravityQuota(name: string, provider: OcxProviderConfig): readonly DecisionQuotaWindow[] | undefined {
+  const row = observations.get(name);
+  if (!row || !current(row.receipt) || !antigravityQuotaEligible(name, provider) || row.receipt.policy !== antigravityQuotaPolicy(name, provider)) return undefined;
+  return row.windows.map(window => ({ ...window }));
+}

package/src/providers/quota-decision-publication.ts

@@ -35,6 +35,17 @@ export function providerDecisionWindows(quota: ProviderQuota): DecisionQuotaWind
   }
   return windows;
 }
+/** Antigravity family buckets: Gem/Cla are 5h counters, "(Weekly)" their weekly pair; per-model rows and other groups are display-only. */
+export function antigravityDecisionWindows(quota: ProviderQuota): DecisionQuotaWindow[] {
+  const windows: DecisionQuotaWindow[] = [];
+  for (const row of Array.isArray(quota.customWindows) ? quota.customWindows : []) {
+    const match = typeof row?.label === "string" && row.modelId === undefined ? /^(Gem|Cla)( \(Weekly\))?$/.exec(row.label) : null;
+    if (!match || !Number.isFinite(row.percent)) continue;
+    windows.push({ window: match[2] ? "weekly" : "5h", family: match[1] === "Gem" ? "gem" : "cla", percent: row.percent,
+      observedAt: quota.updatedAt, ...(row.resetAt !== undefined ? { resetAt: row.resetAt } : {}) });
+  }
+  return windows;
+}
 /** Publish decision windows for one Anthropic pool account, bound to its credential generation; a null quota publishes no windows. */
 export function publishAnthropicDecisionQuota(id: string, generation: string, quota: ProviderQuota | null, partial = false): void {
   if (!decisionQuotaSinkActive()) return;