@krtclcdy/tersio 2.25.4 → 2.25.5

package/dist/extensions/shared/brand-marks.js

@@ -0,0 +1,154 @@
+// Brand mark catalog: names, not bytes. One list serves both consumers — the dashboard draws from
+// it at runtime, and the CLI export inlines the same URLs so a single-file dashboard keeps its
+// logos with the network off. Simple Icons files are CC0-1.0; the marks stay their owners'
+// property and the dashboard uses them nominatively, to name the service that served a request.
+// A vendor with no Simple Icons entry keeps its owner-hosted mark, one with no hosted mark is
+// drawn inline (`dashboard/app/src/lib/marks/inline.ts`), and bumping `SIMPLE_ICONS` once moves
+// every Simple Icons entry with it.
+const SIMPLE_ICONS = "https://cdn.jsdelivr.net/npm/simple-icons@16/icons";
+/** Slug to mark URL. Only slugs named here resolve to a mark; the rest get a monogram. */
+export const REMOTE_MARKS = {
+    // Simple Icons, CC0-1.0.
+    anthropic: `${SIMPLE_ICONS}/anthropic.svg`,
+    google: `${SIMPLE_ICONS}/google.svg`,
+    meta: `${SIMPLE_ICONS}/meta.svg`,
+    deepseek: `${SIMPLE_ICONS}/deepseek.svg`,
+    qwen: `${SIMPLE_ICONS}/qwen.svg`,
+    x: `${SIMPLE_ICONS}/x.svg`,
+    mistralai: `${SIMPLE_ICONS}/mistralai.svg`,
+    minimax: `${SIMPLE_ICONS}/minimax.svg`,
+    zdotai: `${SIMPLE_ICONS}/zdotai.svg`,
+    xiaomi: `${SIMPLE_ICONS}/xiaomi.svg`,
+    kimi: `${SIMPLE_ICONS}/kimi.svg`,
+    moonshotai: `${SIMPLE_ICONS}/moonshotai.svg`,
+    nvidia: `${SIMPLE_ICONS}/nvidia.svg`,
+    amd: `${SIMPLE_ICONS}/amd.svg`,
+    ollama: `${SIMPLE_ICONS}/ollama.svg`,
+    cline: `${SIMPLE_ICONS}/cline.svg`,
+    githubcopilot: `${SIMPLE_ICONS}/githubcopilot.svg`,
+    openrouter: `${SIMPLE_ICONS}/openrouter.svg`,
+    github: `${SIMPLE_ICONS}/github.svg`,
+    instagram: `${SIMPLE_ICONS}/instagram.svg`,
+    reddit: `${SIMPLE_ICONS}/reddit.svg`,
+    // Owner-hosted, nominative use.
+    groq: "https://groq.com/favicon.svg",
+    poolside: "https://poolside.ai/favicon/favicon.svg",
+    cerebras: "https://cdn.sanity.io/images/e4qjo92p/production/e7a55ae5ab7e2c4fdfd4e66a51f628d1f2f44207-967x967.png?w=256&h=256&fit=max",
+    inclusionai: "https://cdn-avatars.huggingface.co/v1/production/uploads/662e1f9da266499277937d33/fyKuazRifqiaIO34xrhhm.jpeg",
+    // Owner avatars: the vendor or gateway posts no standalone icon, so its account picture stands in.
+    stepfun: "https://cdn-avatars.huggingface.co/v1/production/uploads/644f7e6233ac8f46fa0b9e26/CmF2ocXhkr2UtHXgmwq7-.png",
+    // typesafe.ai serves one full-bleed tile: a dark square with pink art inside it.
+    typesafe: "https://framerusercontent.com/images/aNFzSFxM4fjICmnibw7npfZjcQ.png",
+    // A gateway's own brand, which names the service that served the request. Never another vendor's logo.
+    opencode: "https://opencode.ai/favicon.svg",
+    commandcode: "https://commandcode.ai/favicon.ico",
+    kilo: "https://kilo.ai/favicon.ico",
+    magpie: "https://usemagpie.ai/favicon.png",
+    gmicloud: "https://gmicloud.ai/favicon.ico",
+    charmhyper: "https://github.com/charmbracelet.png?size=80",
+};
+/**
+ * Tile fill, not text. A mark whose tile carries its brand color reads as the brand, and a mark
+ * whose logo already fills its own box never shows the fill. Values come from the brand (the
+ * service's own page or its own asset), never from a guess; a slug absent here keeps the plain
+ * panel and the theme ink.
+ */
+export const MARK_BG = {
+    // Simple Icons marks: the vendor's brand color, taken from its own brand page.
+    anthropic: "#d97757",
+    meta: "#0082fb",
+    google: "#4285f4",
+    deepseek: "#4d6bfe",
+    qwen: "#6950ef",
+    mistralai: "#ff7000",
+    minimax: "#e11d48",
+    // Kimi's own favicon carries this blue, not the Moonshot violet.
+    kimi: "#1782fe",
+    xiaomi: "#ff6900",
+    nvidia: "#76b900",
+    amd: "#ed1c24",
+    x: "#000000",
+    ollama: "#000000",
+    zdotai: "#2d2d2d",
+    github: "#181717",
+    githubcopilot: "#181717",
+    cline: "#9f58fa",
+    openrouter: "#03080a",
+    instagram: "#e4405f",
+    reddit: "#ff4500",
+    linkedin: "#0a66c2",
+    // Owner-hosted marks: the tile matches the asset's own square, and a slug whose artwork already
+    // carries its own color takes a white tile so the art reads.
+    groq: "#f43e01",
+    poolside: "#4137ff",
+    cerebras: "#ffffff",
+    typesafe: "#171717",
+    charmhyper: "#ffffff",
+    stepfun: "#ffffff",
+    kilo: "#f7f576",
+    opencode: "#131010",
+    // The mark's own artwork is white, so the tile is white and the glyph is black.
+    openai: "#ffffff",
+    commandcode: "#ffffff",
+    gmicloud: "#ffffff",
+    magpie: "#0b0b0c",
+};
+/**
+ * Glyph scale per slug, applied to the glyph box the tile clips. Simple Icons art fills its 24 box
+ * by very different amounts, so the measured ink box decides the scale: a logo that runs to its
+ * box edge shrinks and one with an invisible margin grows. One is the default.
+ */
+export const MARK_SCALE = {
+    kimi: 0.72,
+    zdotai: 0.72,
+    openrouter: 0.9,
+    magpie: 1.15,
+};
+/** WCAG relative luminance of a `#rrggbb` string. */
+export function luminance(hex) {
+    const n = parseInt(hex.slice(1), 16);
+    const ch = [(n >> 16) & 255, (n >> 8) & 255, n & 255].map((v) => {
+        const s = v / 255;
+        return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+    });
+    return 0.2126 * ch[0] + 0.7152 * ch[1] + 0.0722 * ch[2];
+}
+/**
+ * The glyph color that stays legible on a tile fill. The cut sits at 0.35, which keeps white ink
+ * on a brand color: Meta blue, DeepSeek blue, Xiaomi orange, Mistral orange, and Kimi blue all
+ * carry a white logo, which is how their own brand sheets print them. Only a light neutral takes
+ * black: Kilo yellow, StepFun teal, and Lightbend orange.
+ */
+export function contrastInk(hex) {
+    return luminance(hex) > 0.35 ? "#000000" : "#ffffff";
+}
+/**
+ * Marks that carry their own color or their own background. Everything else is opaque black, so
+ * it draws as an alpha mask filled with the chosen ink instead of an image. A slug whose asset is
+ * a filled tile must draw as an image, or the mask paints one flat block and the logo vanishes.
+ */
+export const COLORED_MARKS = new Set([
+    "cerebras",
+    "inclusionai",
+    "typesafe",
+    "opencode",
+    "commandcode",
+    "kilo",
+    "magpie",
+    "charmhyper",
+    "stepfun",
+    // The ICO and the two inline PNGs are dark tiles with light art drawn inside them. The Groq
+    // favicon is one flat orange, so it draws as a mask instead: a masked glyph on a Groq-orange
+    // tile is a logo, and the same art as an image on the same orange tile is a blank tile.
+    "gmicloud",
+    "stealth",
+    "cognition",
+]);
+/** The URL a mark comes from, or null when the name has no hosted mark. */
+export function markUrl(slug) {
+    return REMOTE_MARKS[slug] ?? null;
+}
+/** True when the mark carries its own color and must draw as an image. */
+export function isColoredMark(slug) {
+    return COLORED_MARKS.has(slug);
+}

package/dist/extensions/shared/plugin-settings.js

@@ -1,7 +1,7 @@
 // One settings file for every host; parse failure yields {} with per-caller defaults.
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
-import { homeDir, tersioHome } from '../lib/utils.js';
+import { homeDir, tersioHome } from './utils.js';
 export const PLUGIN_NAME = '@krtclcdy/tersio';
 // The one store both hosts read; this module owns its path.
 export function tersioSettingsFile() {

package/dist/extensions/shared/pricing.js

@@ -1,9 +1,11 @@
 // extensions/shared/pricing.ts — dynamic model pricing from LiteLLM. Exact id → provider-prefix strip → default, reported with known:false when unpriced.
 import fs from 'node:fs';
 import path from 'node:path';
-import { tersioDataPath } from '../lib/utils.js';
+import { tersioDataPath } from './utils.js';
 // Sonnet-class default for unpriced models; always paired with known:false.
 export const DEFAULT_PRICE = { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 };
+/** Tiers firm enough to call a price. `tail` and `default` are estimates, so they are not. */
+export const PRICE_TIERS_FIRM = ['measured', 'override', 'exact', 'alias'];
 const LITELLM_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
 // Readers use the file even when stale, and only one refresh runs per process; `tersio update` still forces a fresh fetch.
 const CACHE_TTL_MS = 7 * 24 * 3600 * 1000;
@@ -14,6 +16,53 @@ export function pricesCachePath() {
         return override;
     return tersioDataPath('prices.json', 'tersio-prices.json');
 }
+/**
+ * The operator's own prices, merged over the feed and keyed exactly as the transcript spells a
+ * model. A `*` prefix matches any gateway suffix. This is where a model the feed keys under a
+ * different provider gets a real price.
+ */
+export function pricesOverridePath() {
+    const override = process.env.TERSIO_PRICES_OVERRIDE_FILE;
+    if (override)
+        return override;
+    return tersioDataPath('prices.local.json', 'tersio-prices.local.json');
+}
+/** The override file's mtime, or 0 when absent. Callers key their memo on it. */
+function overrideStamp() {
+    try {
+        return fs.statSync(pricesOverridePath()).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+let overrideCache = null;
+/** Reads the override file, keeping a `*`-prefixed entry as a suffix matcher. */
+function loadOverrides(stamp = overrideStamp()) {
+    if (stamp === 0)
+        return null;
+    const file = pricesOverridePath();
+    if (overrideCache && overrideCache.stamp === stamp)
+        return overrideCache;
+    const exact = new Map();
+    const tails = [];
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        for (const [id, row] of Object.entries(parsed ?? {})) {
+            const price = asPrice(row);
+            if (!price)
+                continue;
+            // A `*` prefix matches any gateway prefix, so one entry covers every spelling of a model.
+            if (id.startsWith('*'))
+                tails.push([id.slice(1).toLowerCase(), price]);
+            else
+                exact.set(id, price);
+        }
+    }
+    catch { /* an unreadable override is empty, not fatal */ }
+    overrideCache = { stamp, exact, tails };
+    return overrideCache;
+}
 export function pricesUrl() {
     return process.env.TERSIO_PRICES_URL || LITELLM_URL;
 }
@@ -94,26 +143,26 @@ export function canonicalPriceId(model) {
 export function priceFor(model, live) {
     const table = live === undefined ? loadLivePrices() : live;
     if (live === undefined) {
-        const memo = priceMemo(table);
+        // An operator who edits the override file expects the new price at once, not after a refresh.
+        const stamp = overrideStamp();
+        if (memoTable !== table || memoStamp !== stamp) {
+            memoTable = table;
+            memoStamp = stamp;
+            memo = new Map();
+        }
         const hit = memo.get(model);
         if (hit)
             return hit;
-        const resolved = resolvePrice(model, table);
+        const resolved = resolvePrice(model, table, stamp);
         memo.set(model, resolved);
         return resolved;
     }
-    return resolvePrice(model, table);
+    return resolvePrice(model, table, overrideStamp());
 }
 // Recent rows repeat a handful of models; the memo turns thousands of lookups into one per model. Cleared whenever the table identity changes.
 let memoTable;
+let memoStamp = 0;
 let memo = new Map();
-function priceMemo(table) {
-    if (memoTable !== table) {
-        memoTable = table;
-        memo = new Map();
-    }
-    return memo;
-}
 // Validated once per table instead of once per lookup.
 let compiledTable = null;
 let compiledEntries = [];
@@ -130,28 +179,43 @@ function priceEntries(table) {
     compiledEntries = entries;
     return entries;
 }
-function resolvePrice(model, table) {
-    // An alias goes through the same exact-then-suffix chain as any other id, so it still resolves when the feed keys it under a provider prefix.
-    const id = MODEL_ALIASES.find((a) => a.id === model.toLowerCase())?.feed ?? model;
+function resolvePrice(model, table, stamp = overrideStamp()) {
+    // The operator's file wins outright: it is the only source that can name what a gateway charges.
+    const overrides = loadOverrides(stamp);
+    if (overrides) {
+        const own = overrides.exact.get(model) ?? overrides.exact.get(model.toLowerCase());
+        if (own)
+            return { price: own, known: true, live: false, tier: 'override' };
+        const low = model.toLowerCase();
+        for (const [suffix, price] of overrides.tails) {
+            if (low === suffix || low.endsWith(`/${suffix}`)) {
+                return { price, known: true, live: false, tier: 'override' };
+            }
+        }
+    }
+    // An alias goes through the same chain as any other id, so it still resolves when the feed keys
+    // it under a provider prefix.
+    const alias = MODEL_ALIASES.find((a) => a.id === model.toLowerCase());
+    const id = alias?.feed ?? model;
     if (table) {
         const entries = priceEntries(table);
-        const lower = id.toLowerCase();
-        const hit = entries.find(([k]) => k === id) ?? entries.find(([k]) => k === lower);
+        // 1. The id verbatim, then case-folded. Nothing is being guessed here.
+        const hit = entries.find(([k]) => k === id) ?? entries.find(([k]) => k === id.toLowerCase());
         if (hit)
-            return { price: hit[1], known: true, live: true };
-        // Provider-prefixed ids ("azure/gpt-4o", "dashscope/qwen-max"): match the
-        // first cached key that ends with the full id, then with the bare tail
-        // segment, so "codex/openai/gpt-6-luna" still finds "gpt-6-luna".
-        const name = lower;
-        const tail = name.split('/').pop() ?? name;
-        const key = entries.find(([k]) => {
+            return { price: hit[1], known: true, live: true, tier: alias ? 'alias' : 'exact' };
+        const lower = id.toLowerCase();
+        const tail = lower.split('/').pop() ?? lower;
+        // The bare model name under any provider, which need not be the provider that billed the row.
+        // Reported as tier `tail`, so a caller keeps it out of a firm total; `prices.local.json` fixes
+        // a specific case.
+        const bare = entries.find(([k]) => {
             const lk = k.toLowerCase();
-            return lk === name || lk.endsWith(`/${name}`) || lk === tail || lk.endsWith(`/${tail}`);
+            return lk === tail || lk.endsWith(`/${tail}`);
         });
-        if (key)
-            return { price: key[1], known: true, live: true };
+        if (bare)
+            return { price: bare[1], known: true, live: true, tier: 'tail' };
     }
-    return { price: DEFAULT_PRICE, known: false, live: false };
+    return { price: DEFAULT_PRICE, known: false, live: false, tier: 'default' };
 }
 // Fetch LiteLLM pricing and write the cache. False on any failure — callers fall back silently.
 export async function refreshPrices() {

package/dist/extensions/shared/usage-ledger.js

@@ -1,7 +1,7 @@
 // Shared usage ledger: append-only JSON lines, read by the CLI, `/tersio`, and the Dashboard. Best-effort; corrupt lines are skipped on read.
 import fs from 'node:fs';
 import path from 'node:path';
-import { homeDir, isPiProcess, piAgentDir, resolveRtkBinary, tersioDataPath } from '../lib/utils.js';
+import { homeDir, isPiProcess, piAgentDir, resolveRtkBinary, tersioDataPath } from './utils.js';
 import { execFileSync } from 'node:child_process';
 export function ledgerPath() {
     const override = process.env.TERSIO_USAGE_FILE;
@@ -223,9 +223,9 @@ const RTK_ELIGIBLE_HEADS = new Set([
     'ruff', 'mypy', 'docker', 'kubectl', 'psql', 'aws', 'gh', 'glab', 'wc',
 ]);
 export function newSessionAccum() {
-    return { byModel: {}, byDay: {}, byDayModel: {}, byTool: {}, byModelMessages: {}, byHost: {}, totals: zeroBreakdown(), messages: 0, costMeasured: 0, recent: [] };
+    return { byModel: {}, byDay: {}, byDayModel: {}, byTool: {}, byModelMessages: {}, byHost: {}, byAgent: {}, byAgentMessages: {}, byModelMeasured: {}, byModelCostMessages: {}, totals: zeroBreakdown(), messages: 0, costMeasured: 0, recent: [], recentFloor: Number.POSITIVE_INFINITY };
 }
-export function ingestSessionRow(accum, model, usage, ts, durMs, run, toolNames, host, id) {
+export function ingestSessionRow(accum, model, usage, ts, durMs, run, toolNames, host, id, agent) {
     const watermark = readResetWatermark();
     const ms = ts === undefined ? NaN : typeof ts === 'number' ? ts : Date.parse(ts);
     if (watermark > 0 && (!Number.isFinite(ms) || ms < watermark))
@@ -240,10 +240,33 @@ export function ingestSessionRow(accum, model, usage, ts, durMs, run, toolNames,
         hs[host] ??= zeroBreakdown();
         addInto(hs[host], usage);
     }
+    if (agent) {
+        const as = (accum.byAgent[key] ??= {});
+        as[agent] ??= zeroBreakdown();
+        addInto(as[agent], usage);
+        const am = (accum.byAgentMessages[key] ??= {});
+        am[agent] = (am[agent] ?? 0) + 1;
+    }
     const num = (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.floor(v) : 0);
     if (Number.isFinite(ms)) {
         const outcome = run ?? { st: 'completed' };
-        accum.recent.push({ m: key, i: num(usage.input), o: num(usage.output), t: ms, d: durOf(durMs), h: host, cr: num(usage.cacheRead), cw: num(usage.cacheWrite), usd: costOf(usage), st: outcome.st, code: outcome.code, note: outcome.note, id });
+        // The store holds every message ever recorded, but only the newest few are ever read. Skip
+        // anything older than the floor, and re-read the floor when the list is full, so a 50k-row
+        // store costs 2000 rows of memory instead of 50k.
+        if (accum.recent.length < RECENT_LIMIT || ms >= accum.recentFloor) {
+            accum.recent.push({ m: key, i: num(usage.input), o: num(usage.output), t: ms, d: durOf(durMs), h: host, cr: num(usage.cacheRead), cw: num(usage.cacheWrite), usd: costOf(usage), st: outcome.st, code: outcome.code, note: outcome.note, id });
+            if (accum.recent.length > RECENT_LIMIT) {
+                let drop = 0;
+                for (let k = 1; k < accum.recent.length; k += 1)
+                    if (accum.recent[k].t < accum.recent[drop].t)
+                        drop = k;
+                accum.recent.splice(drop, 1);
+                accum.recentFloor = accum.recent.reduce((lo, r) => Math.min(lo, r.t), Number.POSITIVE_INFINITY);
+            }
+            else if (ms < accum.recentFloor) {
+                accum.recentFloor = ms;
+            }
+        }
     }
     const day = ts !== undefined ? dayKey(ts) : null;
     if (day) {
@@ -257,8 +280,11 @@ export function ingestSessionRow(accum, model, usage, ts, durMs, run, toolNames,
     }
     accum.messages += 1;
     const measured = costOf(usage);
-    if (measured !== undefined)
+    if (measured !== undefined) {
         accum.costMeasured += measured;
+        accum.byModelMeasured[key] = (accum.byModelMeasured[key] ?? 0) + measured;
+        accum.byModelCostMessages[key] = (accum.byModelCostMessages[key] ?? 0) + 1;
+    }
     for (const name of toolNames ?? [])
         accum.byTool[name] = (accum.byTool[name] ?? 0) + 1;
     return true;
@@ -352,14 +378,14 @@ export function processOpencodeFile(accum, text, file) {
     if (!parsed)
         return;
     const id = file ? path.basename(file).replace(/\.[^.]+$/, '') || undefined : undefined;
-    ingestSessionRow(accum, parsed.model, parsed.usage, parsed.ms, parsed.durMs, { st: 'completed' }, undefined, 'opencode', id);
+    ingestSessionRow(accum, parsed.model, parsed.usage, parsed.ms, parsed.durMs, { st: 'completed' }, undefined, 'opencode', id, 'main');
 }
 // One v2 message row into the shared accum. The msg id is the row primary key.
 export function ingestOpencodeDbRow(accum, row) {
     const parsed = classifyOpencodeMessage(row.row);
     if (!parsed)
         return;
-    ingestSessionRow(accum, parsed.model, parsed.usage, parsed.ms, parsed.durMs, { st: 'completed' }, undefined, 'opencode', row.id);
+    ingestSessionRow(accum, parsed.model, parsed.usage, parsed.ms, parsed.durMs, { st: 'completed' }, undefined, 'opencode', row.id, 'main');
 }
 // Fold `:free`/`-free` suffixes and case variants into one chart key.
 export function canonicalModelId(model) {
@@ -491,10 +517,10 @@ export function importSessionTokens() {
             set codexProvider(v) { codexProvider = v; },
             get codexModel() { return codexModel; },
             set codexModel(v) { codexModel = v; },
-        }, text, hostOfSessionFile(file));
+        }, text, hostOfSessionFile(file), agentOfSessionText(text));
     }
     accum.recent.sort((a, b) => b.t - a.t);
-    return { messages: accum.messages, totals: accum.totals, byModel: accum.byModel, byDay: accum.byDay, byDayModel: accum.byDayModel, byTool: accum.byTool, byModelMessages: accum.byModelMessages, byHost: accum.byHost, costMeasured: accum.costMeasured, recent: accum.recent.slice(0, RECENT_LIMIT) };
+    return { messages: accum.messages, totals: accum.totals, byModel: accum.byModel, byDay: accum.byDay, byDayModel: accum.byDayModel, byTool: accum.byTool, byModelMessages: accum.byModelMessages, byHost: accum.byHost, byAgent: accum.byAgent, byAgentMessages: accum.byAgentMessages, byModelMeasured: accum.byModelMeasured, byModelCostMessages: accum.byModelCostMessages, costMeasured: accum.costMeasured, recent: accum.recent.slice(0, RECENT_LIMIT) };
 }
 // Which agent wrote a session file, from the directory it sits in.
 export function hostOfSessionFile(file) {
@@ -507,6 +533,24 @@ export function hostOfSessionFile(file) {
         return 'opencode';
     return 'pi';
 }
+// Which agent ran a session file, from its own `session` row: a transcript with a parent
+// session is a subagent's, and everything else is the main agent. The row is the host's own
+// record, so a mirrored transcript carries the same answer as the stats database.
+export function agentOfSessionText(text) {
+    if (!text.includes('parentSession'))
+        return 'main';
+    for (const line of text.split('\n')) {
+        if (!line.includes('parentSession'))
+            continue;
+        try {
+            const row = JSON.parse(line);
+            if (row.type === 'session' && typeof row.parentSession === 'string' && row.parentSession !== '')
+                return 'subagent';
+        }
+        catch { /* skip a corrupt line */ }
+    }
+    return 'main';
+}
 const adoptionFileCache = new Map();
 function parseAdoptionFile(file) {
     const counts = { bashCalls: 0, eligibleCalls: 0, rtkCalls: 0 };
@@ -581,7 +625,7 @@ export function readRtkAdoption() {
     const missedCalls = Math.max(0, eligibleCalls - rtkCalls);
     return { sessions, bashCalls, eligibleCalls, rtkCalls, missedCalls, adoptionPct: eligibleCalls ? (rtkCalls / eligibleCalls) * 100 : 0 };
 }
-export function processSessionText(accum, state, text, host) {
+export function processSessionText(accum, state, text, host, agent) {
     for (const line of text.split('\n')) {
         if (!line.trim())
             continue;
@@ -603,12 +647,12 @@ export function processSessionText(accum, state, text, host) {
                 const base = parsed.provider ? `codex/${parsed.provider}` : (state.codexProvider ? `codex/${state.codexProvider}` : 'codex');
                 // The provider alone told you nothing about which model ran.
                 const model = state.codexModel ? `${base}/${state.codexModel}` : base;
-                ingestSessionRow(accum, model, parsed.usage ?? {}, row.timestamp, parsed.durMs, { st: 'completed' }, undefined, host ?? 'codex', rid);
+                ingestSessionRow(accum, model, parsed.usage ?? {}, row.timestamp, parsed.durMs, { st: 'completed' }, undefined, host ?? 'codex', rid, agent);
                 continue;
             }
             if (parsed.kind !== 'assistant_row' || !parsed.model || !parsed.usage)
                 continue;
-            ingestSessionRow(accum, parsed.model, parsed.usage, row.timestamp, parsed.durMs, parsed.run, parsed.tools, host, rid);
+            ingestSessionRow(accum, parsed.model, parsed.usage, row.timestamp, parsed.durMs, parsed.run, parsed.tools, host, rid, agent);
         }
         catch { /* skip corrupt lines */ }
     }
@@ -653,13 +697,28 @@ export function leadBinary(command) {
     return 'bash';
 }
 // --- Pricing lives in ./pricing.ts (live LiteLLM cache + fallback table) ---
-import { DEFAULT_PRICE, canonicalPriceId, priceFor, refreshPricesIfStale } from './pricing.js';
+import { DEFAULT_PRICE, PRICE_TIERS_FIRM, canonicalPriceId, priceFor, pricesOverridePath, refreshPricesIfStale } from './pricing.js';
 import { co2GramsFor, energyWhFor } from './carbon.js';
-export { DEFAULT_PRICE, priceFor, refreshPricesIfStale };
+export { DEFAULT_PRICE, PRICE_TIERS_FIRM, priceFor, pricesOverridePath, refreshPricesIfStale };
 export { co2GramsFor, energyWhFor };
-export function usdCost(t, model) {
-    const { price, known } = model ? priceFor(model) : { price: DEFAULT_PRICE, known: false };
+/**
+ * Price one model's tokens. `measured` is the cost the host reported for those tokens; it outranks
+ * every rate card, because it is the only figure from the party that billed. Pass undefined rather
+ * than 0 for a cost nobody reported: `costOf` keeps the two apart.
+ */
+export function usdCost(t, model, measured) {
     const m = 1 / 1_000_000;
+    if (measured !== undefined) {
+        // Only a bare total arrives, so it attributes to input, the largest bucket for every model here.
+        return {
+            usd: measured,
+            priced: true,
+            tier: 'measured',
+            buckets: { input: measured, output: 0, cacheRead: 0, cacheWrite: 0 },
+        };
+    }
+    const hit = model ? priceFor(model) : { price: DEFAULT_PRICE, known: false, live: false, tier: 'default' };
+    const price = hit.price;
     const buckets = {
         input: t.input * price.input * m,
         output: t.output * price.output * m,
@@ -668,7 +727,10 @@ export function usdCost(t, model) {
     };
     return {
         usd: buckets.input + buckets.output + buckets.cacheRead + buckets.cacheWrite,
-        priced: model ? known : false,
+        // A tier the caller cannot stand behind is not a price. `tail` and `default` are estimates,
+        // and a report that sums them beside measured cost reads as a bill it is not.
+        priced: PRICE_TIERS_FIRM.includes(hit.tier),
+        tier: hit.tier,
         buckets,
     };
 }