@krtclcdy/tersio 2.23.0 → 2.24.1

package/extensions/shared/usage-ledger.ts

@@ -1,11 +1,9 @@
-// Shared usage ledger: append-only JSON-lines file. One source of truth read
-// by `tersio usage`, `/tersio usage`, and the Dashboard.
-// Best-effort by design: a ledger failure never breaks the caller, and
-// corrupt lines are skipped on read (same pattern as the config normalizer).
+// 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 os from 'node:os';
 import path from 'node:path';
-import { resolveRtkBinary, tersioDataPath } from '../lib/utils.ts';
+import { isPiProcess, piAgentDir, resolveRtkBinary, tersioDataPath } from '../lib/utils.ts';
 import { execFileSync } from 'node:child_process';
 
 export type UsageKind = 'command' | 'toggle' | 'install' | 'update' | 'rtk-audit';
@@ -22,11 +20,7 @@ export function ledgerPath(): string {
   return tersioDataPath('usage.jsonl', 'tersio-usage.jsonl');
 }
 
-// Reset watermark: tersio-owned timestamp marking the last statistics reset.
-// Session transcripts and the RTK database are host/tool-owned and never
-// touched — instead, every derived view (token stats, command tools) filters
-// rows from before the watermark, so "reset" empties what tersio shows
-// without deleting anything it does not own.
+// Reset watermark: views filter rows older than it, so nothing else is deleted.
 export function resetMarkerPath(): string {
   const override = process.env.TERSIO_RESET_FILE;
   if (override) return override;
@@ -59,10 +53,7 @@ export function appendUsage(kind: UsageKind, detail: string): void {
 }
 
 // --- Session tokens, tokscale-style ------------------------------------------
-// OMP writes per-assistant-message usage into ~/.omp/agent/sessions/**/*.jsonl:
-// message.role === 'assistant', message.usage = { input, output, cacheRead,
-// cacheWrite }, message.model, plus a per-line timestamp. Same source tokscale
-// parses for its oh-my-pi client. Best-effort: unreadable files are skipped.
+// Assistant messages in the host transcripts carry usage, model, and a timestamp.
 export interface TokenBreakdown {
   input: number;
   output: number;
@@ -70,10 +61,7 @@ export interface TokenBreakdown {
   cacheWrite: number;
 }
 
-// Run outcome for one assistant message. OMP writes stopReason on every turn
-// (toolUse | stop | aborted | error) and, when the request failed, an HTTP
-// errorStatus plus errorMessage. `toolUse` is an ordinary turn that handed off
-// to tools, so it reads as completed rather than as a distinct state.
+// `toolUse` is an ordinary turn that handed off to tools, so it reads completed.
 export type RunStatus = 'completed' | 'aborted' | 'error';
 
 export interface RecentRequest {
@@ -82,11 +70,11 @@ export interface RecentRequest {
   o: number;
   t: number;
   d?: number;
+  /** Which agent wrote the session: pi, omp, or codex. */
+  h?: string;
   cr?: number;
   cw?: number;
-  // Measured spend for this message, from the transcript's usage.cost.total.
-  // Left undefined when the host recorded no cost — never backfilled with an
-  // estimate, so a measured figure is never mistaken for a modeled one.
+  // Undefined when the host recorded no cost; never backfilled.
   usd?: number;
   st: RunStatus;
   code?: number;
@@ -123,14 +111,16 @@ export interface RtkRecallDiagnostics {
 function zeroBreakdown(): TokenBreakdown {
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 }
+function stampMs(ts: string | number | undefined): number {
+  return ts === undefined ? NaN : typeof ts === 'number' ? ts : Date.parse(ts);
+}
+
 export function durOf(v: unknown): number | undefined {
   return typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined;
 }
 
-// Measured cost for one message. OMP writes usage.cost as
-// { input, output, cacheRead, cacheWrite, total }; a bare number shows up in
-// older fixtures. Anything else means "not recorded" — deliberately not 0, so
-// the dashboard can tell a genuinely free run from an unrecorded one.
+// Measured cost: usage.cost.total, or a bare number in old fixtures. Anything
+// else means unrecorded, which is deliberately not 0.
 export function costOf(usage: Record<string, unknown>): number | undefined {
   const c = usage.cost;
   if (typeof c === 'number') return Number.isFinite(c) ? c : undefined;
@@ -163,10 +153,20 @@ function addInto(into: TokenBreakdown, u: { input?: unknown; output?: unknown; c
   }
 }
 
-export function sessionsDir(): string {
+export function sessionsDirs(): string[] {
   const override = process.env.TERSIO_SESSIONS_DIR;
-  if (override) return override;
-  return path.join(os.homedir(), '.omp', 'agent', 'sessions');
+  if (override) return [override];
+  // Both hosts, not just the running one: a session on pi is missing from the
+  // dashboard entirely if we stop at the first directory that exists.
+  const dirs = isPiProcess()
+    ? [path.join(piAgentDir(), 'sessions'), path.join(os.homedir(), '.omp', 'agent', 'sessions')]
+    : [path.join(os.homedir(), '.omp', 'agent', 'sessions'), path.join(piAgentDir(), 'sessions')];
+  const found = dirs.filter((dir) => fs.existsSync(dir));
+  return found.length > 0 ? found : [dirs[0]];
+}
+
+export function sessionsDir(): string {
+  return sessionsDirs()[0];
 }
 
 export function codexSessionsDir(): string {
@@ -177,6 +177,19 @@ export function codexSessionsDir(): string {
   return path.join(os.homedir(), '.codex', 'sessions');
 }
 
+// One JSON file per message; probe XDG, then local, then macOS default.
+export function opencodeSessionsDir(): string {
+  const override = process.env.TERSIO_OPENCODE_DIR;
+  if (override) return override;
+  const xdg = process.env.XDG_DATA_HOME;
+  if (xdg && xdg.trim() !== '') return path.join(xdg, 'opencode', 'storage', 'message');
+  const local = path.join(os.homedir(), '.local', 'share', 'opencode', 'storage', 'message');
+  try {
+    if (fs.existsSync(local)) return local;
+  } catch { /* fall through to the platform default */ }
+  return path.join(os.homedir(), 'Library', 'Application Support', 'opencode', 'storage', 'message');
+}
+
 export function dayKey(ts: string | number): string | null {
   const ms = typeof ts === 'number' ? ts : Date.parse(ts);
   if (!Number.isFinite(ms)) return null;
@@ -184,7 +197,7 @@ export function dayKey(ts: string | number): string | null {
   const p = (n: number): string => String(n).padStart(2, '0');
   return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
 }
-export function walkJsonl(dir: string, out: string[], cap: number): void {
+export function walkJsonl(dir: string, out: string[], cap: number, ext = '.jsonl'): void {
   let entries: fs.Dirent[];
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -194,13 +207,12 @@ export function walkJsonl(dir: string, out: string[], cap: number): void {
   for (const e of entries) {
     if (out.length >= cap) return;
     const full = path.join(dir, e.name);
-    if (e.isDirectory()) walkJsonl(full, out, cap);
-    else if (e.isFile() && e.name.endsWith('.jsonl')) out.push(full);
+    if (e.isDirectory()) walkJsonl(full, out, cap, ext);
+    else if (e.isFile() && e.name.endsWith(ext)) out.push(full);
   }
 }
-// Recent requests are their own full-width table in the dashboard, so this is
-// a payload bound rather than a "few highlights" bound. Rows are small
-// (model, tokens, timing, status), so a few hundred cost little to ship.
+// Recent requests get their own full-width table, so this bounds payload
+// rather than highlights; rows are small, so a few hundred cost little.
 export const RECENT_LIMIT = 200;
 const FREE_SUFFIX = /(?::free|-free)$/i;
 const RTK_ELIGIBLE_HEADS = new Set([
@@ -208,8 +220,8 @@ const RTK_ELIGIBLE_HEADS = new Set([
   'npm', 'npx', 'pnpm', 'bun', 'bunx', 'cargo', 'go', 'python', 'pytest',
   'ruff', 'mypy', 'docker', 'kubectl', 'psql', 'aws', 'gh', 'glab', 'wc',
 ]);
-// Session-parse buffer shared by live reads and usage.db syncs: identical
-// inputs produce identical aggregates, so the store is a cache, never a fork.
+// Parse buffer shared by live reads and usage.db syncs, so the store is a
+// cache and never a fork.
 export interface SessionAccum {
   byModel: Record<string, TokenBreakdown>;
   byDay: Record<string, TokenBreakdown>;
@@ -224,7 +236,7 @@ export interface SessionAccum {
 export function newSessionAccum(): SessionAccum {
   return { byModel: {}, byDay: {}, byDayModel: {}, byTool: {}, byModelMessages: {}, totals: zeroBreakdown(), messages: 0, costMeasured: 0, recent: [] };
 }
-export function ingestSessionRow(accum: SessionAccum, model: string, usage: Record<string, unknown>, ts: string | number | undefined, durMs?: unknown, run?: { st: RunStatus; code?: number; note?: string }, toolNames?: string[]): boolean {
+export function ingestSessionRow(accum: SessionAccum, model: string, usage: Record<string, unknown>, ts: string | number | undefined, durMs?: unknown, run?: { st: RunStatus; code?: number; note?: string }, toolNames?: string[], host?: string): boolean {
   const watermark = readResetWatermark();
   const ms = ts === undefined ? NaN : typeof ts === 'number' ? ts : Date.parse(ts);
   if (watermark > 0 && (!Number.isFinite(ms) || ms < watermark)) return false;
@@ -236,7 +248,7 @@ export function ingestSessionRow(accum: SessionAccum, model: string, usage: Reco
   const num = (v: unknown): number => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.floor(v) : 0);
   if (Number.isFinite(ms)) {
     const outcome = run ?? { st: 'completed' as RunStatus };
-    accum.recent.push({ m: key, i: num(usage.input), o: num(usage.output), t: ms, d: durOf(durMs), cr: num(usage.cacheRead), cw: num(usage.cacheWrite), usd: costOf(usage), st: outcome.st, code: outcome.code, note: outcome.note });
+    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 });
   }
   const day = ts !== undefined ? dayKey(ts) : null;
   if (day) {
@@ -254,11 +266,15 @@ export function ingestSessionRow(accum: SessionAccum, model: string, usage: Reco
   for (const name of toolNames ?? []) accum.byTool[name] = (accum.byTool[name] ?? 0) + 1;
   return true;
 }
-export type SessionLineKind = 'codex_provider' | 'token_row' | 'assistant_row' | 'skip';
-export function classifySessionLine(row: { timestamp?: string | number; type?: unknown; message?: { role?: unknown; model?: unknown; usage?: Record<string, unknown>; duration?: unknown; completedAt?: unknown; timestamp?: unknown; stopReason?: unknown; errorStatus?: unknown; errorMessage?: unknown; isError?: unknown; content?: Array<{ type?: unknown; name?: unknown; arguments?: unknown }> }; payload?: { type?: unknown; model_provider?: unknown; info?: { last_token_usage?: Record<string, unknown> } } }): { kind: SessionLineKind; provider?: string; model?: string; usage?: Record<string, unknown>; durMs?: number; run?: { st: RunStatus; code?: number; note?: string }; tools?: string[]; ms?: number } {
+export type SessionLineKind = 'codex_provider' | 'codex_model' | 'token_row' | 'assistant_row' | 'skip';
+export function classifySessionLine(row: { timestamp?: string | number; type?: unknown; message?: { role?: unknown; model?: unknown; usage?: Record<string, unknown>; duration?: unknown; completedAt?: unknown; timestamp?: unknown; stopReason?: unknown; errorStatus?: unknown; errorMessage?: unknown; isError?: unknown; content?: Array<{ type?: unknown; name?: unknown; arguments?: unknown }> }; payload?: { type?: unknown; model?: unknown; model_provider?: unknown; info?: { last_token_usage?: Record<string, unknown> } } }): { kind: SessionLineKind; provider?: string; model?: string; usage?: Record<string, unknown>; durMs?: number; run?: { st: RunStatus; code?: number; note?: string }; tools?: string[]; ms?: number } {
   const payload = row.payload;
   if (payload && typeof payload === 'object') {
     if (row.type === 'session_meta' && typeof payload.model_provider === 'string') return { kind: 'codex_provider', provider: payload.model_provider };
+    // A Codex transcript states the model once per turn, in turn_context.
+    if (row.type === 'turn_context' && typeof payload.model === 'string' && payload.model) {
+      return { kind: 'codex_model', model: payload.model };
+    }
     if (payload.type === 'token_count') {
       const last = payload.info?.last_token_usage;
       if (last) {
@@ -271,7 +287,10 @@ export function classifySessionLine(row: { timestamp?: string | number; type?: u
   const msg = row.message;
   if (!msg || msg.role !== 'assistant' || !msg.usage) return { kind: 'skip' };
   const model = typeof msg.model === 'string' && msg.model ? msg.model : 'unknown';
-  const computedDur = (typeof msg.completedAt === 'number' && typeof msg.timestamp === 'number') ? msg.completedAt - msg.timestamp : undefined;
+  // pi omits duration, so derive Elapsed/Speed from the timestamp pair.
+  const startMs = typeof msg.timestamp === 'number' ? msg.timestamp : undefined;
+  const endMs = typeof msg.completedAt === 'number' ? msg.completedAt : stampMs(row.timestamp);
+  const computedDur = startMs !== undefined && Number.isFinite(endMs) && endMs > startMs ? endMs - startMs : undefined;
   const tools: string[] = [];
   for (const part of msg.content ?? []) {
     if (part?.type !== 'toolCall' || typeof part.name !== 'string' || !part.name) continue;
@@ -284,13 +303,70 @@ export function classifySessionLine(row: { timestamp?: string | number; type?: u
   }
   return { kind: 'assistant_row', model, usage: msg.usage, durMs: typeof msg.duration === 'number' ? msg.duration : computedDur, run: statusOf(msg), tools };
 }
-// Fold `:free`/`-free` suffixes and case variants into one chart key, so the
-// same model from two providers stops splitting into separate rows.
+// True when at least one token bucket holds a positive finite count.
+export function hasPositiveUsage(usage: Record<string, unknown>): boolean {
+  for (const k of ['input', 'output', 'cacheRead', 'cacheWrite']) {
+    const v = usage[k];
+    if (typeof v === 'number' && Number.isFinite(v) && v > 0) return true;
+  }
+  return false;
+}
+
+export interface OpencodeMessage {
+  role?: unknown;
+  tokens?: { input?: unknown; output?: unknown; reasoning?: unknown; cache?: { read?: unknown; write?: unknown } } | null;
+  modelID?: unknown;
+  providerID?: unknown;
+  time?: { created?: unknown; completed?: unknown } | null;
+  cost?: unknown;
+  finish?: unknown;
+}
+
+// One OpenCode message file; assistant rows carry the token buckets.
+export function classifyOpencodeMessage(obj: OpencodeMessage | null | undefined): { model: string; usage: Record<string, unknown>; ms: number | undefined; durMs: number | undefined } | null {
+  if (!obj || typeof obj !== 'object' || obj.role !== 'assistant') return null;
+  const t = obj.tokens;
+  if (!t || typeof t !== 'object') return null;
+  const usage: Record<string, unknown> = {
+    input: t.input,
+    output: t.output,
+    cacheRead: t.cache?.read,
+    cacheWrite: t.cache?.write,
+    cost: (obj as Record<string, unknown>).cost,
+  };
+  if (!hasPositiveUsage(usage)) return null;
+  const provider = typeof obj.providerID === 'string' && obj.providerID ? obj.providerID : 'unknown';
+  const model = typeof obj.modelID === 'string' && obj.modelID ? obj.modelID : 'unknown';
+  const num = (v: unknown): number | undefined => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined);
+  const created = num(obj.time?.created);
+  const completed = num(obj.time?.completed);
+  return {
+    model: `opencode/${provider}/${model}`,
+    usage,
+    ms: created,
+    durMs: created !== undefined && completed !== undefined && completed > created ? completed - created : undefined,
+  };
+}
+
+// One OpenCode message file into the shared accum.
+export function processOpencodeFile(accum: SessionAccum, text: string): void {
+  let obj: unknown;
+  try {
+    obj = JSON.parse(text);
+  } catch {
+    return;
+  }
+  const parsed = classifyOpencodeMessage(obj as OpencodeMessage);
+  if (!parsed) return;
+  ingestSessionRow(accum, parsed.model, parsed.usage, parsed.ms, parsed.durMs, { st: 'completed' as RunStatus }, undefined, 'opencode');
+}
+
+// Fold `:free`/`-free` suffixes and case variants into one chart key.
 export function canonicalModelId(model: string): string {
-  return model.replace(FREE_SUFFIX, '').toLowerCase();
+  return canonicalPriceId(model.replace(FREE_SUFFIX, ''));
 }
-// LiteLLM-style display: namespace stays lowercase, model segments title-case
-// with version dots kept (`deepseek-v4.1-flash` → `Deepseek-V4.1-Flash`).
+// LiteLLM-style display: lowercase namespace, title-cased model segments with
+// version dots kept.
 export function displayModelId(model: string): string {
   const bare = model.replace(FREE_SUFFIX, '');
   const cap = (s: string): string => {
@@ -311,13 +387,28 @@ export function displayModelId(model: string): string {
 export function importSessionTokens(): SessionTokens {
   const accum = newSessionAccum();
   const files: string[] = [];
-  walkJsonl(sessionsDir(), files, 2000);
-  // A sessions override signals an isolated environment (tests, fixtures):
-  // only walk the real codex dir when it is explicitly set.
+  for (const dir of sessionsDirs()) walkJsonl(dir, files, 2000);
+  // An override means an isolated environment (tests, fixtures): only walk the
+  // real codex dir when one is explicitly set.
   if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_CODEX_DIR !== undefined) {
     walkJsonl(codexSessionsDir(), files, 2000);
   }
+  // OpenCode message bodies are single JSON documents, not JSONL.
+  const ocFiles: string[] = [];
+  if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_OPENCODE_DIR !== undefined) {
+    walkJsonl(opencodeSessionsDir(), ocFiles, 5000, '.json');
+  }
+  for (const file of ocFiles) {
+    let text: string;
+    try {
+      text = fs.readFileSync(file, 'utf8');
+    } catch {
+      continue;
+    }
+    processOpencodeFile(accum, text);
+  }
   let codexProvider: string | null = null;
+  let codexModel: string | null = null;
   for (const file of files) {
     let text: string;
     try {
@@ -325,12 +416,25 @@ export function importSessionTokens(): SessionTokens {
     } catch {
       continue;
     }
-    processSessionText(accum, { get codexProvider() { return codexProvider; }, set codexProvider(v: string | null) { codexProvider = v; } }, text);
+    processSessionText(accum, {
+      get codexProvider() { return codexProvider; },
+      set codexProvider(v: string | null) { codexProvider = v; },
+      get codexModel() { return codexModel; },
+      set codexModel(v: string | null) { codexModel = v; },
+    }, text, hostOfSessionFile(file));
   }
   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, 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: string): string {
+  const norm = file.replace(/\\/g, '/');
+  if (norm.includes('/.omp/')) return 'omp';
+  if (norm.includes('/.codex/')) return 'codex';
+  return 'pi';
+}
+
 const adoptionFileCache = new Map<string, { size: number; mtimeMs: number; counts: { bashCalls: number; eligibleCalls: number; rtkCalls: number } }>();
 
 function parseAdoptionFile(file: string): { counts: { bashCalls: number; eligibleCalls: number; rtkCalls: number }; sessions: number } {
@@ -369,7 +473,7 @@ export function clearRtkAdoptionCache(): void {
 
 export function readRtkAdoption(): RtkAdoption {
   const files: string[] = [];
-  walkJsonl(sessionsDir(), files, 2000);
+  for (const dir of sessionsDirs()) walkJsonl(dir, files, 2000);
   if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_CODEX_DIR !== undefined) {
     walkJsonl(codexSessionsDir(), files, 2000);
   }
@@ -404,7 +508,7 @@ export function readRtkAdoption(): RtkAdoption {
   const missedCalls = Math.max(0, eligibleCalls - rtkCalls);
   return { sessions, bashCalls, eligibleCalls, rtkCalls, missedCalls, adoptionPct: eligibleCalls ? (rtkCalls / eligibleCalls) * 100 : 0 };
 }
-export function processSessionText(accum: SessionAccum, state: { codexProvider: string | null }, text: string): void {
+export function processSessionText(accum: SessionAccum, state: { codexProvider: string | null; codexModel?: string | null }, text: string, host?: string): void {
   for (const line of text.split('\n')) {
     if (!line.trim()) continue;
     try {
@@ -414,13 +518,19 @@ export function processSessionText(accum: SessionAccum, state: { codexProvider:
         if (parsed.provider) state.codexProvider = parsed.provider;
         continue;
       }
+      if (parsed.kind === 'codex_model') {
+        if (parsed.model) state.codexModel = parsed.model;
+        continue;
+      }
       if (parsed.kind === 'token_row') {
-        const model = parsed.provider ? `codex/${parsed.provider}` : (state.codexProvider ? `codex/${state.codexProvider}` : 'codex');
-        ingestSessionRow(accum, model, parsed.usage ?? {}, row.timestamp, undefined, { st: 'completed' as RunStatus });
+        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' as RunStatus }, undefined, host ?? 'codex');
         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);
+      ingestSessionRow(accum, parsed.model, parsed.usage, row.timestamp, parsed.durMs, parsed.run, parsed.tools, host);
     } catch { /* skip corrupt lines */ }
   }
 }
@@ -443,8 +553,8 @@ export function readRtkRecallDiagnostics(binary: string | null = resolveRtkBinar
     return { mode: 'unknown', entries: 0, available: false };
   }
 }
-// Lead binary of a shell string: first segment head past `cd` chains and
-// VAR=x assignments (`cd /x && git status` → `git`). Falls back to `bash`.
+// Lead binary of a shell string: first segment past `cd` chains and VAR=x
+// assignments. Falls back to `bash`.
 const SKIP_HEADS = ['cd', 'echo', 'export', 'true', 'false'];
 export function leadBinary(command: unknown): string {
   if (typeof command !== 'string' || !command.trim()) return 'bash';
@@ -459,7 +569,7 @@ export function leadBinary(command: unknown): string {
 }
 
 // --- Pricing lives in ./pricing.ts (live LiteLLM cache + fallback table) ---
-import { DEFAULT_PRICE, priceFor, refreshPricesIfStale } from './pricing.ts';
+import { DEFAULT_PRICE, canonicalPriceId, priceFor, refreshPricesIfStale } from './pricing.ts';
 import { co2GramsFor, energyWhFor } from './carbon.ts';
 import type { ModelPrice } from './pricing.ts';
 
@@ -483,12 +593,6 @@ export function usdCost(t: TokenBreakdown, model?: string): { usd: number; price
   };
 }
 
-// CO2 now model-differentiated via ./carbon.ts (EcoLogits 0.8.2 port).
-// Always render with ~est. and never merge with measured figures.
-// The constant below is the served gCO2eq per 1K output tokens for the
-// default (gpt-4o-class) model, kept so single-figure callers stay honest.
-export const CO2_G_PER_1K_OUTPUT = 0.2;
-
 export function co2Grams(outputTokens: number, model?: string): number {
   return co2GramsFor(model ?? 'gpt-4o', outputTokens);
 }
@@ -513,9 +617,8 @@ export function readUsage(): UsageRow[] {
   return rows;
 }
 
-// Delete the ledger file. Returns the rows cleared (0 when already absent).
-// Only tersio-owned data lives here; session transcripts and the RTK
-// database are never touched.
+// Delete the ledger file and return the rows cleared. Tersio-owned data only:
+// transcripts and the RTK database are never touched.
 export function clearUsageLedger(): number {
   const rows = readUsage().length;
   try {