mixdog 0.9.166 → 0.9.167

package/src/standalone/daemon-telemetry.mjs

@@ -0,0 +1,175 @@
+// Periodic daemon memory + in-flight work telemetry.
+//
+// Owns the single unref'd 30s diagnostics loop (event-loop lag rides
+// onInterval on the same tick) so a crash still has a recent
+// RSS/heap/limit/work record in daemon.log. The V8 heap limit is
+// process-specific (heap_size_limit) and is never inferred from host
+// free RAM. Lines contain only counters — no session bodies, tokens,
+// or env. Retention is the daemon log's existing rotate-and-keep bound.
+
+import v8 from 'node:v8';
+
+export const DAEMON_TELEMETRY_INTERVAL_MS = 30_000;
+
+const WORK_KEYS = Object.freeze([
+  'activeCalls',
+  'queuedCalls',
+  'busySessions',
+  'busyMemoryAgents',
+]);
+const REASONS = new Set(['boot', 'periodic']);
+
+function nonNegativeInt(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n >= 0 ? Math.round(n) : 0;
+}
+
+function byteCount(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n >= 0 ? Math.round(n) : -1;
+}
+
+function timestamp(now) {
+  try {
+    const value = typeof now === 'function' ? now() : now;
+    if (value instanceof Date) return value.toISOString();
+    if (typeof value === 'number' && Number.isFinite(value)) return new Date(value).toISOString();
+    if (typeof value === 'string' && value) {
+      const parsed = new Date(value);
+      if (!Number.isNaN(parsed.getTime())) return parsed.toISOString();
+    }
+  } catch { /* fall through */ }
+  return new Date().toISOString();
+}
+
+function processId(pid) {
+  const n = Number(pid);
+  return Number.isInteger(n) ? n : process.pid;
+}
+
+function workCounts(work) {
+  const source = work && typeof work === 'object' ? work : {};
+  const counts = {};
+  for (const key of WORK_KEYS) counts[key] = nonNegativeInt(source[key]);
+  return counts;
+}
+
+function readMemory(memoryUsage) {
+  try {
+    return memoryUsage?.() || {};
+  } catch {
+    return {};
+  }
+}
+
+function readHeapLimit(heapStatistics) {
+  try {
+    return byteCount(heapStatistics?.()?.heap_size_limit);
+  } catch {
+    return -1;
+  }
+}
+
+function reasonToken(reason) {
+  const text = String(reason ?? '').toLowerCase();
+  return REASONS.has(text) ? text : 'periodic';
+}
+
+export function collectDaemonTelemetry({
+  now = () => new Date(),
+  pid = process.pid,
+  memoryUsage = () => process.memoryUsage(),
+  heapStatistics = () => v8.getHeapStatistics(),
+  work = {},
+} = {}) {
+  const usage = readMemory(memoryUsage);
+  return {
+    ts: timestamp(now),
+    pid: processId(pid),
+    rssBytes: byteCount(usage.rss),
+    heapUsedBytes: byteCount(usage.heapUsed),
+    heapTotalBytes: byteCount(usage.heapTotal),
+    heapLimitBytes: readHeapLimit(heapStatistics),
+    externalBytes: byteCount(usage.external),
+    arrayBufferBytes: byteCount(usage.arrayBuffers),
+    ...workCounts(work),
+  };
+}
+
+export function formatDaemonTelemetry(record, reason = 'periodic') {
+  const row = record && typeof record === 'object' ? record : collectDaemonTelemetry();
+  return [
+    'daemon-telemetry',
+    `reason=${reasonToken(reason)}`,
+    `ts=${row.ts}`,
+    `pid=${row.pid}`,
+    `rssBytes=${row.rssBytes}`,
+    `heapUsedBytes=${row.heapUsedBytes}`,
+    `heapTotalBytes=${row.heapTotalBytes}`,
+    `heapLimitBytes=${row.heapLimitBytes}`,
+    `externalBytes=${row.externalBytes}`,
+    `arrayBufferBytes=${row.arrayBufferBytes}`,
+    `activeCalls=${row.activeCalls}`,
+    `queuedCalls=${row.queuedCalls}`,
+    `busySessions=${row.busySessions}`,
+    `busyMemoryAgents=${row.busyMemoryAgents}`,
+  ].join(' ');
+}
+
+export function createDaemonTelemetry({
+  log = () => {},
+  getWork = () => ({}),
+  onInterval = null,
+  now,
+  pid,
+  memoryUsage,
+  heapStatistics,
+  setIntervalFn = setInterval,
+  clearIntervalFn = clearInterval,
+} = {}) {
+  let timer = null;
+
+  function emit(reason = 'periodic') {
+    try {
+      let work = {};
+      try { work = getWork(); } catch { work = {}; }
+      const record = collectDaemonTelemetry({
+        now,
+        pid,
+        memoryUsage,
+        heapStatistics,
+        work,
+      });
+      log(formatDaemonTelemetry(record, reason));
+      return record;
+    } catch {
+      return null;
+    }
+  }
+
+  function tick() {
+    emit('periodic');
+    try { onInterval?.(); } catch { /* lag probes must not kill the sample loop */ }
+  }
+
+  function start(intervalMs = DAEMON_TELEMETRY_INTERVAL_MS) {
+    if (timer) return timer;
+    const delay = Number(intervalMs);
+    const ms = Number.isFinite(delay) && delay > 0 ? delay : DAEMON_TELEMETRY_INTERVAL_MS;
+    const handle = setIntervalFn(() => {
+      if (timer !== handle) return;
+      tick();
+    }, ms);
+    handle?.unref?.();
+    timer = handle;
+    return timer;
+  }
+
+  function stop() {
+    if (!timer) return;
+    clearIntervalFn(timer);
+    timer = null;
+  }
+
+  return { emit, start, stop };
+}

package/src/standalone/daemon.mjs

@@ -66,6 +66,7 @@ import { getStandaloneMemoryRuntime } from './memory-runtime-proxy.mjs';
 import { createBootPhaseProfiler } from './boot-phase-profiler.mjs';
 import { createDaemonBootCoordinator } from './daemon-boot-coordinator.mjs';
 import { createDaemonLog } from './daemon-log.mjs';
+import { createDaemonTelemetry } from './daemon-telemetry.mjs';
 import {
   compareRuntimeVersions,
   SESSION_CAPABILITY_FINGERPRINT,
@@ -113,8 +114,8 @@ let shutdownRecheckTimer = null;
 let replacementRequested = null;
 const eventLoopDelay = monitorEventLoopDelay({ resolution: 20 });
 eventLoopDelay.enable();
-let eventLoopLagTimer = null;
 let idleGc = null;
+let daemonTelemetry = null;
 
 function registerMemoryRuntimeLazy() {
   // Register the shared proxy immediately so daemon shutdown owns its
@@ -181,7 +182,7 @@ async function shutdown(reason, code = 0) {
   try { await closeProviderStreamJsonPool(reason); } catch (e) { log(`stream parser stop failed: ${e?.message || e}`); }
   try { await transport?.stop?.(); } catch (e) { log(`transport.stop failed: ${e?.message || e}`); }
   idleGc?.disarm();
-  if (eventLoopLagTimer) { clearInterval(eventLoopLagTimer); eventLoopLagTimer = null; }
+  daemonTelemetry?.stop();
   eventLoopDelay.disable();
   for (const discoveryPath of [DAEMON_DISCOVERY_PATH]) {
     try { rmSync(discoveryPath, { force: true }); } catch {}
@@ -202,6 +203,29 @@ function inFlightWork() {
   };
 }
 
+daemonTelemetry = createDaemonTelemetry({
+  log,
+  getWork: inFlightWork,
+  onInterval() {
+    const status = eventLoopStatus();
+    if (status.eventLoopP99Ms >= 250) {
+      log(`event-loop lag p95=${status.eventLoopP95Ms}ms p99=${status.eventLoopP99Ms}ms max=${status.eventLoopMaxMs}ms`);
+    }
+    // Legacy external runtime hosts may still report shard-local lag. The
+    // production in-process host is already covered by daemon loop telemetry.
+    const shards = sessionRuntimeHost?.status?.shards || [];
+    const lagging = shards.filter((shard) => Number(shard?.lag?.p99Ms) >= 250 || shard?.degraded);
+    if (lagging.length > 0) {
+      log(`session runtime shard lag ${lagging.map((shard) => (
+        `#${shard.index}${shard.degraded ? '(quarantined)' : ''}`
+        + ` p95=${shard.lag?.p95Ms ?? -1}ms p99=${shard.lag?.p99Ms ?? -1}ms`
+        + ` max=${shard.lag?.maxMs ?? -1}ms runtimes=${shard.runtimes}`
+      )).join(' ')}`);
+    }
+    eventLoopDelay.reset();
+  },
+});
+
 function daemonHasWorkInFlight() {
   const work = inFlightWork();
   return work.activeCalls > 0 || work.queuedCalls > 0
@@ -711,25 +735,11 @@ async function main() {
   }
   log(`ready port=${port} pid=${process.pid} in ${(performance.now() - startedAt).toFixed(0)}ms`);
   bootPhases.mark('daemon-ready');
-  eventLoopLagTimer = setInterval(() => {
-    const status = eventLoopStatus();
-    if (status.eventLoopP99Ms >= 250) {
-      log(`event-loop lag p95=${status.eventLoopP95Ms}ms p99=${status.eventLoopP99Ms}ms max=${status.eventLoopMaxMs}ms`);
-    }
-    // Legacy external runtime hosts may still report shard-local lag. The
-    // production in-process host is already covered by daemon loop telemetry.
-    const shards = sessionRuntimeHost?.status?.shards || [];
-    const lagging = shards.filter((shard) => Number(shard?.lag?.p99Ms) >= 250 || shard?.degraded);
-    if (lagging.length > 0) {
-      log(`session runtime shard lag ${lagging.map((shard) => (
-        `#${shard.index}${shard.degraded ? '(quarantined)' : ''}`
-        + ` p95=${shard.lag?.p95Ms ?? -1}ms p99=${shard.lag?.p99Ms ?? -1}ms`
-        + ` max=${shard.lag?.maxMs ?? -1}ms runtimes=${shard.runtimes}`
-      )).join(' ')}`);
-    }
-    eventLoopDelay.reset();
-  }, 30_000);
-  eventLoopLagTimer.unref?.();
+  // One unref'd 30s loop: memory/work samples plus event-loop lag. A crash
+  // still has a recent RSS/heap/limit record in daemon.log; the 10-minute
+  // memory-pressure file is too sparse to be that record.
+  daemonTelemetry.emit('boot');
+  daemonTelemetry.start();
 
   // Automation may spawn the shared daemon; keep schedules/webhooks live.
   // A TUI-spawned daemon keeps the historical eager start (its channels client

package/src/standalone/session-client.mjs

@@ -2,7 +2,6 @@
 // createSession remains the stable public facade; its projection lives in
 // session-proxy.mjs.
 import http from 'node:http';
-import os from 'node:os';
 import path from 'node:path';
 import { fork } from 'node:child_process';
 import { readFileSync } from 'node:fs';
@@ -20,6 +19,7 @@ import { readSingletonOwner } from '../runtime/shared/singleton-owner.mjs';
 import { isPidAlive } from '../runtime/shared/pid-liveness.mjs';
 import { resolveRuntimeRoot } from '../runtime/shared/runtime-root.mjs';
 import { withHeapCap } from '../runtime/shared/heap-cap.mjs';
+import { beginDaemonSpawnCapture, daemonDataDir } from './daemon-crash-capture.mjs';
 import { createSessionProxyFactory } from './session-proxy.mjs';
 
 function runtimeRoot() {
@@ -31,10 +31,7 @@ export function sessionDiscoveryPath() {
 }
 
 function daemonOwnerPath() {
-  const dataDir = process.env.MIXDOG_DATA_DIR
-    ? path.resolve(process.env.MIXDOG_DATA_DIR)
-    : path.join(process.env.MIXDOG_HOME || path.join(os.homedir(), '.mixdog'), 'data');
-  return path.join(dataDir, 'daemon-owner.json');
+  return path.join(daemonDataDir(), 'daemon-owner.json');
 }
 
 function daemonEntry() {
@@ -238,29 +235,40 @@ async function replaceLowerDaemon(discovery, initialHealth, { log }) {
 
 /** Fork one daemon candidate DETACHED (it outlives this client — machine
  *  global) and resolve when it reports ready OR exits (race loss/crash); the
- *  caller then re-reads discovery and attaches to whoever won. */
-function spawnDaemonCandidate({ cwd, log, timeoutMs = 30_000 }) {
+ *  caller then re-reads discovery and attaches to whoever won.
+ *
+ *  fd 2 is a capture FILE, not a pipe: a V8 fatal abort (heap OOM) is written
+ *  by the runtime below every JS hook, and a pipe dies with this launcher.
+ *  The exit listener outlives the ready handoff so the daemon's code/signal is
+ *  recorded against its pid, boot time and ready state instead of discarded.
+ *  `entry` is a test seam; production always forks the real daemon. */
+export function spawnDaemonCandidate({ cwd, log, timeoutMs = 30_000, entry = daemonEntry() }) {
   return new Promise((resolve) => {
     const t0 = performance.now();
     const at = () => Math.round(performance.now() - t0);
     let settled = false;
     let timer = null;
+    const capture = beginDaemonSpawnCapture({ launcher: 'session-client', log });
     const done = () => {
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
+      // Boot diagnostics written to fd 2 reach this log exactly once, even when
+      // the candidate never reached ready.
+      capture.mirror();
       resolve();
     };
+    const detached = daemonShouldDetach();
+    // Inherit this launcher's flags (fork's default). withHeapCap('daemon')
+    // adds --max-old-space-size only when MIXDOG_DAEMON_HEAP_MB is set.
+    const execArgv = withHeapCap('daemon', process.execArgv);
     let child;
     try {
-      child = fork(daemonEntry(), [], {
+      child = fork(entry, [], {
         cwd,
-        // Inherit this launcher's flags (fork's default) and add the daemon's
-        // old-space cap on top: uncapped, a long-lived daemon stays resident
-        // far above its live set.
-        execArgv: withHeapCap('daemon', process.execArgv),
-        stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
-        detached: daemonShouldDetach(),
+        execArgv,
+        stdio: ['ignore', 'ignore', capture.stderrStdio, 'ipc'],
+        detached,
         windowsHide: true,
         env: {
           ...process.env,
@@ -274,30 +282,30 @@ function spawnDaemonCandidate({ cwd, log, timeoutMs = 30_000 }) {
         },
       });
     } catch (err) {
+      capture.noteSpawnError(err);
       log(`daemon spawn failed: ${err?.message || err}`);
       done();
       return;
     }
     const forkMs = at();
+    capture.track(child, { detached, execArgv });
     child.once('spawn', () => { log(`daemon fork: forkMs=${forkMs} spawnEventMs=${at()}`); });
-    let firstStderrMs = -1;
-    const mirror = (chunk) => {
-      if (firstStderrMs < 0) { firstStderrMs = at(); log(`daemon first stderr at=${firstStderrMs}ms`); }
-      const text = String(chunk || '').trimEnd();
-      if (text) log(text);
-    };
-    child.stderr?.on('data', mirror);
     child.once('message', (msg) => {
       if (msg?.type !== 'ready') return;
+      capture.noteReady();
       log(`daemon ready at=${at()}ms`);
-      try { child.stderr?.off?.('data', mirror); } catch {}
       try { child.disconnect?.(); } catch {}
       try { child.unref?.(); } catch {}
       try { child.stderr?.unref?.(); } catch {}
       done();
     });
     child.once('exit', done);
-    child.once('error', (err) => { log(`daemon spawn error: ${err?.message || err}`); done(); });
+    child.once('error', (err) => {
+      // An async spawn failure may never emit 'exit'; the sidecar still gets it.
+      capture.noteSpawnError(err);
+      log(`daemon spawn error: ${err?.message || err}`);
+      done();
+    });
     timer = setTimeout(done, Math.max(1, timeoutMs));
     timer.unref?.();
   });

package/src/standalone/usage-dashboard-model.mjs

@@ -171,6 +171,7 @@ function providerDescription(id, group) {
     case 'openai-oauth': return 'OpenAI OAuth subscription quota';
     case 'anthropic-oauth': return 'Anthropic OAuth subscription quota';
     case 'grok-oauth': return 'Grok Build subscription quota';
+    case 'antigravity-oauth': return 'Antigravity subscription quota';
     case 'opencode-go': return 'OpenCode Go subscription quota';
     case 'openai': return 'OpenAI API billing';
     case 'anthropic': return 'Anthropic API billing';
@@ -263,6 +264,7 @@ function providerRank(row) {
     'anthropic-oauth': 20,
     'grok-oauth': 30,
     'cursor-oauth': 35,
+    'antigravity-oauth': 36,
     'opencode-go': 40,
     openai: 50,
     anthropic: 60,

package/src/standalone/usage-stats-hours.mjs

@@ -6,38 +6,45 @@ const amount = (value) => Number.isFinite(Number(value)) && Number(value) > 0 ?
 /** Only retained timestamps establish an hour. Legacy day totals stay unallocated. */
 export function hourlySeries(records, period, conversationOnly = false) {
   const make = (key, label, future = false) => ({
-    key, label, future, turns: 0, tokens: 0, costUsd: 0, unmeasuredTurns: 0, providers: new Map(),
+    key, label, future, turns: 0, tokens: 0, costUsd: 0, costKnownTurns: 0, unmeasuredTurns: 0, providers: new Map(),
   });
   const buckets = [];
-  // Real elapsed hours also handle 23/25-hour daylight-saving days.
-  for (let ts = period.fromMs; ts <= period.endMs; ts += HOUR_MS) {
-    const label = `${String(new Date(ts).getHours()).padStart(2, '0')}:00`;
-    buckets.push(make(String(ts), label, ts > period.toMs));
+  // Rolling windows always contain 24 elapsed hours, even across DST changes.
+  for (let ts = period.fromMs; ts < period.endMs; ts += HOUR_MS) {
+    const date = new Date(ts);
+    const label = `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
+    buckets.push({ ...make(String(ts), label, ts > period.toMs),
+      fromMs: ts, toMs: Math.min(ts + HOUR_MS, period.toMs) });
   }
-  const add = (bucket, provider, turns, tokens, costUsd, unmeasuredTurns = 0) => {
+  const add = (bucket, provider, turns, tokens, costUsd, unmeasuredTurns = 0, costKnownTurns = 0) => {
     bucket.turns += turns;
     bucket.tokens += tokens;
     bucket.costUsd += costUsd;
+    bucket.costKnownTurns += costKnownTurns;
     bucket.unmeasuredTurns += unmeasuredTurns;
-    const slice = bucket.providers.get(provider) || { provider, turns: 0, tokens: 0, costUsd: 0, unmeasuredTurns: 0 };
+    const slice = bucket.providers.get(provider) || { provider, turns: 0, tokens: 0, costUsd: 0, costKnownTurns: 0, unmeasuredTurns: 0 };
     slice.turns += turns;
     slice.tokens += tokens;
     slice.costUsd += costUsd;
+    slice.costKnownTurns += costKnownTurns;
     slice.unmeasuredTurns += unmeasuredTurns;
     bucket.providers.set(provider, slice);
   };
   for (const row of records?.rows || []) {
     if (row.ts < period.fromMs || row.ts > period.toMs) continue;
     if (conversationOnly && !isConversationUsageSource(row.source_type)) continue;
-    const bucket = buckets[Math.floor((row.ts - period.fromMs) / HOUR_MS)];
-    if (bucket) add(bucket, row.provider, 1, amount(row.input) + amount(row.output), amount(row.cost_usd),
-      amount(row.unmeasuredTurns));
+    const bucket = buckets[Math.min(buckets.length - 1, Math.floor((row.ts - period.fromMs) / HOUR_MS))];
+    if (bucket) add(bucket, row.provider, 1,
+      amount(row.input) + amount(row.output) + amount(row.cache_read) + amount(row.cache_write), amount(row.cost_usd),
+      amount(row.unmeasuredTurns), row.cost_usd != null && !row.unmeasuredTurns ? 1 : 0);
   }
   const unknown = { ...make('unknown-time', ''), unknown: true };
   for (const route of records?.unallocated || []) {
     const usage = conversationOnly ? route.conversation : route;
     if (usage) add(unknown, route.provider, amount(usage.turns),
-      amount(usage.input) + amount(usage.output), amount(usage.costUsd), amount(usage.unmeasuredTurns));
+      amount(usage.input) + amount(usage.output) + amount(usage.cacheRead) + amount(usage.cacheWrite),
+      amount(usage.costUsd), amount(usage.unmeasuredTurns),
+      usage.costKnownTurns == null ? (amount(usage.costUsd) > 0 ? amount(usage.turns) : 0) : amount(usage.costKnownTurns));
   }
   if (unknown.turns || unknown.tokens || unknown.costUsd) buckets.push(unknown);
   return buckets.map((bucket) => ({

package/src/standalone/usage-stats-model.mjs

@@ -151,6 +151,8 @@ function addUsage(target, usage) {
   target.cacheWrite += usage.cacheWrite;
   target.costUsd += usage.costUsd;
   target.costKnownTurns = (target.costKnownTurns || 0) + (usage.costKnownTurns || 0);
+  target.costBilled = (target.costBilled || 0) + (usage.costBilled || 0);
+  target.costEstimated = (target.costEstimated || 0) + (usage.costEstimated || 0);
   target.unmeasuredTurns = (target.unmeasuredTurns || 0) + (usage.unmeasuredTurns || 0);
 }
 
@@ -170,6 +172,9 @@ function foldRoute(state, providerId, modelId, kind, usage) {
   state.cacheRead += usage.cacheRead;
   state.cacheWrite += usage.cacheWrite;
   state.costUsd += usage.costUsd;
+  state.costKnownTurns += usage.costKnownTurns || 0;
+  state.costBilled += usage.costBilled || 0;
+  state.costEstimated += usage.costEstimated || 0;
   state.unmeasuredTurns += usage.unmeasuredTurns || 0;
 }
 
@@ -216,9 +221,6 @@ function foldRollupDay(state, key, day, conversationOnly) {
   if (day?.restored === true) state.historyDays += 1;
   if (day?.importedPartial === true) state.partialDays += 1;
   if (conversationOnly && day?.conversationPartial === true) state.partialDays += 1;
-  state.costKnownTurns += num(totals.costKnownTurns);
-  state.costBilled += num(totals.costBilled);
-  state.costEstimated += num(totals.costEstimated);
   state.durationMs += num(totals.durationMs);
   state.durationTurns += num(totals.durationTurns);
   state.sessionsDropped += num(day?.sessionsDropped);
@@ -241,6 +243,9 @@ function foldRollupDay(state, key, day, conversationOnly) {
       costUsd: num(route.costUsd),
       costKnownTurns: route.costKnownTurns == null
         ? (num(route.costUsd) > 0 ? num(route.turns) : 0) : num(route.costKnownTurns),
+      costBilled: num(route.costBilled),
+      costEstimated: route.costEstimated == null
+        ? Math.max(0, num(route.costUsd) - num(route.costBilled)) : num(route.costEstimated),
       sessions: route.sessions,
       sessionsComplete: route.sessionsComplete,
       unmeasuredTurns: num(route.unmeasuredTurns),
@@ -277,6 +282,9 @@ function foldEvent(state, key, event, conversationOnly) {
   const cacheRead = num(event?.cacheReadTokens);
   const cacheWrite = num(event?.cacheWriteTokens);
   const sessionId = conversation ? text(event?.sessionId) : '';
+  const costSource = text(event?.costSource);
+  const priced = event?.costUsd != null && Number.isFinite(Number(event.costUsd))
+    && !['', 'none', 'unpriced'].includes(costSource);
   const usage = {
     turns: 1,
     // Same normalization the rollup applies: a provider that reports the whole
@@ -286,19 +294,15 @@ function foldEvent(state, key, event, conversationOnly) {
     cacheRead,
     cacheWrite,
     costUsd: num(event?.costUsd),
-    costKnownTurns: event?.costSource && event.costSource !== 'none' ? 1 : 0,
+    costKnownTurns: priced ? 1 : 0,
+    costBilled: priced && costSource === 'provider' ? num(event.costUsd) : 0,
+    costEstimated: priced && costSource !== 'provider' ? num(event.costUsd) : 0,
     sessions: sessionId ? { [sessionId]: 1 } : {},
     sessionsComplete: !conversation || Boolean(sessionId),
   };
   foldRoute(state, providerId, modelId, text(event?.providerKind), usage);
   addDaily(state, key, usage, providerId);
 
-  const costSource = text(event?.costSource);
-  if (costSource && costSource !== 'none') {
-    state.costKnownTurns += 1;
-    if (costSource === 'provider') state.costBilled += usage.costUsd;
-    else state.costEstimated += usage.costUsd;
-  }
   const durationMs = num(event?.durationMs);
   if (durationMs > 0) {
     state.durationMs += durationMs;
@@ -417,15 +421,17 @@ function median(values) {
     : sorted[middle];
 }
 
-// Cache reads outweigh everything else by two orders of magnitude on a long
-// session, so "tokens" counts what a turn actually read fresh or produced.
-// Cache is reported beside that figure instead of swallowing it.
+// "tokens" is everything a turn moved: fresh input, output, and the cached
+// prompt it read or wrote. Cached providers re-read the whole context every
+// turn, so counting only the fresh part made a cached route look idle beside
+// an uncached one doing the same work. The split stays in input/output/cache.
 function tokensOf(bucket) {
-  return bucket.input + bucket.output;
+  return bucket.input + bucket.output + bucket.cacheRead + bucket.cacheWrite;
 }
 
 function exportRoute(bucket, totalTokens) {
   const tokens = tokensOf(bucket);
+  const fresh = bucket.input + bucket.output;
   const prompt = bucket.input + bucket.cacheRead + bucket.cacheWrite;
   const unmeasuredTurns = num(bucket.unmeasuredTurns);
   const unknown = unmeasuredTurns > 0 && unmeasuredTurns === bucket.turns;
@@ -443,17 +449,20 @@ function exportRoute(bucket, totalTokens) {
     tokens,
     unmeasuredTurns,
     costUsd: round(bucket.costUsd, 6),
+    costBilled: round(num(bucket.costBilled), 6),
+    costEstimated: round(num(bucket.costEstimated), 6),
+    costKnownTurns: num(bucket.costKnownTurns),
+    costUnpricedTurns: Math.max(0, bucket.turns - num(bucket.costKnownTurns)),
     costCoverage: bucket.turns > 0 ? num(bucket.costKnownTurns) / bucket.turns : 0,
     share: unmeasuredTurns > 0 ? null : totalTokens > 0 ? round(tokens / totalTokens, 6) : 0,
     // How much of this route's prompt arrived from cache instead of being read
     // again. Cache writes are misses, so belong in the denominator, not the
     // numerator.
     cacheHitRate: unmeasuredTurns > 0 ? null : prompt > 0 ? round(bucket.cacheRead / prompt, 4) : 0,
-    // What a million tokens actually cost on this route. Cache is excluded from
-    // the divisor for the same reason it is excluded from the token figure —
-    // including it would divide real spend by a number two orders of magnitude
-    // larger and rank every route as free.
-    costPerMTokens: tokens > 0 ? round(bucket.costUsd / (tokens / 1_000_000), 4) : 0,
+    // What a million fresh tokens actually cost on this route. Cache is excluded
+    // from the divisor: including it would divide real spend by a number two
+    // orders of magnitude larger and rank every route as free.
+    costPerMTokens: fresh > 0 ? round(bucket.costUsd / (fresh / 1_000_000), 4) : 0,
     // Answer length, which is what separates a terse route from a verbose one
     // at the same price.
     outputPerTurn: bucket.turns > 0 ? Math.round(bucket.output / bucket.turns) : 0,
@@ -492,8 +501,8 @@ export function usageStatsSnapshot({
   const eventList = Array.isArray(events) ? events : [];
   const state = collect({ events: eventList, rollupDays, historyDays, window, conversationOnly });
 
-  const totalTokens = state.input + state.output;
   const cacheTokens = state.cacheRead + state.cacheWrite;
+  const totalTokens = state.input + state.output + cacheTokens;
   const sessionTotals = [...state.sessions.values(), ...state.anonymousSessions];
   const dayKeys = [...state.dayKeys].sort();
   const firstDay = dayKeys[0] || '';
@@ -531,22 +540,24 @@ export function usageStatsSnapshot({
     const bucket = state.daily.get(day);
     const future = period ? { future: day > endDay } : {};
     if (!bucket) {
-      return { day, turns: 0, tokens: 0, cacheTokens: 0, costUsd: 0, providers: [], ...future };
+      return { day, turns: 0, tokens: 0, cacheTokens: 0, costUsd: 0, costKnownTurns: 0, providers: [], ...future };
     }
     return {
       day: bucket.day,
       turns: bucket.turns,
-      tokens: bucket.input + bucket.output,
+      tokens: tokensOf(bucket),
       cacheTokens: bucket.cacheRead + bucket.cacheWrite,
       costUsd: round(bucket.costUsd, 6),
+      costKnownTurns: num(bucket.costKnownTurns),
       unmeasuredTurns: num(bucket.unmeasuredTurns),
       ...future,
       providers: [...bucket.providers.values()]
         .map((slice) => ({
           provider: slice.provider,
           turns: slice.turns,
-          tokens: slice.input + slice.output,
+          tokens: tokensOf(slice),
           costUsd: round(slice.costUsd, 6),
+          costKnownTurns: num(slice.costKnownTurns),
           unmeasuredTurns: num(slice.unmeasuredTurns),
         }))
         .sort((a, b) => b.tokens - a.tokens),
@@ -584,21 +595,21 @@ export function usageStatsSnapshot({
       cacheRead: state.cacheRead,
       cacheWrite: state.cacheWrite,
       cacheTokens,
-      // Everything that moved, cache included — the figure to quote when the
-      // question is how much data flowed rather than what it cost.
-      totalTokens: totalTokens + cacheTokens,
+      totalTokens,
       // How much of the prompt arrived from cache instead of being read again.
       cacheHitRate: state.unmeasuredTurns > 0 ? null : state.input + state.cacheRead + state.cacheWrite > 0
         ? round(state.cacheRead / (state.input + state.cacheRead + state.cacheWrite), 4)
         : 0,
       costUsd: round(state.costUsd, 6),
+      costKnownTurns: state.costKnownTurns,
+      costUnpricedTurns: Math.max(0, state.turns - state.costKnownTurns),
       // Priced by the provider vs derived from the catalog. A subscription turn
       // lands in the second: real spend, but never an invoice line.
       costBilled: round(state.costBilled, 6),
       costEstimated: round(state.costEstimated, 6),
       costPerDay: effectiveDays > 0 ? round(state.costUsd / effectiveDays, 6) : 0,
       tokensPerSession: sessionTotals.length
-        ? Math.round((totalTokens + cacheTokens) / sessionTotals.length)
+        ? Math.round(totalTokens / sessionTotals.length)
         : 0,
       medianTokensPerSession: Math.round(median(sessionTotals)),
       avgDurationMs: state.durationTurns > 0
@@ -610,7 +621,7 @@ export function usageStatsSnapshot({
     previous: prior
       ? {
         turns: prior.turns,
-        tokens: prior.input + prior.output,
+        tokens: tokensOf(prior),
         costUsd: round(prior.costUsd, 6),
       }
       : null,