tokentracker-cli 1.5.1 → 1.5.3

package/src/lib/codex-rollout-parser.js

@@ -34,6 +34,7 @@ const { readCodexServiceTier, isPriorityServiceTier, isUltrafastServiceTier } =
 const {
   createUsageRecordState,
   extractTokenUsageRecord,
+  isCodexTotalOnlyResetSentinel,
   noteLineAfterUsageRecord,
   noteTokenCount,
   noteUsageRecord,
@@ -72,6 +73,11 @@ const CODEX_RESUME_INVALIDATED = "TOKENTRACKER_CODEX_RESUME_INVALIDATED";
 // input (including cache), not the accumulated session or day totals.
 const OPENAI_LONG_CONTEXT_INPUT_THRESHOLD = 272_000;
 
+// Session token summaries use the same fork-prefix rules as rollout.js; the
+// reset-sentinel predicate is shared verbatim from codex-usage-record.js.
+// Context/performance callers retain their existing event view.
+const LEDGER_FORK_REPLAY_GAP_MS = 500;
+
 // ---------------------------------------------------------------------------
 // Timezone helpers
 // ---------------------------------------------------------------------------
@@ -461,7 +467,7 @@ function formatToolDisplayName(name) {
 // Usage normalization
 // ---------------------------------------------------------------------------
 
-function normalizeUsage(u) {
+function normalizeUsage(u, { preserveReportedTotal = false } = {}) {
   const out = {};
   for (const k of [
     "input_tokens",
@@ -477,7 +483,7 @@ function normalizeUsage(u) {
   // Codex reports input inclusive of cached_input_tokens; keep our schema
   // convention: non-cached input and cached input tracked separately.
   out.input_tokens = Math.max(0, out.input_tokens - out.cached_input_tokens);
-  out.total_tokens =
+  if (!preserveReportedTotal) out.total_tokens =
     out.input_tokens +
     out.cached_input_tokens +
     out.cache_creation_input_tokens +
@@ -596,6 +602,7 @@ async function parseCodexRolloutFile(filePath, {
   sourceHandle = null,
   collectBreakdowns = true,
   collectModelUsage = false,
+  ledgerUsage = false,
   onObject = null,
   onUsage = null,
 } = {}) {
@@ -638,6 +645,12 @@ async function parseCodexRolloutFile(filePath, {
   let provider = isResuming ? resumeState.provider || null : null;
   let cliVersion = isResuming ? resumeState.cliVersion || null : null;
   let forkedFromId = isResuming ? resumeState.forkedFromId || null : null;
+  const ledgerRolloutDate = path.basename(primaryFilePath).match(/^rollout-(\d{4}-\d{2}-\d{2})T/)?.[1] || null;
+  let ledgerCurrentDate = null;
+  // Same gating as rollout.js: the replay prefix only ever sits at the head of
+  // a freshly-forked file, so only a scan from offset 0 can see it.
+  let ledgerReplayActive = initialOffset === 0;
+  let ledgerPreviousTokenMs = null;
   let parentThreadId = isResuming ? resumeState.parentThreadId || null : null;
   let threadSource = isResuming ? resumeState.threadSource || null : null;
   let agentNickname = isResuming ? resumeState.agentNickname || null : null;
@@ -1050,6 +1063,9 @@ async function parseCodexRolloutFile(filePath, {
     contentHasher,
     sourceHandle,
   })) {
+    if (ledgerUsage && obj?.type === "turn_context" && typeof obj?.payload?.current_date === "string") {
+      ledgerCurrentDate = obj.payload.current_date.trim().match(/^(\d{4}-\d{2}-\d{2})/)?.[1] || null;
+    }
     const modelEvent = applyCodexModelEvent(modelAttributionState, obj);
     const attributedModel = currentCodexModel(modelAttributionState);
     model = attributedModel || model;
@@ -1114,7 +1130,7 @@ async function parseCodexRolloutFile(filePath, {
     }
 
     if (usageRecord) {
-      const delta = normalizeUsage(usageRecord.usage);
+      const delta = normalizeUsage(usageRecord.usage, { preserveReportedTotal: ledgerUsage });
       noteUsageRecord(
         usageRecordState,
         // Without a response_id a compaction cannot be deduplicated.
@@ -1147,15 +1163,36 @@ async function parseCodexRolloutFile(filePath, {
         );
       }
       const rawDelta = consumeUsageDelta(usageDeltaState, lastUsage, totalUsage);
-      const delta = rawDelta ? normalizeUsage(rawDelta) : null;
+      const delta = rawDelta && !(ledgerUsage && isCodexTotalOnlyResetSentinel(lastUsage, totalUsage))
+        ? normalizeUsage(rawDelta, { preserveReportedTotal: ledgerUsage }) : null;
       // Timing consumers receive canonical, deduplicated usage below. A null
       // delta is a snapshot, not another model response.
       if (compaction) countCompactionRecord(compaction);
       const isNewResumeEvent = noteTokenEvent(ts, lastUsage, totalUsage);
       if (inRequestedRange) {
         const eventSessionId = sessionId || rolloutSessionIdFromPath(primaryFilePath) || primaryFilePath;
-        const eventKey = `${eventSessionId}:${ts}:${usageEventSignature(lastUsage, totalUsage)}`;
-        if (!isNewResumeEvent || (seenTokenEvents && seenTokenEvents.has(eventKey))) {
+        const eventKey = ledgerUsage ? `${eventSessionId}:${ts}`
+          : `${eventSessionId}:${ts}:${usageEventSignature(lastUsage, totalUsage)}`;
+        const alreadySeen = seenTokenEvents && seenTokenEvents.has(eventKey);
+        let replayed = false;
+        if (ledgerUsage && forkedFromId && delta?.total_tokens > 0) {
+          if (ledgerReplayActive) {
+            const tokenMs = Date.parse(ts);
+            if (!Number.isFinite(tokenMs) || (ledgerPreviousTokenMs !== null && tokenMs < ledgerPreviousTokenMs)) {
+              ledgerReplayActive = false;
+            } else {
+              if (ledgerPreviousTokenMs !== null && tokenMs - ledgerPreviousTokenMs >= LEDGER_FORK_REPLAY_GAP_MS) ledgerReplayActive = false;
+              replayed = ledgerReplayActive && ledgerPreviousTokenMs !== null
+                && tokenMs - ledgerPreviousTokenMs < LEDGER_FORK_REPLAY_GAP_MS;
+              ledgerPreviousTokenMs = tokenMs;
+            }
+          }
+          replayed ||= Boolean(ledgerRolloutDate && ledgerCurrentDate && ledgerCurrentDate < ledgerRolloutDate);
+        }
+        // Remember skipped inherited rows too: another readable copy of the
+        // same session must not reintroduce its prefix after the first live turn.
+        if (ledgerUsage && seenTokenEvents && delta?.total_tokens > 0) seenTokenEvents.add(eventKey);
+        if (!isNewResumeEvent || alreadySeen || replayed) {
           if (typeof onUsage === "function") onUsage({ timestamp: ts, delta: null, rawUsage: lastUsage, model: attributedModel });
           attributeTurn(null);
         } else {

package/src/lib/codex-usage-record.js

@@ -176,6 +176,26 @@ function formatRecordOnlyWarning(count) {
   return `${count} Codex session(s) report usage only via token_usage_record; not counted yet (see #652)`;
 }
 
+// A reset sentinel is a token_count whose total drops to exact zero while the
+// previous total was positive and every component of both snapshots is zero —
+// Codex restarting a session's cumulative counters, not a real response. Both
+// the hourly ledger (rollout.js) and the session ledger mode
+// (codex-rollout-parser.js) must reject it identically, so the predicate lives
+// here as the single copy of the rule.
+function isCodexTotalOnlyResetSentinel(lastUsage, totalUsage) {
+  const componentTotal = (usage) => [
+    usage?.input_tokens,
+    usage?.cached_input_tokens,
+    usage?.cache_creation_input_tokens ?? usage?.cache_write_input_tokens,
+    usage?.output_tokens,
+    usage?.reasoning_output_tokens,
+  ].reduce((sum, value) => sum + Math.max(0, Number(value) || 0), 0);
+  return Number(lastUsage?.total_tokens || 0) > 0
+    && Number(totalUsage?.total_tokens || 0) === 0
+    && componentTotal(lastUsage) === 0
+    && componentTotal(totalUsage) === 0;
+}
+
 module.exports = {
   MAX_COMPACTION_RESPONSE_IDS,
   createCompactionResponseIds,
@@ -184,6 +204,7 @@ module.exports = {
   awaitsCompactedLine,
   createUsageRecordState,
   extractTokenUsageRecord,
+  isCodexTotalOnlyResetSentinel,
   isCodexTurnEndEvent,
   isRecordOnly,
   noteLineAfterUsageRecord,

package/src/lib/deepseek-status.js

@@ -0,0 +1,157 @@
+// DeepSeek service-status probe.
+//
+// status.deepseek.com is a Flashcat(快猫)-hosted Next.js app. Unlike Statuspage.io
+// it exposes no public JSON API and sends no CORS headers, so a browser cannot
+// read it directly. The page state is, however, inlined in the server render as
+// React Server Component "flight" data: the client script pushes JSON chunks via
+// self.__next_f.push([1, "<json string>"]). We concatenate those chunks and read
+// the single machine-readable signal — the live `active_changes` array.
+//
+// Semantics (Flashcat change status -> Statuspage.io indicator):
+//   operational                                      -> none
+//   degraded / degraded_performance / maintenance    -> minor
+//   partial_outage                                   -> major
+//   major_outage / full_outage                       -> critical
+// An empty active_changes array means everything is operational. Anything we
+// cannot parse throws, so the caller falls back instead of inventing "all good".
+
+const DEEPSEEK_STATUS_URL = "https://status.deepseek.com/";
+
+const RSC_PUSH_RE = /self\.__next_f\.push\(\[1,("(?:[^"\\]|\\.)*")\]\)/g;
+
+const CHANGE_STATUS_TO_INDICATOR = {
+  operational: "none",
+  degraded: "minor",
+  degraded_performance: "minor",
+  maintenance: "minor",
+  under_maintenance: "minor",
+  partial_outage: "major",
+  major_outage: "critical",
+  full_outage: "critical",
+  outage: "critical",
+};
+
+const INDICATOR_RANK = { none: 0, minor: 1, major: 2, critical: 3 };
+
+function extractFlight(html) {
+  if (typeof html !== "string" || html.length === 0) {
+    throw new Error("DeepSeek status: expected an HTML document");
+  }
+  let flight = "";
+  let chunks = 0;
+  RSC_PUSH_RE.lastIndex = 0;
+  let match;
+  while ((match = RSC_PUSH_RE.exec(html))) {
+    try {
+      flight += JSON.parse(match[1]);
+    } catch (_error) {
+      throw new Error("DeepSeek status: malformed RSC chunk");
+    }
+    chunks += 1;
+  }
+  if (chunks === 0) {
+    throw new Error("DeepSeek status: no RSC data found");
+  }
+  return flight;
+}
+
+// Return the balanced JSON array that starts at `start` (a '[' in flight).
+function sliceJsonArray(flight, start) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < flight.length; i += 1) {
+    const ch = flight[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "[") depth += 1;
+    else if (ch === "]") {
+      depth -= 1;
+      if (depth === 0) return flight.slice(start, i + 1);
+    }
+  }
+  throw new Error("DeepSeek status: unterminated active_changes array");
+}
+
+function readUpdatedAt(flight) {
+  const match = /"initialDataUpdatedAt":(\d{10,})/.exec(flight);
+  if (!match) return undefined;
+  const ms = Number(match[1]);
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : undefined;
+}
+
+/**
+ * Parse the status.deepseek.com HTML into a Statuspage.io-shaped payload:
+ *   { status: { indicator, description }, page: { updated_at } }
+ * Throws when the page structure is not understood, so callers fall back
+ * instead of reporting a false "operational".
+ */
+function parseDeepSeekStatusPage(html) {
+  const flight = extractFlight(html);
+  const marker = '"active_changes":';
+  const markerIndex = flight.indexOf(marker);
+  if (markerIndex === -1) {
+    throw new Error("DeepSeek status: active_changes not found");
+  }
+  // The value must be an array. If upstream ever reports null / an object /
+  // anything else, refuse to guess a healthier-looking array further along the
+  // document — throwing keeps the caller on its last-good / "unknown" path
+  // instead of inventing a false "operational".
+  let arrayStart = markerIndex + marker.length;
+  while (arrayStart < flight.length && /\s/.test(flight[arrayStart])) arrayStart += 1;
+  if (flight[arrayStart] !== "[") {
+    throw new Error("DeepSeek status: active_changes is not an array");
+  }
+  let changes;
+  try {
+    changes = JSON.parse(sliceJsonArray(flight, arrayStart));
+  } catch (error) {
+    throw new Error("DeepSeek status: cannot parse active_changes (" + error.message + ")");
+  }
+  if (!Array.isArray(changes)) {
+    throw new Error("DeepSeek status: active_changes is not an array");
+  }
+
+  const updatedAt = readUpdatedAt(flight);
+  if (changes.length === 0) {
+    return { status: { indicator: "none", description: "" }, page: { updated_at: updatedAt } };
+  }
+
+  let worstIndicator = "none";
+  let worstRank = -1;
+  let descriptions = [];
+  for (const change of changes) {
+    if (!change || typeof change !== "object") continue;
+    const rawStatus = String(change.status || change.change_status || change.impact || "").toLowerCase();
+    const indicator = CHANGE_STATUS_TO_INDICATOR[rawStatus] || "minor";
+    const rank = INDICATOR_RANK[indicator];
+    const description = typeof change.name === "string" ? change.name
+      : typeof change.title === "string" ? change.title
+      : typeof change.description === "string" ? change.description
+      : "";
+    if (rank > worstRank) {
+      worstRank = rank;
+      worstIndicator = indicator;
+      descriptions = description ? [description] : [];
+    } else if (rank === worstRank && description) {
+      descriptions.push(description);
+    }
+  }
+  // A non-empty array with no readable change is still "something is wrong".
+  if (worstRank < 0) worstIndicator = "minor";
+
+  return {
+    status: { indicator: worstIndicator, description: descriptions.join("; ") },
+    page: { updated_at: updatedAt },
+  };
+}
+
+module.exports = {
+  parseDeepSeekStatusPage,
+  DEEPSEEK_STATUS_URL,
+};

package/src/lib/local-api.js

@@ -20,6 +20,7 @@ const { createCloudDeviceTokenStore } = require("./cloud-device-token");
 const { parseBearerToken } = require("./bearer-token");
 const { writeJsonAtomicSync } = require("./atomic-json");
 const { createLocalUsageTransfer, MAX_BYTES: LOCAL_USAGE_MAX_BYTES } = require("./local-usage-transfer");
+const { fetchProviderServiceStatus } = require("./provider-status");
 
 const SYNC_TIMEOUT_MS = 120_000;
 // A failed account-view request should not stall every dashboard refresh
@@ -1677,6 +1678,32 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
 
   return async function handleLocalApi(req, res, url) {
     const p = url.pathname;
+    // status.deepseek.com has no public JSON API or CORS, so the dashboard
+    // cannot probe it like the other providers. Relay it through the local app:
+    // fetchProviderServiceStatus("deepseek") fetches + parses the server-rendered
+    // page (with a 5-minute cache and 6s timeout in provider-status.js) and we
+    // return a Statuspage.io-shaped payload the existing dashboard parser reads.
+    if (p === "/api/deepseek-status") {
+      const method = String(req.method || "GET").toUpperCase();
+      if (method !== "GET" && method !== "HEAD") {
+        json(res, { error: "Method Not Allowed" }, 405);
+        return true;
+      }
+      try {
+        const reading = await fetchProviderServiceStatus("deepseek");
+        if (!reading) {
+          json(res, { error: "DeepSeek status unavailable" }, 502);
+          return true;
+        }
+        json(res, {
+          page: { updated_at: reading.updated_at },
+          status: { indicator: reading.indicator, description: reading.description || "" },
+        });
+      } catch (error) {
+        json(res, { error: `DeepSeek status probe error: ${error?.message || error}` }, 502);
+      }
+      return true;
+    }
     if (p === "/api/local-usage") {
       if (!isAuthorizedLocalMutation(req)) { json(res, { code: "unauthorized" }, 401); return true; }
       try {
@@ -2718,7 +2745,7 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
         const src = row.source || "unknown";
         const mdl = row.model || "unknown";
         if (!bySource.has(src))
-          bySource.set(src, { source: src, source_scope: getSourceScope(src), totals: { total_tokens: 0, billable_total_tokens: 0, input_tokens: 0, output_tokens: 0, cached_input_tokens: 0, cache_creation_input_tokens: 0, reasoning_output_tokens: 0, total_cost_usd: "0" }, models: new Map() });
+          bySource.set(src, { source: src, source_scope: getSourceScope(src), totals: { total_tokens: 0, billable_total_tokens: 0, input_tokens: 0, output_tokens: 0, cached_input_tokens: 0, cache_creation_input_tokens: 0, reasoning_output_tokens: 0, conversation_count: 0, total_cost_usd: "0" }, models: new Map() });
         const sa = bySource.get(src);
         sa.totals.total_tokens += row.total_tokens || 0;
         sa.totals.billable_total_tokens += row.billable_total_tokens ?? row.total_tokens ?? 0;
@@ -2727,8 +2754,12 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
         sa.totals.cached_input_tokens += row.cached_input_tokens || 0;
         sa.totals.cache_creation_input_tokens += row.cache_creation_input_tokens || 0;
         sa.totals.reasoning_output_tokens += row.reasoning_output_tokens || 0;
+        // Request-only sources (#948: credit-billed transcripts that report no
+        // tokens) carry their activity solely as conversation_count — thread it
+        // through so the dashboard can surface "0 tokens / N requests".
+        sa.totals.conversation_count += row.conversation_count || 0;
         if (!sa.models.has(mdl))
-          sa.models.set(mdl, { model: mdl, model_id: mdl, pricing: getModelPricingInfo(mdl, { source: src }), totals: { total_tokens: 0, billable_total_tokens: 0, input_tokens: 0, output_tokens: 0, cached_input_tokens: 0, cache_creation_input_tokens: 0, reasoning_output_tokens: 0, total_cost_usd: "0" } });
+          sa.models.set(mdl, { model: mdl, model_id: mdl, pricing: getModelPricingInfo(mdl, { source: src }), totals: { total_tokens: 0, billable_total_tokens: 0, input_tokens: 0, output_tokens: 0, cached_input_tokens: 0, cache_creation_input_tokens: 0, reasoning_output_tokens: 0, conversation_count: 0, total_cost_usd: "0" } });
         const ma = sa.models.get(mdl);
         const reportedCost = ["grok", "cline"].includes(src) && Number(row.total_cost_usd) > 0;
         const costSource = reportedCost ? "provider_reported" : "model_pricing";
@@ -2740,6 +2771,7 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
         ma.totals.cached_input_tokens += row.cached_input_tokens || 0;
         ma.totals.cache_creation_input_tokens += row.cache_creation_input_tokens || 0;
         ma.totals.reasoning_output_tokens += row.reasoning_output_tokens || 0;
+        ma.totals.conversation_count += row.conversation_count || 0;
         // Price each row, exactly as aggregateByDay does for the hero (#653).
         // computeRowCost is not linear for models with a Fast tier or
         // long-context rates: priority_* / long_context_* mark a subset of the
@@ -3672,7 +3704,7 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
 
     // --- usage-limits ---
     if (p === "/functions/tokentracker-usage-limits") {
-      const { getUsageLimits, resetUsageLimitsCache } = require("./usage-limits");
+      const { getUsageLimits, resetUsageLimitsCache, normalizeHiddenProviders } = require("./usage-limits");
       try {
         // Devin quota is opt-in (Settings > Usage & Limits > Providers). An
         // explicit devin=1 without local authentication is rejected before any
@@ -3683,7 +3715,14 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
         const localAuthorized = isAuthorizedLocalMutation(req);
         const devinParam = url.searchParams.get("devin");
         const devinEnabled = devinParam === "1" || devinParam === "true";
-        if (devinEnabled && !localAuthorized) {
+        // Provider visibility gate (#956): hidden=<csv> names provider rows to
+        // skip entirely — no upstream call, no credential read. Like devin=1,
+        // an explicit list is honored only together with the loopback auth
+        // header (letting an unauthenticated caller scope the fetch would let
+        // it pick exactly which credentials to leave alone). Unknown ids are
+        // dropped by the normalizer, so the gate only ever narrows.
+        const hiddenProviders = normalizeHiddenProviders(url.searchParams.get("hidden"));
+        if ((devinEnabled || hiddenProviders) && !localAuthorized) {
           json(res, { error: "Unauthorized" }, 401);
           return true;
         }
@@ -3701,6 +3740,7 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
           // cooldown) — an explicit user refresh should hit upstream.
           forceRefresh,
           devinEnabled,
+          hiddenProviders,
         });
         json(res, data);
       } catch (e) {

package/src/lib/pricing/curated-overrides.json

@@ -75,6 +75,27 @@
       "cache_write": 6.25,
       "note": "Opus 4.8 not yet in LiteLLM. Pin to the standard Opus tier (same as 4.6/4.7); remove once LiteLLM carries it."
     },
+    "claude-opus-4-5": {
+      "input": 5,
+      "output": 25,
+      "cache_read": 0.5,
+      "cache_write": 6.25,
+      "note": "Canonical undated Opus 4.5 alias (LiteLLM bare key, sourced from https://platform.claude.com/docs/en/about-claude/pricing, cached 2026-10-31): standard Opus tier $5/$25 per MTok, cache_read 0.1x, cache_write 1.25x — same rates as claude-opus-4-5-20250414. Previously LiteLLM-only; promoted so cloud account views price the bare id (issue #929)."
+    },
+    "claude-opus-4-6": {
+      "input": 5,
+      "output": 25,
+      "cache_read": 0.5,
+      "cache_write": 6.25,
+      "note": "Opus 4.6 standard tier (LiteLLM entry sourced from https://platform.claude.com/docs/en/about-claude/pricing, cached 2026-10-31): $5/$25 per MTok, cache_read 0.1x, cache_write 1.25x. The edge table pins the same rate; curated pins it so local billing and -thinking variants no longer depend on LiteLLM fuzzy matching (issue #929)."
+    },
+    "claude-sonnet-4-6": {
+      "input": 3,
+      "output": 15,
+      "cache_read": 0.3,
+      "cache_write": 3.75,
+      "note": "Sonnet 4.6 standard tier (LiteLLM entry sourced from https://platform.claude.com/docs/en/about-claude/pricing, cached 2026-10-31): $3/$15 per MTok, cache_read 0.1x, cache_write 1.25x. The edge table pins the same rate; curated pins it so local billing no longer depends on the LiteLLM cache (issue #929)."
+    },
     "claude-sonnet-5": {
       "input": 2,
       "output": 10,
@@ -137,6 +158,13 @@
       "priority_multiplier": 2,
       "note": "Official Standard USD/MTok rates verified 2026-09-24: https://developers.openai.com/api/docs/models/gpt-6-sol. Same rules as gpt-6-astra: requests above 272K input tokens use 2x input/cache and 1.5x output for the full request, applied only to observed long-context request subsets; Fast mode is published as 2x the applicable rates (priority_multiplier). Reasoning-effort suffixes use the same base rates."
     },
+    "gpt-6-luna": {
+      "input": 0.1,
+      "output": 0.5,
+      "cache_read": 0.01,
+      "cache_write": 0.125,
+      "note": "GPT-6 Luna lightweight tier, Standard USD/MTok (LiteLLM entry sourced from https://developers.openai.com/api/docs/pricing, cached 2026-10-31): $0.10/$0.50 per MTok, $0.01 cache read, $0.125 cache write. Distinct from gpt-5.6-luna. Previously LiteLLM-only, so cloud account views showed it unpriced; promoted so cloud prices it and curated/edge parity guards the key (issue #929)."
+    },
     "gpt-5.6-sol": {
       "input": 4,
       "output": 20,
@@ -158,6 +186,42 @@
       "cache_write": 0.25,
       "note": "GPT-5.6 lightweight tier. Official short-context rates: $0.20/$1.20 per MTok (previous curated values $1/$6 overcounted 5x). See gpt-5.6-sol."
     },
+    "gpt-5.5": {
+      "input": 5,
+      "output": 30,
+      "cache_read": 0.5,
+      "note": "Official Standard USD/MTok rates (LiteLLM entry sourced from https://developers.openai.com/api/docs/pricing, cached 2026-10-31): $5/$30 per MTok, $0.50 cache read, no published cache-write rate. The largest production LiteLLM-only model — codex's primary SKU ($1,118 of cloud account usage showed unpriced between 2026-01-01 and 2026-10-31); promoted so cloud account views price it and curated/edge parity guards the key (issue #929)."
+    },
+    "gpt-5.4": {
+      "input": 2.5,
+      "output": 15,
+      "cache_read": 0.25,
+      "note": "Official Standard USD/MTok rates (LiteLLM entry sourced from https://developers.openai.com/api/docs/pricing, cached 2026-10-31): $2.50/$15 per MTok, $0.25 cache read. The edge table has pinned this rate since before v1.5.1; curated pins the same value so local billing no longer depends on the LiteLLM cache (issue #929). -pro/-nano/-mini keep their own SKUs."
+    },
+    "gpt-5.4-pro": {
+      "input": 30,
+      "output": 180,
+      "cache_read": 3,
+      "note": "Official Pro USD/MTok rates, matching the edge table's gpt-5.4-pro entry ($30/$180, $3 cache read; https://developers.openai.com/api/docs/pricing). Companion pin for the gpt-5.4 promotion: without a curated Pro entry, the curated contained match captures provider-qualified dated snapshots (openai/gpt-5.4-pro-2026-03-05) at the base $2.50/$15 rate before the LiteLLM reverse lookup reaches the Pro SKU — 12x under local vs edge (issue #929)."
+    },
+    "gpt-5.4-mini": {
+      "input": 0.75,
+      "output": 4.5,
+      "cache_read": 0.075,
+      "note": "Official Standard USD/MTok rates (LiteLLM entry sourced from https://developers.openai.com/api/docs/pricing, cached 2026-10-31): $0.75/$4.50 per MTok, $0.075 cache read. Same promotion rationale as gpt-5.4 (issue #929)."
+    },
+    "gpt-5.2": {
+      "input": 1.75,
+      "output": 14,
+      "cache_read": 0.175,
+      "note": "Official Standard USD/MTok rates (LiteLLM entry sourced from https://developers.openai.com/api/docs/pricing, cached 2026-10-31): $1.75/$14 per MTok, $0.175 cache read. Same promotion rationale as gpt-5.4 (issue #929); -pro stays on its own 10x LiteLLM SKU."
+    },
+    "gpt-5.3-codex-spark": {
+      "input": 1.75,
+      "output": 14,
+      "cache_read": 0.175,
+      "note": "Codex spark capacity tier; not a separate LiteLLM key. Local (LiteLLM reverse-substring) and the edge matcher both bill it at the base gpt-5.3-codex rate ($1.75/$14, $0.175 cache read, https://developers.openai.com/api/docs/pricing); the exact entry pins that resolution on both sides (issue #929)."
+    },
     "kiro-agent": {
       "input": 3,
       "output": 15,
@@ -265,6 +329,12 @@
       "cache_write": 0,
       "note": "Google Gemini 4 Argon introductory list rate (through 2026-11-30) matching Cursor Other Models pool: $2/M input, $0.10/M cached input, $10/M output. Effort suffixes (-high/-medium/-low/-minimal) are stripped by normalizeCursorModel. Sources: https://cursor.com/docs/models-and-pricing and https://ai.google.dev/gemini-api/docs/pricing"
     },
+    "gemini-3-flash-preview": {
+      "input": 0.5,
+      "output": 3,
+      "cache_read": 0.05,
+      "note": "LiteLLM entry (sourced from https://cloud.google.com/gemini-enterprise-agent-platform/generative-ai/pricing, cached 2026-10-31): $0.50/$3 per MTok, $0.05 cache read, no published cache-write rate. Same rate the edge table already pins; promoted so curated/edge parity guards the key (issue #929)."
+    },
     "MiniMax-M2.7": {
       "input": 0.3,
       "output": 1.2,
@@ -579,6 +649,30 @@
       "output": 0,
       "cache_read": 0
     },
+    "mimo-v2.5": {
+      "input": 0.4,
+      "output": 2,
+      "cache_read": 0.08,
+      "note": "Xiaomi MiMo v2.5 (queue rows report the bare id; LiteLLM keys are provider-qualified). Rates match the deepinfra entry — the lexicographically smallest provider key the matcher deterministically picks: $0.40/$2 per MTok, $0.08 cache read, no published cache-write rate. The edge table pinned this exact rate after the kimi-k2.6/mimo profile-modal incident; curated pins the same value so local billing no longer depends on LiteLLM prefix-strip (issue #929)."
+    },
+    "mimo-v2.5-pro": {
+      "input": 1,
+      "output": 3,
+      "cache_read": 0.2,
+      "note": "Xiaomi MiMo v2.5 Pro (deepinfra is the lexicographically smallest LiteLLM provider key, matching the edge table): $1/$3 per MTok, $0.20 cache read. Exact entry required alongside mimo-v2.5 so the contained-exact fallback cannot bill -pro at the base v2.5 rate (issue #929)."
+    },
+    "muse-spark-1.2-contributor": {
+      "input": 0.1,
+      "output": 0.2,
+      "cache_read": 0.002,
+      "note": "Paid Muse contributor SKU. LiteLLM provider-qualified entries agree on $0.10/$0.20 per MTok, $0.002 cache read (meta and opencode_go both list these rates, cached 2026-10-31). Previously LiteLLM prefix-strip-only, so cloud account views showed it unpriced; promoted so cloud prices it and curated/edge parity guards the key (issue #929). The -free SKU below stays $0."
+    },
+    "muse-spark-1.3-contributor": {
+      "input": 0.1,
+      "output": 0.2,
+      "cache_read": 0.002,
+      "note": "See muse-spark-1.2-contributor — same paid contributor SKU at the same verified rates (issue #929)."
+    },
     "muse-spark-1.2-contributor-free": {
       "input": 0,
       "output": 0,