@yansigit/opencodex 2.36.1-dev.20260829.47 → 2.36.1-dev.20260829.50

package/src/storage/policy.ts

@@ -8,7 +8,7 @@
  * Privacy: logs never include host paths, digests of file contents, or secrets.
  */
 import { resolveCodexHomeDir } from "../codex/home";
-import { loadConfig, saveConfigPreservingClaudeCode } from "../config";
+import { loadConfig, mutatePersistedConfig } from "../config";
 import type { StorageCleanupPolicy } from "../types";
 import {
   computePreviewDigest,
@@ -22,9 +22,21 @@ import {
   type CleanupResult,
   type ExecuteCleanupOptions,
 } from "./cleanup";
+import {
+  computeNextRun,
+  normalizeStorageCleanupPolicy,
+} from "./policy-input";
+export {
+  computeNextRun,
+  defaultStorageCleanupPolicy,
+  isValidPolicyTarget,
+  normalizeStorageCleanupPolicy,
+  parseStorageCleanupPolicyInput,
+  DEFAULT_ARCHIVED_BYTES_OVER,
+  DEFAULT_REMOVE_OLDEST_PERCENT,
+  type PolicySchedule,
+} from "./policy-input";
 
-export const DEFAULT_ARCHIVED_BYTES_OVER = 5 * 1024 ** 3; // 5 GiB
-export const DEFAULT_REMOVE_OLDEST_PERCENT = 25;
 export const BUSY_DEFER_MS = 15 * 60 * 1000;
 
 /** Optional sink so background policy writes stay synced with the live server config. */
@@ -36,8 +48,12 @@ export function setStorageCleanupPolicyLiveSink(
   livePolicySink = sink ?? undefined;
 }
 
-export type PolicySchedule = StorageCleanupPolicy["schedule"];
+function adoptStorageCleanupPolicy(policy: StorageCleanupPolicy): void {
+  livePolicySink?.(policy);
+}
+
 export type PolicyRunReason = "startup" | "schedule" | "manual";
+export type PolicyMetadataPersistenceError = "missing" | "invalid" | "conflict" | "write_failed";
 
 export type PolicySkipReason =
   | "disabled"
@@ -54,6 +70,7 @@ export interface PolicyRunResult {
   freedBytes?: number;
   removed?: number;
   trashDir?: string;
+  metadataPersistenceError?: PolicyMetadataPersistenceError;
   policy: StorageCleanupPolicy;
 }
 
@@ -76,206 +93,20 @@ export interface PolicyRunDeps {
   onPolicyLoaded?: () => void;
 }
 
-/** Canonical defaults — enabled is always false. */
-export function defaultStorageCleanupPolicy(): StorageCleanupPolicy {
-  return {
-    enabled: false,
-    trigger: { archivedBytesOver: DEFAULT_ARCHIVED_BYTES_OVER },
-    target: { removeOldestPercent: DEFAULT_REMOVE_OLDEST_PERCENT },
-    schedule: "manual",
-    mode: "quarantine",
-  };
-}
-
-function isFiniteNonNegInt(n: unknown): n is number {
-  return typeof n === "number" && Number.isFinite(n) && n >= 0 && Math.floor(n) === n;
-}
-
-function isFinitePositiveInt(n: unknown): n is number {
-  return typeof n === "number" && Number.isFinite(n) && n > 0 && Math.floor(n) === n;
-}
-
-/** True when target has exactly one of reduceToBytes / removeOldestPercent. */
-export function isValidPolicyTarget(target: StorageCleanupPolicy["target"]): boolean {
-  if (!target || typeof target !== "object") return false;
-  const reduce = (target as { reduceToBytes?: unknown }).reduceToBytes;
-  const percent = (target as { removeOldestPercent?: unknown }).removeOldestPercent;
-  const hasReduce = reduce !== undefined;
-  const hasPercent = percent !== undefined;
-  if (hasReduce === hasPercent) return false; // none or both
-  if (hasReduce) return isFiniteNonNegInt(reduce);
-  return typeof percent === "number" && Number.isFinite(percent) && percent > 0 && percent <= 100;
-}
-
-/**
- * Normalize a partial/unknown policy into a complete StorageCleanupPolicy.
- * Never flips enabled to true unless the input explicitly sets enabled: true.
- */
-export function normalizeStorageCleanupPolicy(raw: unknown): StorageCleanupPolicy {
-  const base = defaultStorageCleanupPolicy();
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return base;
-  const o = raw as Record<string, unknown>;
-
-  // only explicit true enables — and never when a present target is malformed
-  let enabled = o.enabled === true;
-
-  let archivedBytesOver = base.trigger.archivedBytesOver;
-  if (o.trigger && typeof o.trigger === "object" && !Array.isArray(o.trigger)) {
-    const t = (o.trigger as { archivedBytesOver?: unknown }).archivedBytesOver;
-    if (isFiniteNonNegInt(t)) archivedBytesOver = t;
-  }
-
-  let target: StorageCleanupPolicy["target"] = base.target;
-  if (Object.prototype.hasOwnProperty.call(o, "target")) {
-    if (o.target && typeof o.target === "object" && !Array.isArray(o.target)) {
-      const candidate = o.target as StorageCleanupPolicy["target"];
-      if (isValidPolicyTarget(candidate)) {
-        const reduce = (candidate as { reduceToBytes?: number }).reduceToBytes;
-        const percent = (candidate as { removeOldestPercent?: number }).removeOldestPercent;
-        target = reduce !== undefined
-          ? { reduceToBytes: reduce }
-          : { removeOldestPercent: Math.min(100, Math.max(1, Math.floor(percent!))) };
-      } else {
-        // Fail closed: malformed persisted target must not become delete-oldest 25%.
-        enabled = false;
-      }
-    } else {
-      enabled = false;
-    }
-  }
-
-  const schedule: PolicySchedule =
-    o.schedule === "startup" || o.schedule === "daily" || o.schedule === "weekly" || o.schedule === "manual"
-      ? o.schedule
-      : base.schedule;
-
-  const mode: CleanupMode = o.mode === "permanent" ? "permanent" : "quarantine";
-
-  let lastRun: StorageCleanupPolicy["lastRun"];
-  if (o.lastRun && typeof o.lastRun === "object" && !Array.isArray(o.lastRun)) {
-    const lr = o.lastRun as Record<string, unknown>;
-    if (
-      isFinitePositiveInt(lr.at)
-      && isFiniteNonNegInt(lr.freedBytes)
-      && isFiniteNonNegInt(lr.removed)
-    ) {
-      lastRun = { at: lr.at, freedBytes: lr.freedBytes, removed: lr.removed };
-    }
-  }
-
-  let nextRun: number | undefined;
-  if (o.nextRun === undefined || o.nextRun === null) {
-    nextRun = undefined;
-  } else if (isFinitePositiveInt(o.nextRun)) {
-    nextRun = o.nextRun;
-  }
-
-  return {
-    enabled,
-    trigger: { archivedBytesOver },
-    target,
-    schedule,
-    mode,
-    ...(lastRun ? { lastRun } : {}),
-    ...(nextRun !== undefined ? { nextRun } : {}),
-  };
-}
-
-/**
- * Validate a PUT body. Returns a normalized policy or an error string.
- * Does not invent enabled=true.
- */
-export function parseStorageCleanupPolicyInput(
-  raw: unknown,
-  previous?: StorageCleanupPolicy,
-): { ok: true; policy: StorageCleanupPolicy } | { ok: false; error: string } {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    return { ok: false, error: "body must be a JSON object" };
-  }
-  const o = raw as Record<string, unknown>;
-  const prev = previous ?? defaultStorageCleanupPolicy();
-
-  if (o.enabled !== undefined && typeof o.enabled !== "boolean") {
-    return { ok: false, error: "enabled must be a boolean" };
-  }
-  if (o.mode !== undefined && o.mode !== "quarantine" && o.mode !== "permanent") {
-    return { ok: false, error: "mode must be quarantine or permanent" };
-  }
-  if (
-    o.schedule !== undefined
-    && o.schedule !== "startup"
-    && o.schedule !== "daily"
-    && o.schedule !== "weekly"
-    && o.schedule !== "manual"
-  ) {
-    return { ok: false, error: "schedule must be startup, daily, weekly, or manual" };
-  }
-
-  const merged: Record<string, unknown> = {
-    ...prev,
-    ...o,
-    trigger: o.trigger !== undefined ? o.trigger : prev.trigger,
-    target: o.target !== undefined ? o.target : prev.target,
-    // Preserve run metadata unless the client explicitly sends replacements.
-    lastRun: o.lastRun !== undefined ? o.lastRun : prev.lastRun,
-    nextRun: o.nextRun !== undefined ? o.nextRun : prev.nextRun,
-  };
-
-  if (o.trigger !== undefined) {
-    if (!o.trigger || typeof o.trigger !== "object" || Array.isArray(o.trigger)) {
-      return { ok: false, error: "trigger must be an object" };
-    }
-    const bytes = (o.trigger as { archivedBytesOver?: unknown }).archivedBytesOver;
-    if (!isFiniteNonNegInt(bytes)) {
-      return { ok: false, error: "trigger.archivedBytesOver must be a non-negative integer" };
-    }
-  }
-
-  if (o.target !== undefined) {
-    if (!isValidPolicyTarget(o.target as StorageCleanupPolicy["target"])) {
-      return {
-        ok: false,
-        error: "target must set exactly one of reduceToBytes (non-negative int) or removeOldestPercent (1-100)",
-      };
-    }
-  }
-
-  // Clients must not clear lastRun/nextRun via null unless intentional — accept omit only.
-  const policy = normalizeStorageCleanupPolicy(merged);
-  // Recompute nextRun only when schedule newly becomes timed, or no valid nextRun exists.
-  // Do not reset nextRun on every PUT that merely re-sends an unchanged schedule.
-  if (
-    (policy.schedule === "daily" || policy.schedule === "weekly")
-    && o.nextRun === undefined
-    && (policy.nextRun === undefined || (o.schedule !== undefined && o.schedule !== prev.schedule))
-  ) {
-    policy.nextRun = computeNextRun(policy.schedule, Date.now());
-  }
-  if (policy.schedule === "manual" || policy.schedule === "startup") {
-    if (o.nextRun === undefined) delete policy.nextRun;
-  }
-
-  return { ok: true, policy };
-}
-
 export function readStorageCleanupPolicyFromConfig(): StorageCleanupPolicy {
   return normalizeStorageCleanupPolicy(loadConfig().storageCleanupPolicy);
 }
 
 export function writeStorageCleanupPolicyToConfig(policy: StorageCleanupPolicy): StorageCleanupPolicy {
   const normalized = normalizeStorageCleanupPolicy(policy);
-  const config = loadConfig();
-  config.storageCleanupPolicy = normalized;
-  saveConfigPreservingClaudeCode(config);
-  livePolicySink?.(normalized);
-  return normalized;
-}
-
-/** Wall-clock next run for daily/weekly. Startup/manual → undefined. */
-export function computeNextRun(schedule: PolicySchedule, now: number): number | undefined {
-  if (schedule === "daily") return now + 24 * 60 * 60 * 1000;
-  if (schedule === "weekly") return now + 7 * 24 * 60 * 60 * 1000;
-  return undefined;
+  const outcome = mutatePersistedConfig(fresh => {
+    const changed = JSON.stringify(fresh.storageCleanupPolicy) !== JSON.stringify(normalized);
+    fresh.storageCleanupPolicy = normalized;
+    return { changed, value: structuredClone(normalized) };
+  });
+  if (outcome.status === "unavailable") throw new Error(`storage cleanup policy persistence unavailable: ${outcome.reason}`);
+  adoptStorageCleanupPolicy(outcome.value);
+  return outcome.value;
 }
 
 export function isPolicyDue(
@@ -401,6 +232,21 @@ export type PolicyRunMetadataPatch = {
   lastRun?: StorageCleanupPolicy["lastRun"];
 };
 
+/** Apply only run-owned fields while preserving the supplied policy settings. */
+function applyPolicyRunMetadata(
+  policy: StorageCleanupPolicy,
+  patch: PolicyRunMetadataPatch,
+): StorageCleanupPolicy {
+  let next =
+    patch.nextRun === "defer_busy"
+      ? deferBusy(policy, patch.now)
+      : advanceNextRun(policy, patch.now);
+  if (patch.lastRun) {
+    next = { ...next, lastRun: patch.lastRun };
+  }
+  return next;
+}
+
 /**
  * Reload the latest persisted policy and write only run-owned metadata
  * (`lastRun` / `nextRun`). Preserves concurrent edits to enabled, trigger,
@@ -412,17 +258,58 @@ export function commitPolicyRunMetadata(
   patch: PolicyRunMetadataPatch,
 ): StorageCleanupPolicy {
   const latest = normalizeStorageCleanupPolicy(load());
-  let next =
-    patch.nextRun === "defer_busy"
-      ? deferBusy(latest, patch.now)
-      : advanceNextRun(latest, patch.now);
-  if (patch.lastRun) {
-    next = { ...next, lastRun: patch.lastRun };
-  }
+  const next = applyPolicyRunMetadata(latest, patch);
   save(next);
   return next;
 }
 
+type PolicyRunMetadataCommit = {
+  policy: StorageCleanupPolicy;
+  persistenceError?: PolicyMetadataPersistenceError;
+};
+
+/** Attach the durable metadata outcome without replacing cleanup status or metrics. */
+function withMetadataCommit(
+  result: Omit<PolicyRunResult, "policy" | "metadataPersistenceError">,
+  committed: PolicyRunMetadataCommit,
+): PolicyRunResult {
+  return {
+    ...result,
+    policy: committed.policy,
+    ...(committed.persistenceError ? { metadataPersistenceError: committed.persistenceError } : {}),
+  };
+}
+
+/** Recompute run-owned metadata from the latest config inside the mutation lock. */
+function commitPolicyRunMetadataToConfig(
+  patch: PolicyRunMetadataPatch,
+  fallbackPolicy: StorageCleanupPolicy,
+): PolicyRunMetadataCommit {
+  const unavailable = (reason: PolicyMetadataPersistenceError): PolicyRunMetadataCommit => {
+    console.warn(`[storage-policy] metadata_persist_failed reason=${reason}`);
+    return {
+      policy: applyPolicyRunMetadata(fallbackPolicy, patch),
+      persistenceError: reason,
+    };
+  };
+  try {
+    const outcome = mutatePersistedConfig(config => {
+      const before = JSON.stringify(config.storageCleanupPolicy);
+      const next = applyPolicyRunMetadata(
+        normalizeStorageCleanupPolicy(config.storageCleanupPolicy),
+        patch,
+      );
+      config.storageCleanupPolicy = next;
+      return { changed: JSON.stringify(next) !== before, value: structuredClone(next) };
+    });
+    if (outcome.status === "unavailable") return unavailable(outcome.reason);
+    adoptStorageCleanupPolicy(outcome.value);
+    return { policy: outcome.value };
+  } catch {
+    return unavailable("write_failed");
+  }
+}
+
 function logPolicyEvent(message: string): void {
   console.log(`[storage-policy] ${message}`);
 }
@@ -434,10 +321,15 @@ function logPolicyEvent(message: string): void {
 export function runStorageCleanupPolicy(deps: PolicyRunDeps): PolicyRunResult {
   const now = deps.now ?? Date.now();
   const load = deps.loadPolicy ?? readStorageCleanupPolicyFromConfig;
-  const save = deps.savePolicy ?? writeStorageCleanupPolicyToConfig;
   const execute = deps.execute ?? executeArchivedCleanup;
-
   const policy = normalizeStorageCleanupPolicy(load());
+  // Injected stores retain the existing load/save contract. The production path
+  // recomputes metadata from the latest persisted policy inside the config lock.
+  const commitMetadata = deps.savePolicy !== undefined
+    ? (patch: PolicyRunMetadataPatch): PolicyRunMetadataCommit => ({
+        policy: commitPolicyRunMetadata(load, deps.savePolicy!, patch),
+      })
+    : (patch: PolicyRunMetadataPatch) => commitPolicyRunMetadataToConfig(patch, policy);
   deps.onPolicyLoaded?.();
 
   if (typeof deps.holdAfterLoadMs === "number" && Number.isFinite(deps.holdAfterLoadMs) && deps.holdAfterLoadMs > 0) {
@@ -454,15 +346,15 @@ export function runStorageCleanupPolicy(deps: PolicyRunDeps): PolicyRunResult {
 
   const selection = selectPolicyPreview(policy, deps.codexHome);
   if (selection.archivedBytes <= policy.trigger.archivedBytesOver) {
-    const saved = commitPolicyRunMetadata(load, save, { now, nextRun: "advance" });
+    const committed = commitMetadata({ now, nextRun: "advance" });
     logPolicyEvent("skip under_threshold");
-    return { ok: true, skipped: "under_threshold", policy: saved };
+    return withMetadataCommit({ ok: true, skipped: "under_threshold" }, committed);
   }
 
   if (selection.count === 0) {
-    const saved = commitPolicyRunMetadata(load, save, { now, nextRun: "advance" });
+    const committed = commitMetadata({ now, nextRun: "advance" });
     logPolicyEvent("skip nothing_selected");
-    return { ok: true, skipped: "nothing_selected", policy: saved };
+    return withMetadataCommit({ ok: true, skipped: "nothing_selected" }, committed);
   }
 
   const result = execute({
@@ -476,25 +368,28 @@ export function runStorageCleanupPolicy(deps: PolicyRunDeps): PolicyRunResult {
   });
 
   if (!result.ok && result.error === "codex_busy") {
-    const saved = commitPolicyRunMetadata(load, save, { now, nextRun: "defer_busy" });
+    const committed = commitMetadata({ now, nextRun: "defer_busy" });
     logPolicyEvent("defer codex_busy");
-    return { ok: false, deferred: "codex_busy", error: "codex_busy", policy: saved };
+    return withMetadataCommit({
+      ok: false,
+      deferred: "codex_busy",
+      error: "codex_busy",
+    }, committed);
   }
 
   if (!result.ok) {
     // Non-busy failure: still advance schedule so we do not tight-loop.
-    const saved = commitPolicyRunMetadata(load, save, { now, nextRun: "advance" });
+    const committed = commitMetadata({ now, nextRun: "advance" });
     logPolicyEvent(`fail ${result.error ?? "cleanup_failed"}`);
-    return {
+    return withMetadataCommit({
       ok: false,
       error: result.error,
       mode: result.mode,
       ...(result.trashDir ? { trashDir: result.trashDir } : {}),
-      policy: saved,
-    };
+    }, committed);
   }
 
-  const saved = commitPolicyRunMetadata(load, save, {
+  const committed = commitMetadata({
     now,
     nextRun: "advance",
     lastRun: {
@@ -506,14 +401,13 @@ export function runStorageCleanupPolicy(deps: PolicyRunDeps): PolicyRunResult {
   logPolicyEvent(
     `ok mode=${result.mode} removed=${result.count} freedBytes=${result.bytes}`,
   );
-  return {
+  return withMetadataCommit({
     ok: true,
     mode: result.mode,
     freedBytes: result.bytes,
     removed: result.count,
     ...(result.trashDir ? { trashDir: result.trashDir } : {}),
-    policy: saved,
-  };
+  }, committed);
 }
 
 /** Startup / schedule tick entry — swallows unexpected errors. */

package/src/usage/log.ts

@@ -8,22 +8,27 @@ import { sanitizeLogMetadataString } from "../lib/redact";
 import { usageDisplayTotalTokens } from "./totals";
 import type { AttemptTierOutcome, OcxUsage } from "../types";
 import { normalizeRouteDecisionTrace, type RouteDecisionTraceV1 } from "../routing/trace";
-import { CODEX_ACCOUNT_LOG_LABEL_RE } from "../codex/account-label";
+import { ACCOUNT_LOG_LABEL_RE, CODEX_ACCOUNT_LOG_LABEL_RE } from "../codex/account-label";
 import type { AgentKind } from "../server/effort-policy";
 
 export type UsageStatus = "reported" | "unreported" | "unsupported" | "estimated";
-export type CodexUsageAccountLogLabel = "main" | `p${string}`;
+export type UsageAccountLogLabel = "main" | `p${string}` | `o${string}`;
+export type CodexUsageAccountLogLabel = UsageAccountLogLabel;
 
 export const OAUTH_ACCOUNT_LOG_LABEL_RE = /^[a-f0-9]{8,64}(?:-\d+)?$/;
 
 export function isPersistableAccountLogLabel(value: unknown): value is string {
   return (
-    value === "main"
-    || (typeof value === "string" && (CODEX_ACCOUNT_LOG_LABEL_RE.test(value) || OAUTH_ACCOUNT_LOG_LABEL_RE.test(value)))
+    typeof value === "string"
+    && (ACCOUNT_LOG_LABEL_RE.test(value) || OAUTH_ACCOUNT_LOG_LABEL_RE.test(value))
   );
 }
 
-export function isCodexUsageAccountLogLabel(value: unknown): value is CodexUsageAccountLogLabel {
+export function isCodexUsageAccountLogLabel(value: unknown): value is UsageAccountLogLabel {
+  return typeof value === "string" && ACCOUNT_LOG_LABEL_RE.test(value);
+}
+
+export function isCodexPoolAccountLogLabel(value: unknown): value is "main" | `p${string}` {
   return value === "main" || (typeof value === "string" && CODEX_ACCOUNT_LOG_LABEL_RE.test(value));
 }
 
@@ -63,6 +68,13 @@ export interface PersistedUsageAttempt {
   sendCount: number;
   recoveryKinds: AttemptRecoveryKind[];
   usageStatus: UsageStatus;
+  /**
+   * True when the proxy answered this turn locally and issued no upstream request. It travels on
+   * the attempt itself rather than as a `finishRequestAttempt` argument because that function is
+   * called from six places, and a new parameter would silently default to the wrong answer at any
+   * one of them that was missed. Absent on ordinary attempts so old rows keep their exact shape.
+   */
+  locallyAnswered?: boolean;
   /** Stable non-PII identity for the account that served this attempt. */
   accountLogLabel?: string;
   inputTokenEstimate?: number;
@@ -200,8 +212,20 @@ function isEstimatedUsageProvider(providerOrAdapter: string): boolean {
     || providerOrAdapter === "cursor" || providerOrAdapter.startsWith("cursor-");
 }
 
-export function usageForFinalLog(provider: string, usage: OcxUsage | undefined): OcxUsage | undefined {
+export function usageForFinalLog(
+  provider: string,
+  usage: OcxUsage | undefined,
+  /**
+   * True when the proxy answered this turn locally and issued no upstream request. Such a turn's
+   * zero counts are EXACT, so the provider-wide estimated marking must not apply: Kiro and Cursor
+   * are marked estimated because their adapters can only guess a real inference's usage, and a
+   * turn with no inference has nothing to guess. Without this, a no-send turn is indistinguishable
+   * from a real one whose usage frame never arrived.
+   */
+  locallyAnswered = false,
+): OcxUsage | undefined {
   if (!usage) return undefined;
+  if (locallyAnswered) return usage;
   if (usage.estimated || isEstimatedUsageProvider(provider)) return { ...usage, estimated: true };
   return usage;
 }
@@ -239,6 +263,8 @@ const ATTEMPT_RECOVERY_KINDS = new Set<AttemptRecoveryKind>([
   "key-429",
   "rate-limit-429",
   "anthropic-oauth-429",
+  "cursor-oauth-auth",
+  "cursor-oauth-429",
   "oauth-account-429",
   "image-413",
   "opaque-blob-rejection",

package/src/usage/summary.ts

@@ -94,7 +94,6 @@ export interface UsageProvider {
 
 export interface UsageAccount {
   accountLogLabel: string;
-  provider?: string;
   ambiguous: boolean;
   requests: number;
   attemptCount: number;
@@ -685,25 +684,22 @@ function legacyCodexAccountLabel(provider: string): string | null {
   return suffix ?? LEGACY_AMBIGUOUS_ACCOUNT_LABEL;
 }
 
-export function accountLabelForAttribution(
-  provider: string,
-  explicit: unknown,
-  fallbackAccountByProvider?: Record<string, string>,
-): string | null {
-  if (typeof explicit === "string" && explicit.trim().length > 0) return explicit.trim();
-  const legacy = legacyCodexAccountLabel(provider);
-  if (legacy) return legacy;
-  const base = baseProviderLabel(provider);
-  if (fallbackAccountByProvider && fallbackAccountByProvider[base]) {
-    return fallbackAccountByProvider[base];
-  }
-  return null;
+/**
+ * An explicitly stamped label of EITHER family is authoritative for any provider (#2699).
+ *
+ * No `o`-label branch is needed here: `isCodexUsageAccountLogLabel` now accepts both families,
+ * and adding a second predicate call would be a no-op guarded by a comment claiming otherwise.
+ *
+ * The legacy fallback stays openai-only on purpose. It infers an account from the PROVIDER
+ * string, and inferring for a non-Codex row would merge unrelated accounts under one label --
+ * so an unlabeled xai row is dropped from the account table rather than guessed at.
+ */
+function accountLabelForAttribution(provider: string, explicit: unknown): string | null {
+  if (isCodexUsageAccountLogLabel(explicit)) return explicit;
+  return legacyCodexAccountLabel(provider);
 }
 
-function buildAccounts(
-  entries: PersistedUsageEntry[],
-  fallbackAccountByProvider?: Record<string, string>,
-): UsageAccount[] {
+function buildAccounts(entries: PersistedUsageEntry[]): UsageAccount[] {
   const byLabel = new Map<string, UsageAccount>();
   const requestIds = new Map<string, Set<string>>();
 
@@ -716,13 +712,12 @@ function buildAccounts(
     totalTokens?: number;
     estimate: ReturnType<typeof estimateRequestCost>;
   }): void => {
-    const label = accountLabelForAttribution(input.provider, input.accountLogLabel, fallbackAccountByProvider);
+    const label = accountLabelForAttribution(input.provider, input.accountLogLabel);
     if (!label) return;
     let row = byLabel.get(label);
     if (!row) {
       row = {
         accountLogLabel: label,
-        provider: baseProviderLabel(input.provider),
         ambiguous: label === LEGACY_AMBIGUOUS_ACCOUNT_LABEL,
         requests: 0,
         attemptCount: 0,
@@ -823,7 +818,6 @@ export function summarizeUsage(
   range: UsageRange,
   now: number,
   surface: UsageSurface = "all",
-  fallbackAccountByProvider?: Record<string, string>,
 ): UsageSummary {
   const { since } = rangeWindow(range, now);
   const filteredEntries = entries.filter(entry => {
@@ -853,7 +847,7 @@ export function summarizeUsage(
     days: buildDayGrid(range, since, now, filteredEntries),
     models: buildModels(filteredEntries, totals.totalTokens),
     providers: buildProviders(filteredEntries, totals.totalTokens),
-    accounts: buildAccounts(filteredEntries, fallbackAccountByProvider),
+    accounts: buildAccounts(filteredEntries),
   };
 }
 
@@ -885,14 +879,12 @@ function normalizeFilterValue(input: string | null | undefined): string | null {
  */
 export function projectUsageSummary<T extends UsageSummary>(
   summary: T,
-  filter: { provider?: string | null; model?: string | null; account?: string | null },
+  filter: { provider?: string | null; model?: string | null },
   entries?: PersistedUsageEntry[],
-  fallbackAccountByProvider?: Record<string, string>,
 ): T & { filter?: UsageFilterEcho } {
   const provider = normalizeFilterValue(filter.provider);
   const model = normalizeFilterValue(filter.model);
-  const account = normalizeFilterValue(filter.account);
-  if (provider === null && model === null && account === null) return summary;
+  if (provider === null && model === null) return summary;
 
   // Re-summarise from the entries the summary was built from, rather than
   // projecting over its rows.
@@ -909,13 +901,9 @@ export function projectUsageSummary<T extends UsageSummary>(
   //
   // The entries are already in hand on every path that filters, so the honest
   // computation is also the simple one.
-  const matches = (rowProvider: string, rowModel: string, rowAccount?: string | null): boolean => {
+  const matches = (rowProvider: string, rowModel: string): boolean => {
     if (provider !== null && baseProviderLabel(rowProvider).toLowerCase() !== provider) return false;
     if (model !== null && rowModel.toLowerCase() !== model) return false;
-    if (account !== null && rowAccount !== undefined) {
-      const effectiveAccount = accountLabelForAttribution(rowProvider, rowAccount, fallbackAccountByProvider);
-      if (!effectiveAccount || effectiveAccount.toLowerCase() !== account) return false;
-    }
     return true;
   };
 
@@ -931,10 +919,10 @@ export function projectUsageSummary<T extends UsageSummary>(
   const filtered: PersistedUsageEntry[] = [];
   for (const entry of source) {
     if (!entry.attempts?.length) {
-      if (matches(entry.provider, antigravityUsageModel(entry.provider, entry.model), entry.accountLogLabel)) filtered.push(entry);
+      if (matches(entry.provider, antigravityUsageModel(entry.provider, entry.model))) filtered.push(entry);
       continue;
     }
-    const attempts = entry.attempts.filter(a => matches(a.provider, antigravityUsageModel(a.provider, a.model), a.accountLogLabel ?? entry.accountLogLabel));
+    const attempts = entry.attempts.filter(a => matches(a.provider, antigravityUsageModel(a.provider, a.model)));
     if (attempts.length === 0) continue;
     // A combo is still counted once per participating model, so a filtered
     // request count can exceed the number of distinct requests. That is the
@@ -943,7 +931,7 @@ export function projectUsageSummary<T extends UsageSummary>(
     filtered.push({ ...entry, attempts });
   }
 
-  const projected = summarizeUsage(filtered, summary.range, summary.generatedAt, summary.surface, fallbackAccountByProvider);
+  const projected = summarizeUsage(filtered, summary.range, summary.generatedAt, summary.surface);
   // matched reflects usage inside the requested WINDOW, not anywhere in the
   // log: summarizeUsage applies the range and surface predicates, and the CLI
   // uses this flag to decide between a table and "no usage recorded".