sprag-cli 3.55.0 → 3.56.0

package/src/commands/codex-delegate.js

@@ -2,7 +2,9 @@ import { loadConfig, saveConfig } from '../config.js';
 import { configureCodexHooks } from '../codex-installer.js';
 import { validateCodexTarget, loadCodexModelRules, addCodexModelRule, removeCodexModelRule } from '../codex-delegation.js';
 import { findCodexCandidate, resolveCodexCandidate } from '../codex-route-scan.js';
-import { codexRoutingSavedTotals } from '../codex-ledger.js';
+import { codexRoutingSavedTotals, loadCodexLedger } from '../codex-ledger.js';
+import { codexRuleHealth } from '../codex-rule-health.js';
+import { signedUsd } from '../money.js';
 import { codexProviderName } from '../agent.js';
 
 export function run({ args, getArg, hasFlag, root }) {
@@ -31,7 +33,14 @@ export function run({ args, getArg, hasFlag, root }) {
     else if (args[2]) throw new Error('Usage: delegate rules [add <category|R<N>> --from <model> --model <model> --global|--project | rm <N>]');
     const rules = loadCodexModelRules();
     if (!rules.length) console.log('No Codex model rules. Claude rules are not imported.');
-    rules.forEach((r, i) => console.log(`#${i + 1} ${r.category} | ${r.from} -> ${r.model} | ${r.scope}${r.targetRoot ? ` ${r.targetRoot}` : ''}`));
+    let events = [];
+    try { events = Object.values(loadCodexLedger().events); } catch { /* No ledger yet: rules list without outcomes. */ }
+    rules.forEach((r, i) => {
+      const h = codexRuleHealth(r, { events });
+      const outcome = h.runs ? ` | measured x${h.runs}, err ${Math.round(h.rate * 100)}%, saved ${signedUsd(h.saved, 4)}` : '';
+      const warn = h.status === 'review' ? ` | rule-health: ${h.errs}/${h.runs} runs failed, narrow the condition or remove (delegate rules rm ${i + 1} --agent codex)` : '';
+      console.log(`#${i + 1} ${r.category} | ${r.from} -> ${r.model} | ${r.scope}${r.targetRoot ? ` ${r.targetRoot}` : ''}${outcome}${warn}`);
+    });
     return;
   }
   if (!['on', 'off', 'status', 'model'].includes(sub)) throw new Error('Usage: delegate on|off|status|model <model>|rules --agent codex');
@@ -54,6 +63,6 @@ export function run({ args, getArg, hasFlag, root }) {
   console.log('Explicit spawn models and custom roles are preserved. Targets must be available from your Codex provider.');
   const saved = codexRoutingSavedTotals();
   console.log(saved.priced
-    ? `Routing saved: $${saved.total.toFixed(4)} over ${saved.priced} priced run(s). Details: sprag route-scan savings --agent codex`
+    ? `Routing saved: ${saved.total < 0 ? '-' : ''}$${Math.abs(saved.total).toFixed(4)} over ${saved.priced} priced run(s). Details: sprag route-scan savings --agent codex`
     : `Routing saved: n/a (${saved.runs ? `${saved.runs} attributed run(s), none priced` : 'no attributed runs yet'}). Review/trust the Sprag hooks in Codex /hooks.`);
 }

package/src/commands/codex.js

@@ -4,6 +4,8 @@ import { initCodexHarness, uninitCodexHarness, codexHarnessStatus } from '../cod
 import { findProjectRoot, harnessPromote, harnessListRules, harnessRmRule, harnessPrune } from '../harness.js';
 import { loadConfig, saveConfig } from '../config.js';
 import { resolve } from 'node:path';
+import { debug } from '../debug.js';
+import { signedUsd } from '../money.js';
 
 const HELP = `Sprag / Codex
 
@@ -19,7 +21,7 @@ Usage: sprag <command> --agent codex [options]
   doctor [--format json]         Config, hooks, harness, logs, and capabilities
   capabilities [--format json]   Support matrix, including native/unsupported areas
   brief [on|off|status]          Current warnings or prompt-briefing preference
-  last / history                Codex warning history; --days, --session, --project
+  last / history                Context/rate-limit warnings and handoffs; --days, --session, --project
   handoff [--cwd path]           Write Git state and Codex usage to HANDOFF-*.md
   delegate on|off|status         Native model routing and SubagentStart guidance
   delegate model <model>         Default target for spawns without an explicit model
@@ -155,7 +157,7 @@ export async function run({ args, version }) {
       const money = (usd) => Number.isFinite(usd) ? `${usd < 0 ? '-' : ''}$${Math.abs(usd).toFixed(4)}` : 'n/a (unpriced)';
       console.log(`Codex routing saved: ${totals.priced ? `${money(totals.week)} (7d) / ${money(totals.total)} total` : 'n/a'} | ${totals.runs} attributed run(s), ${totals.runs - totals.priced} unpriced`);
       for (const e of events.slice(0, 20)) {
-        console.log(`${new Date(e.ts).toISOString().slice(0, 16)} ${e.source}${e.category ? `/${e.category}` : ''} ${e.from} -> ${e.to} ${money(e.usd)}${e.complete ? '' : ' (incomplete)'}`);
+        console.log(`${new Date(e.ts).toISOString().slice(0, 16)} ${e.source}${e.category ? `/${e.category}` : ''} ${e.from} -> ${e.to} ${money(e.usd)}${e.aborted ? ' (interrupted: whole cost counted as a loss)' : e.complete ? '' : ' (incomplete)'}`);
       }
       console.log('Counterfactual: the child run\'s own tokens priced at the parent model. Only Sprag-routed spawns with a recorded route id count.');
       return;
@@ -172,7 +174,7 @@ export async function run({ args, version }) {
     if (hasFlag('--refresh') || !cache) {
       // Prices live in the gateway snapshot; refresh it when stale so candidates can name a target.
       const { readCodexPrices, refreshCodexPrices } = await import('../codex-cache-policy.js');
-      if (!readCodexPrices()) { try { await refreshCodexPrices(); } catch { /* Candidates still list; targets need --model. */ } }
+      if (!readCodexPrices()) { try { await refreshCodexPrices(); } catch (e) { debug('codex:prices', e); } }
       cache = await rs.runCodexRouteScan({ days });
     }
     if (hasFlag('--quiet')) return;
@@ -181,7 +183,7 @@ export async function run({ args, version }) {
     console.log(`Codex route-scan: ${cache.totalEpisodes} turns in ${cache.days} days, scanned ${cache.scannedAt}${cache.priceCheckedAt ? '' : ' | prices unavailable'}`);
     if (!open.length) console.log('No recurring delegable pattern. Needs 3+ similar simple turns per project and parent model.');
     for (const c of open) {
-      const target = c.suggestedModel ? `-> ${c.suggestedModel}${Number.isFinite(c.estSavedUsd) ? ` (~$${c.estSavedUsd.toFixed(4)} over ${c.count} turns)` : ''}`
+      const target = c.suggestedModel ? `-> ${c.suggestedModel}${Number.isFinite(c.estSavedUsd) ? ` (~${signedUsd(c.estSavedUsd, 4)} over ${c.count} turns)` : ''}`
         : `-> choose --model${c.alternatives.length ? ` (priced cheaper: ${c.alternatives.join(', ')})` : ''}`;
       console.log(`R${c.id} ${c.category} x${c.count} [T2 ${c.tiers.T2} / T1 ${c.tiers.T1}] ${c.provider || 'unknown provider'} / ${c.from} ${target}`);
       console.log(`   ${c.projectRoot}`);
@@ -225,7 +227,7 @@ export async function run({ args, version }) {
       sessionId: getArg('--session'), project: getArg('--project') || getArg('-p') });
     if (cmd === 'last') events = events.slice(-1);
     if (format === 'json') { console.log(JSON.stringify({ agent: 'codex', events }, null, 2)); return; }
-    if (!events.length) console.log('No Codex warning history in this window. Records are written by the trusted prompt hook.');
+    if (!events.length) console.log('No Codex warning history in this window. The trusted prompt hook records context and rate-limit warnings; handoffs are recorded when written.');
     else if (hasFlag('--list')) console.log([...new Set(events.map((event) => event.at.slice(0, 10)))].reverse().join('\n'));
     else for (const event of events) {
       console.log(terminalText(`${event.at} [${event.sessionId}] ${event.message}`));
@@ -239,6 +241,11 @@ export async function run({ args, version }) {
     const cwd = getArg('--cwd') || process.cwd();
     const data = await createPanelReader({ root: findProjectRoot(resolve(cwd), { agent: 'codex' }), sessionId: getArg('--session'), days: numArg('--days', { dflt: 7, min: 0 }) })();
     const result = writeHandoff({ cwd, agent: 'codex', session: data.session });
+    try {
+      const { recordCodexHistoryEvent } = await import('../codex-brief.js');
+      recordCodexHistoryEvent({ sessionId: data.session?.sessionId, project: cwd, key: 'handoff',
+        message: `Handoff written: ${result.path}` });
+    } catch (e) { debug('codex:handoff-record', e); }
     console.log(`Handoff written: ${result.path}`);
     console.log('Fill in the remaining-work sections, then ask the next Codex session to read this file.');
     return;
@@ -324,7 +331,7 @@ export async function run({ args, version }) {
     })() : { read: createCodexBudgetReader() };
     if (hasFlag('--once')) {
       const provider = codexBudgetProvider();
-      if (provider) { try { readBudget.set(await fetchCodexBudget(provider)); } catch { /* No verified budget. */ } }
+      if (provider) { try { readBudget.set(await fetchCodexBudget(provider)); } catch (e) { debug('codex:budget', e); } }
     }
     const { createInlinePanelResizer } = await import('../codex-panel-runner.js');
     const rawInterval = getArg('--interval');
@@ -340,7 +347,7 @@ export async function run({ args, version }) {
         readCachePolicy: hasFlag('--once') ? async (session) => {
           const { readCodexCachePolicy } = await import('../codex-cache-policy.js');
           try { return readCodexCachePolicy(session) || await refreshCodexCachePolicy(session); }
-          catch { return null; }
+          catch (e) { debug('codex:cache-policy', e); return null; }
         } : createCodexCachePolicyReader(), hasFlag }),
       interval: interval * 1000, once: hasFlag('--once'),
       color: !hasFlag('--no-color') && !process.env.NO_COLOR && !!process.stdout.isTTY, version, compact: hasFlag('--compact'),
@@ -377,7 +384,7 @@ export async function run({ args, version }) {
       }
       const out = await codexHookOutput(getArg('--event'), payload);
       if (out) console.log(JSON.stringify(out));
-    } catch { /* Hook failures must not break the agent loop. */ }
+    } catch (e) { debug('codex:hook', e); /* Hook failures must not break the agent loop. */ }
     return;
   }
   if (cmd === 'install') {
@@ -396,7 +403,7 @@ export async function run({ args, version }) {
       const { preparePresetRatchet } = await import('../preset-ratchet.js');
       const p = preparePresetRatchet({ agent: 'codex' });
       console.log(`Codex preset rules: ${p.file} (${p.rules} registered${p.moved ? `, ${p.moved} moved from ratchet.md` : ''})`);
-    } catch { /* Presets are optional; `seed` still registers them. */ }
+    } catch (e) { debug('codex:preset', e); /* Presets are optional; `seed` still registers them. */ }
     console.log('Open /hooks in Codex and review/trust the Sprag hooks before they can run.');
     console.log(`Panel auto-start: ${panelAuto ? 'registered with the other hooks' : 'off'}. Hook registration is complete; runtime activation is not verified.`);
     console.log('After approval, start or resume Codex and run: sprag panel doctor --agent codex');
@@ -508,7 +515,8 @@ export async function run({ args, version }) {
     console.log(`Cache: ${doc2md.cacheDir()}`);
     try {
       for (const hook of codexHookStatus().filter((h) => ['PreToolUse', 'UserPromptSubmit'].includes(h.event))) console.log(`${hook.event}: ${hook.registered ? 'registered' : 'missing/outdated'}`);
-    } catch {
+    } catch (e) {
+      debug('codex:hook-status', e);
       console.log('Hooks: cannot read Codex hooks.json; file left unchanged. Run sprag doctor --agent codex for diagnostics.');
     }
     console.log('Prompt conversion, supported reads, and document/cache write guards require trusted hooks. Review in Codex /hooks.');

package/src/commands/route-scan.js

@@ -10,6 +10,7 @@ import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 import { readStdinJson } from '../stdin-payload.js';
 import { debug } from '../debug.js';
+import { signedUsd } from '../money.js';
 
 /**
  * Whether the user turned doc2md on.
@@ -65,7 +66,7 @@ export async function run({ args, hasFlag, numArg }) {
         return;
       }
       const t = delegationSavedTotals();
-      const money = (v) => `$${v.toFixed(2)}`;
+      const money = (v) => (v < 0 ? `-$${(-v).toFixed(2)}` : `$${v.toFixed(2)}`); // sign before the symbol
       // Lifetime leads (it is what the breakdown below adds up to); the
       // rolling windows follow as context rather than as competing headlines.
       console.log(lang === 'ko'
@@ -154,8 +155,8 @@ export async function run({ args, hasFlag, numArg }) {
         // two mean opposite things (no data vs. data showing no value).
         const measured = r.delegatedRuns
           ? (lang === 'ko'
-            ? `실제 위임 ${r.delegatedRuns}건 · 에러율 ${Math.round((r.delegatedErrRate || 0) * 100)}% · 절감 ~$${(r.savedUsd || 0).toFixed(2)}`
-            : `measured ×${r.delegatedRuns} · err ${Math.round((r.delegatedErrRate || 0) * 100)}% · saved ~$${(r.savedUsd || 0).toFixed(2)}`)
+            ? `실제 위임 ${r.delegatedRuns}건 · 에러율 ${Math.round((r.delegatedErrRate || 0) * 100)}% · 절감 ~${signedUsd(r.savedUsd || 0)}`
+            : `measured ×${r.delegatedRuns} · err ${Math.round((r.delegatedErrRate || 0) * 100)}% · saved ~${signedUsd(r.savedUsd || 0)}`)
           : (sessionRank !== null && !rs.worthDelegating(r.tier, sessionRank)
             ? (lang === 'ko'
               ? `이 규칙은 현재 기본 모델(${sessionModel}) 기준으로는 적용되지 않습니다. 세션 모델이 이미 위임 목표와 같은 급이어서 절감이 발생하지 않습니다.`

package/src/cost.js

@@ -197,7 +197,8 @@ function tokensToMillions(n) {
  *   ephemeral1h      — portion of cacheCreation billed at 1h rate (2x input)
  *   output           — output tokens
  */
-export function estimateCost(totals, model) {
+export function estimateCost(totals, model, { price } = {}) {
+  if (price) return estimateCostAtPrice(totals, price);
   const tier = detectPricingTier(model);
   const p = PRICING[tier];
 
@@ -248,20 +249,73 @@ export function estimateCost(totals, model) {
   };
 }
 
+/**
+ * Same shape as the list-price estimate, but priced at a gateway's per-token
+ * rates (LiteLLM /model/info). A token class the gateway does not price makes
+ * the whole estimate unknown (null) rather than free or list-priced.
+ */
+function estimateCostAtPrice(totals, price) {
+  const write5m = totals.ephemeral5m ?? 0;
+  const write1h = totals.ephemeral1h ?? 0;
+  const untracked = Math.max(0, (totals.cacheCreation ?? 0) - write5m - write1h);
+  const read = totals.cacheRead ?? 0;
+  if (read > 0 && price.cacheRead == null) return null;
+  if (write5m + untracked > 0 && price.cacheWrite == null) return null;
+  if (write1h > 0 && price.cacheWrite1h == null) return null;
+  if (price.input == null || price.output == null) return null;
+  const perM = (rate) => (rate ?? 0) * 1e6;
+  const input = perM(price.input), output = perM(price.output), cacheRead = perM(price.cacheRead);
+  const cacheWrite5m = perM(price.cacheWrite), cacheWrite1h = perM(price.cacheWrite1h);
+
+  const actual =
+    tokensToMillions(totals.input) * input +
+    tokensToMillions(write5m + untracked) * cacheWrite5m +
+    tokensToMillions(write1h) * cacheWrite1h +
+    tokensToMillions(read) * cacheRead +
+    tokensToMillions(totals.output) * output;
+  const totalInput = totals.input + (totals.cacheCreation ?? 0) + read;
+  const noCacheCost = tokensToMillions(totalInput) * input + tokensToMillions(totals.output) * output;
+
+  // The 5m scenario needs a 5m write rate; without one it is not computable, so
+  // it collapses to the actual cost and the "extra cost" row stays hidden.
+  let scenario5mCost = actual;
+  if (price.cacheWrite != null) {
+    const extra5mCreation = write1h * 2;
+    scenario5mCost =
+      tokensToMillions(totals.input) * input +
+      tokensToMillions(write5m + write1h + untracked + extra5mCreation) * cacheWrite5m +
+      tokensToMillions(Math.max(0, read - extra5mCreation)) * cacheRead +
+      tokensToMillions(totals.output) * output;
+  }
+
+  return {
+    tier: 'gateway',
+    actual: round(actual),
+    noCacheCost: round(noCacheCost),
+    savings: round(noCacheCost - actual),
+    savingsRate: noCacheCost > 0 ? (noCacheCost - actual) / noCacheCost : 0,
+    scenario5mCost: round(scenario5mCost),
+    extraCostIf5m: round(scenario5mCost - actual),
+    extraCostIf5mApplicable: price.cacheWrite != null && write1h > 0,
+  };
+}
+
 /**
  * Price a set of sessions each at its own model and sum. One estimateCost over
  * the summed totals priced every token at whichever session came first in the
  * list — sorted by mtime, so a haiku scratch session touched earliest set the
  * rate for a day of Fable work and understated the saving about tenfold.
  * Sessions whose model has no known rate are skipped, as month-spend does.
+ * `estimate` lets a caller price by path (see claude-price.js); null skips a session.
  */
-export function estimateCostAcross(sessions) {
+export function estimateCostAcross(sessions, estimate = estimateCost) {
   const acc = { actual: 0, noCacheCost: 0, scenario5mCost: 0, extraCostIf5mApplicable: false };
   const tiers = new Map();
   for (const s of sessions || []) {
     if (!s?.totals) continue;
     let c;
-    try { c = estimateCost(s.totals, s.model); } catch { continue; }
+    try { c = estimate(s.totals, s.model); } catch { continue; }
+    if (!c) continue;
     acc.actual += c.actual;
     acc.noCacheCost += c.noCacheCost;
     acc.scenario5mCost += c.scenario5mCost;

package/src/formatters/statusline.js

@@ -54,6 +54,12 @@ const GRAY = fg(100, 116, 139, '\x1b[90m');
 const BOLD = '\x1b[1m';
 
 export function formatMoney(usd) {
+  // The sign leads the currency symbol ("-$0.12"); a loss that rounds to zero
+  // prints as plain "$0.00" rather than "-$0.00".
+  if (usd < 0) {
+    const abs = formatMoney(-usd);
+    return abs === '$0.00' ? abs : `-${abs}`;
+  }
   // Boundaries sit at 999.5/999500 so a value that would round up into the
   // next band's width ($999.9 → "$1000") jumps to that band's unit instead —
   // otherwise "$1000" renders visually larger than "$1.0K".
@@ -512,8 +518,8 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // Tied to MIN_VOTES rather than a literal so the two cannot drift: the chip
   // appears exactly when learning has had its chance and still came up short.
   const unresolvedRuns = Number(data.unresolvedRuns) || 0;
-  const delegateSeg = delegationSaved > 0
-    ? `${c(GREEN)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}`
+  const delegateSeg = delegationSaved !== 0
+    ? `${c(delegationSaved < 0 ? RED : GREEN)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}`
     : (unresolvedRuns >= MIN_VOTES
       ? `${c(YELLOW)}${g.routing} ${unresolvedRuns} unresolved${c(RESET)}`
       : null);
@@ -552,8 +558,12 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   //   verbose: "Sep spend $42.1 (since Sep 1)"
   const month = data.monthSpend;
   let monthSeg = null;
-  if (month && Number(month.usd) > 0) {
-    const amt = formatMoney(Number(month.usd));
+  // Gateway sessions whose model the gateway does not price are left out of the
+  // sum and counted, so a partial total says so and an all-unpriced month is n/a.
+  const monthUnpriced = Number(month?.unpriced) || 0;
+  if (month && (Number(month.usd) > 0 || monthUnpriced > 0)) {
+    const amt = (Number(month.usd) > 0 ? formatMoney(Number(month.usd)) : 'n/a') +
+      (monthUnpriced > 0 ? ` +${monthUnpriced} unpriced` : '');
     if (isIcon) {
       monthSeg = `${c(GRAY)}${g.month} ${month.label} ${amt}${c(RESET)}`;
     } else if (verbose) {
@@ -576,7 +586,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   //   text:  "Routing saved $9.8 | opus→haiku 2× $6.4 · fable→sonnet 1× $3.4"
   const totals = data.delegationTotals;
   let totalsLine = null;
-  if (!singleLine && totals && Number(totals.total) > 0) {
+  if (!singleLine && totals && Number(totals.total) !== 0 && Number.isFinite(Number(totals.total))) {
     const head = isIcon ? `${g.routing} Routing saved` : 'Routing saved';
     // Model changes behind the total, family-level and version-free: `opus →
     // haiku 2× $0.6`. Versions bump constantly and add nothing here — the
@@ -595,9 +605,10 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     const pairText = pairs
       .map((p) => `${c(GRAY)}${p.from}→${p.to} ${p.runs}× ${formatMoney(p.usd)}${c(RESET)}`)
       .join(` ${c(GRAY)}·${c(RESET)} `);
+    const tone = Number(totals.total) < 0 ? RED : GREEN; // a net loss must not read as a win
     totalsLine =
-      `${c(GREEN)}${c(BOLD)}${head}${c(RESET)} ` +
-      `${c(GREEN)}${formatMoney(Number(totals.total) || 0)}${c(RESET)}` +
+      `${c(tone)}${c(BOLD)}${head}${c(RESET)} ` +
+      `${c(tone)}${formatMoney(Number(totals.total) || 0)}${c(RESET)}` +
       (pairText ? `  ${c(GRAY)}|${c(RESET)}  ${pairText}` : '');
   }
 

package/src/formatters/table.js

@@ -253,6 +253,7 @@ export function formatReport({ summary: sum, trend, ttl, anomalies, cost, option
     lines.push('  ' + tableRow(['Extra cost if 5m-only', `+$${cost.extraCostIf5m}`], costW, costA));
   }
   lines.push('  ' + tableBot(costW));
+  if (cost.unpriced > 0) lines.push(`  ${cost.unpriced} session(s) not priced by the gateway are left out.`);
   lines.push('');
 
   // Daily trend

package/src/gateway-prices.js

@@ -0,0 +1,39 @@
+// LiteLLM /model/info prices, shared by the Codex and Claude sides. Per-token USD; both sides
+// price a call by the path it took, so these are only ever the gateway's own numbers.
+export const PRICE_MAX_AGE_MS = 7 * 86400000;
+export const rate = (value) => Number.isFinite(value) && value >= 0 && value < 1 ? value : null;
+
+export function deploymentPrice(row) {
+  const info = row?.model_info || {};
+  const mode = typeof info.mode === 'string' ? info.mode : null;
+  if (mode && !['chat', 'responses', 'completion'].includes(mode)) return null;
+  const input = rate(info.input_cost_per_token), output = rate(info.output_cost_per_token);
+  if (input === null || output === null) return null;
+  return { input, output, cacheRead: rate(info.cache_read_input_token_cost), cacheWrite: rate(info.cache_creation_input_token_cost),
+    cacheWrite1h: rate(info.cache_creation_input_token_cost_above_1hr) };
+}
+
+/** Per-token prices by alias. Load-balanced deployments must agree, like cache policy. */
+export function gatewayPrices(payload) {
+  if (!Array.isArray(payload?.data)) throw new Error('LiteLLM model/info returned no model list');
+  const groups = new Map();
+  for (const row of payload.data) {
+    if (typeof row?.model_name !== 'string' || row.model_name.length > 256) continue;
+    groups.set(row.model_name, [...(groups.get(row.model_name) || []), deploymentPrice(row)]);
+  }
+  return Object.fromEntries([...groups].map(([name, prices]) => [name,
+    prices[0] && prices.every((p) => JSON.stringify(p) === JSON.stringify(prices[0])) ? prices[0] : null]));
+}
+
+/**
+ * USD for a token mix at one model's prices, or null when a needed rate is
+ * missing. Cached input without a cache-read rate is unknown, not free.
+ */
+export function codexRunCost({ input = 0, cached = 0, cacheWrite = 0, output = 0 }, price) {
+  if (!price || price.input === null || price.output === null) return null;
+  if (cached > 0 && price.cacheRead === null) return null;
+  // cache_write_input_tokens is billed at the creation rate when one is published, else as input.
+  const uncached = Math.max(0, input - cached - cacheWrite);
+  return uncached * price.input + cached * (price.cacheRead ?? 0) + cacheWrite * (price.cacheWrite ?? price.input) + output * price.output;
+}
+

package/src/litellm-models.js

@@ -27,6 +27,7 @@
 import { gatewayBase } from './gateway-auth.js';
 import { loadProfileMap, updateProfileMap, resetModelAliasCache, profileIdFrom, isGatewayModelId } from './model-alias.js';
 import { isRecognizedModelId } from './cost.js';
+import { deploymentPrice, PRICE_MAX_AGE_MS } from './gateway-prices.js';
 import { debug } from './debug.js';
 
 /** 게이트웨이 모델 맵의 신선도 기준. 배포 구성은 하루에 여러 번 바뀌지 않습니다. */
@@ -70,6 +71,23 @@ function normalizeCandidate(id) {
   return s.replace(/\[[^\]]*\]$/, '');
 }
 
+/**
+ * 배포 항목 하나의 별칭을 고릅니다. model_name → model_info.base_model →
+ * litellm_params.model 순으로 정규화해 isRecognizedModelId()를 통과하는 첫
+ * 후보이며, 없으면 null입니다. 별칭 추출과 가격 키 등록이 같은 판정을 쓰도록
+ * 한 곳에 둡니다.
+ */
+function pickAlias(item) {
+  const modelName = typeof item.model_name === 'string' ? item.model_name : '';
+  const baseModel = typeof item.model_info?.base_model === 'string' ? item.model_info.base_model : '';
+  const rawModel = typeof item.litellm_params?.model === 'string' ? item.litellm_params.model : '';
+  for (const candidate of [modelName, baseModel, rawModel]) {
+    const normalized = normalizeCandidate(candidate);
+    if (normalized && isRecognizedModelId(normalized)) return normalized;
+  }
+  return null;
+}
+
 /**
  * `/model/info` 응답에서 프로파일 ID(또는 계열명 없는 사내 별칭) → 모델 계열
  * 매핑을 뽑아냅니다. 순수 함수입니다: 네트워크·파일 I/O가 없고, 잘못된 입력에도
@@ -99,17 +117,8 @@ export function deriveAliasesFromModelInfo(payload) {
   for (const item of data) {
     if (!item || typeof item !== 'object') continue;
     const modelName = typeof item.model_name === 'string' ? item.model_name : '';
-    const baseModel = typeof item.model_info?.base_model === 'string' ? item.model_info.base_model : '';
     const rawModel = typeof item.litellm_params?.model === 'string' ? item.litellm_params.model : '';
-
-    let alias = null;
-    for (const candidate of [modelName, baseModel, rawModel]) {
-      const normalized = normalizeCandidate(candidate);
-      if (normalized && isRecognizedModelId(normalized)) {
-        alias = normalized;
-        break;
-      }
-    }
+    const alias = pickAlias(item);
 
     if (!alias) {
       if (modelName) skipped.push(modelName);
@@ -134,6 +143,58 @@ export function deriveAliasesFromModelInfo(payload) {
   return { aliases, skipped, count: data.length };
 }
 
+/**
+ * `/model/info` 응답에서 모델 키 → 토큰당 가격 표를 만듭니다. 순수 함수입니다.
+ *
+ * 한 배포 항목의 가격을 model_name, 정규화한 model_name·base_model·
+ * litellm_params.model, 그리고 별칭 추출이 고른 별칭 아래에 모두 등록합니다.
+ * 트랜스크립트의 모델 문자열이 어느 모양으로 오든 찾을 수 있게 하려는 것입니다.
+ * 같은 키에 서로 다른 가격이 들어오면 어느 쪽이 맞는지 알 수 없으므로 null로
+ * 둡니다. 값은 숫자뿐이고, 키는 normalizeCandidate를 거쳐 ARN이 리소스 부분으로
+ * 줄어 있으므로 AWS 계정 ID가 파일에 남지 않습니다.
+ *
+ * @returns {Record<string, object|null>}
+ */
+export function deriveGatewayPrices(payload) {
+  const data = Array.isArray(payload?.data) ? payload.data : [];
+  const prices = new Map();
+  for (const item of data) {
+    if (!item || typeof item !== 'object') continue;
+    const price = deploymentPrice(item);
+    const keys = new Set([
+      // 원문 model_name이 ARN이면 계정 ID가 있으므로 원문 키는 쓰지 않습니다.
+      typeof item.model_name === 'string' && !isGatewayModelId(item.model_name) ? item.model_name : '',
+      normalizeCandidate(item.model_name),
+      normalizeCandidate(item.model_info?.base_model),
+      normalizeCandidate(item.litellm_params?.model),
+      pickAlias(item) || '',
+    ]);
+    for (const key of keys) {
+      if (!key) continue;
+      if (!prices.has(key)) prices.set(key, price);
+      else if (JSON.stringify(prices.get(key)) !== JSON.stringify(price)) prices.set(key, null);
+    }
+  }
+  return Object.fromEntries(prices);
+}
+
+/**
+ * LiteLLM 경로로 나간 호출의 모델 가격(토큰당 USD). 게이트웨이 표에 없거나,
+ * 표가 PRICE_MAX_AGE_MS보다 오래됐거나, 키가 모호하면 null입니다. 정가표로
+ * 대신 채우지 않습니다. 호출이 실제로 지난 경로의 가격만 씁니다.
+ */
+export function gatewayPriceFor(model, env = process.env, now = Date.now()) {
+  const gateway = readGatewayModelMap(env);
+  if (!gateway?.prices || typeof gateway.prices !== 'object') return null;
+  const fetchedAt = Date.parse(gateway.fetchedAt);
+  if (!Number.isFinite(fetchedAt) || fetchedAt > now || now - fetchedAt > PRICE_MAX_AGE_MS) return null;
+  if (typeof model !== 'string' || !model) return null;
+  for (const key of [model, normalizeCandidate(model)]) {
+    if (key && Object.hasOwn(gateway.prices, key)) return gateway.prices[key] || null;
+  }
+  return null;
+}
+
 /**
  * profile-map.json의 gateway 절을 읽습니다. base가 현재 gatewayBase(env)와
  * 다르면 다른 게이트웨이의 캐시이므로 null을 돌려줍니다. 예산 캐시(budgetWindow)
@@ -240,6 +301,7 @@ export async function refreshGatewayModelMap({ base, key, fetchImpl = fetch } =
         base,
         fetchedAt: new Date().toISOString(),
         aliases: result.aliases,
+        prices: deriveGatewayPrices(payload),
         skipped: result.skipped,
         count: result.count,
       },

package/src/model-rules.js

@@ -34,6 +34,7 @@ import { homedir } from 'node:os';
 import { userDataDir } from './paths.js';
 import { userLanguage } from './config.js';
 import { agentPhrase, agentPhraseEn } from './agents.js';
+import { signedUsd } from './money.js';
 
 // Post-promotion delegated-category error rate above this flags the rule
 // for review (rule-health). Calibrated against local T0 avg error incidence.
@@ -356,7 +357,7 @@ export function renderModelRatchet(rules, lang = userLanguage()) {
       ? `preset (curated), registered ${r.promotedAt}`
       : `×${r.count || 0}, err ${pct(r.errRate)}%, seen ${r.lastSeen || r.promotedAt}`;
     if (!r.delegatedRuns) return base;
-    const saved = r.savedUsd ? `, saved ~$${r.savedUsd.toFixed(2)}` : '';
+    const saved = r.savedUsd ? `, saved ~${signedUsd(r.savedUsd)}` : '';
     return `${base}, delegated ×${r.delegatedRuns} err ${pct(r.delegatedErrRate)}%${saved}`;
   };
   // Merged T2+T1 rules carry two caps, so they state both once rather than

package/src/money.js

@@ -0,0 +1,9 @@
+/**
+ * A signed dollar amount for text output: "-$0.12" for a loss, "$0.12" for a
+ * saving. Routing savings are recorded signed, and "~$-0.12" misreads as a
+ * formatting glitch rather than a loss.
+ */
+export function signedUsd(usd, digits = 2) {
+  const fixed = Math.abs(usd).toFixed(digits);
+  return usd < 0 && Number(fixed) !== 0 ? `-$${fixed}` : `$${fixed}`;
+}

package/src/month-spend.js

@@ -4,10 +4,12 @@
  * LiteLLM·Bedrock처럼 5h/7d cap 이 아예 없는 게이트웨이 사용자도
  * "이번 달에 얼마나 썼는지"는 늘 궁금하므로, 세션 로그를 기반으로
  * 달력 월 단위 지출을 통계선에 상시 노출합니다. 모델 단가는 세션마다
- * 다르므로 세션별로 estimateCost 를 적용해 합산합니다.
+ * 다르므로 세션별로 호출 경로에 맞는 가격(sessionCost)을 적용해 합산합니다.
+ * LiteLLM 게이트웨이 세션은 게이트웨이 가격표로만 계산하고, 표에 없는 모델은
+ * 합계에서 빼고 unpriced 로 셉니다. 정가표로 대신 채우지 않습니다.
  */
 
-import { estimateCost } from './cost.js';
+import { sessionCost } from './claude-price.js';
 
 /** 이번 달 1일 00:00(로컬)의 epoch ms. */
 export function monthStartMs(now = new Date()) {
@@ -27,21 +29,24 @@ export function monthLabel(now = new Date()) {
  *
  * @param {Array} sessions parseAllSessions 결과
  * @param {Date} [now]
- * @returns {{usd:number, sessions:number, sinceMs:number, label:string}}
+ * @returns {{usd:number, sessions:number, unpriced:number, sinceMs:number, label:string}}
  */
 export function monthSpend(sessions, now = new Date()) {
   const since = monthStartMs(now);
   let usd = 0;
   let count = 0;
+  let unpriced = 0;
   for (const s of sessions || []) {
     if (!s || !s.endTime || s.endTime.getTime() < since) continue;
     if (!s.totals) continue;
     try {
-      usd += estimateCost(s.totals, s.model).actual;
+      const c = sessionCost(s.totals, s.model);
+      if (!c) { unpriced += 1; continue; }
+      usd += c.actual;
       count += 1;
     } catch {
       // 단가를 모르는 모델은 합계에서 빠집니다. 통계선에서는 침묵이 낫습니다.
     }
   }
-  return { usd, sessions: count, sinceMs: since, label: monthLabel(now) };
+  return { usd, sessions: count, unpriced, sinceMs: since, label: monthLabel(now) };
 }

package/src/openai-prices.js

@@ -0,0 +1,33 @@
+// OpenAI list prices for Codex calls that go straight to OpenAI (ChatGPT/OpenAI login).
+// Source: https://developers.openai.com/api/docs/pricing , "Standard" tier, short-context
+// rates, checked 2026-10-01. Long-context surcharges are not modeled, so requests past the
+// long-context threshold are under-priced. Calls through a LiteLLM gateway never use this table.
+export const OPENAI_PRICES_CHECKED_AT = Date.parse('2026-10-01T00:00:00Z');
+
+// Per-1M-token numbers as listed on the page; null where the page shows "-".
+const PER_MILLION = {
+  'gpt-6-astra': [10, 1, 12.5, 50],
+  'gpt-6.1-sol': [2, 0.1, 2.5, 10],
+  'gpt-6-luna': [0.1, 0.01, 0.125, 0.5],
+  'gpt-6-sol': [2, 0.2, 2.5, 10],
+  'gpt-5.6-sol': [4, 0.4, 5, 20],
+  'gpt-5.6-terra': [2, 0.2, 2.5, 12],
+  'gpt-5.6-luna': [0.2, 0.02, 0.25, 1.2],
+  'gpt-5.5': [5, 0.5, null, 30],
+  'gpt-5.5-pro': [30, null, null, 180],
+  'gpt-5.4': [2.5, 0.25, null, 15],
+  'gpt-5.4-pro': [30, null, null, 180],
+  'gpt-5.4-mini': [0.75, 0.075, null, 4.5],
+  'gpt-5.4-nano': [0.2, 0.02, null, 1.25],
+  'gpt-5.2': [1.75, 0.175, null, 14],
+  'gpt-5.2-pro': [21, null, null, 168],
+  'gpt-5.1': [1.25, 0.125, null, 10],
+  'gpt-5': [1.25, 0.125, null, 10],
+};
+
+// Parse "<n>e-6" instead of dividing so 0.1 per 1M is exactly 1e-7, without float noise.
+const perToken = (n) => (n === null ? null : Number(`${n}e-6`));
+
+/** model -> per-token USD `{ input, cacheRead, cacheWrite, output }`. */
+export const OPENAI_LIST_PRICES = Object.fromEntries(Object.entries(PER_MILLION).map(([model, [input, cacheRead, cacheWrite, output]]) =>
+  [model, { input: perToken(input), cacheRead: perToken(cacheRead), cacheWrite: perToken(cacheWrite), output: perToken(output) }]));