syndes 0.1.0

package/analytics/metrics/context.mjs

@@ -0,0 +1,95 @@
+/**
+ * Compaction, session starts, and the tokens burned before each compact.
+ *
+ * The pillar with the largest single effect on both cost and output quality. An
+ * automatic compact means the context ran out; a manual one means the user chose
+ * the moment. Only the first is a problem, which is why `trigger` is recorded.
+ */
+
+import { KIND } from '../../ledger/schema.mjs';
+
+export const name = 'context';
+
+export function create() {
+  return {
+    autoCompacts: 0, manualCompacts: 0,
+    fresh: 0, resumed: 0, cleared: 0,
+    tokensBeforeCompact: [], sinceCompact: new Map(),
+    sessionsWithCompact: new Set(), sessionEnds: 0,
+  };
+}
+
+export function add(state, record) {
+  const session = record.session ?? 'unknown';
+
+  if (record.kind === KIND.USAGE) {
+    const data = record.data;
+    const readable = (data.input ?? 0) + (data.cacheRead ?? 0) + (data.cacheWrite ?? 0);
+    // The last turn before a compact is the high-water mark of the window.
+    state.sinceCompact.set(session, Math.max(state.sinceCompact.get(session) ?? 0, readable));
+    return;
+  }
+
+  if (record.kind === KIND.COMPACT) {
+    if (record.data.trigger === 'manual') state.manualCompacts += 1;
+    else state.autoCompacts += 1;
+    state.sessionsWithCompact.add(session);
+
+    const peak = state.sinceCompact.get(session);
+    if (peak) state.tokensBeforeCompact.push(peak);
+    state.sinceCompact.set(session, 0);
+    return;
+  }
+
+  if (record.kind === KIND.SESSION_START) {
+    const source = record.data.source;
+    if (source === 'resume' || source === 'compact') state.resumed += 1;
+    else if (source === 'clear') state.cleared += 1;
+    else state.fresh += 1;
+    return;
+  }
+
+  if (record.kind === KIND.SESSION_END) state.sessionEnds += 1;
+}
+
+export function done(state) {
+  return {
+    autoCompacts: state.autoCompacts,
+    manualCompacts: state.manualCompacts,
+    fresh: state.fresh,
+    resumed: state.resumed,
+    cleared: state.cleared,
+    sessionEnds: state.sessionEnds,
+    sessionsWithCompact: [...state.sessionsWithCompact],
+    tokensBeforeCompact: state.tokensBeforeCompact.slice(0, 200),
+    peakWindow: Math.max(0, ...state.sinceCompact.values()),
+  };
+}
+
+export function merge(parts) {
+  const out = {
+    autoCompacts: 0, manualCompacts: 0, fresh: 0, resumed: 0, cleared: 0,
+    sessionEnds: 0, peakWindow: 0,
+  };
+  const compacted = new Set();
+  const peaks = [];
+
+  for (const part of parts) {
+    for (const key of ['autoCompacts', 'manualCompacts', 'fresh', 'resumed', 'cleared', 'sessionEnds']) {
+      out[key] += part[key] ?? 0;
+    }
+    out.peakWindow = Math.max(out.peakWindow, part.peakWindow ?? 0);
+    for (const id of part.sessionsWithCompact ?? []) compacted.add(id);
+    peaks.push(...(part.tokensBeforeCompact ?? []));
+  }
+
+  const starts = out.fresh + out.resumed + out.cleared;
+  return {
+    ...out,
+    compacts: out.autoCompacts + out.manualCompacts,
+    sessionsWithCompact: compacted.size,
+    starts,
+    resumeRate: starts ? out.resumed / starts : 0,
+    avgTokensBeforeCompact: peaks.length ? Math.round(peaks.reduce((a, b) => a + b, 0) / peaks.length) : null,
+  };
+}

package/analytics/metrics/cost.mjs

@@ -0,0 +1,83 @@
+/**
+ * Cost from token counts and a dated price table.
+ *
+ * The table is versioned and the UI states which one produced a number. Prices
+ * change; a cost history silently recomputed under new prices is worse than no
+ * cost history, because it looks authoritative and is not.
+ *
+ * A model we do not recognise is priced by its family and marked `estimated`.
+ * A guess labelled as a guess is useful; a guess presented as a fact is not.
+ */
+
+export const name = 'cost';
+
+/** USD per million tokens. Override in syndes.json under `prices`. */
+export const TABLE_VERSION = '2026-09';
+
+const TABLE = [
+  [/opus/i, { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 }],
+  [/sonnet/i, { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 }],
+  [/haiku/i, { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08 }],
+];
+
+/** This metric folds nothing: it is a pure function of the token summary. */
+export function create() { return {}; }
+export function add() {}
+export function done() { return {}; }
+export function merge() { return {}; }
+
+export function priceFor(model, overrides = {}) {
+  for (const [key, price] of Object.entries(overrides)) {
+    if (model.includes(key)) return { price, exact: true };
+  }
+  for (const [pattern, price] of TABLE) {
+    if (pattern.test(model)) return { price, exact: false };
+  }
+  return { price: null, exact: false };
+}
+
+/**
+ * @param {object} tokenSummary  from metrics/tokens.mjs merge()
+ * @returns {{usd, byModel, estimated, unpriced, tableVersion}}
+ */
+export function costOf(tokenSummary, overrides = {}) {
+  const byModel = {};
+  let usd = 0;
+  let estimated = false;
+  const unpriced = [];
+
+  for (const [model, bucket] of Object.entries(tokenSummary.byModel ?? {})) {
+    const { price, exact } = priceFor(model, overrides);
+    if (!price) {
+      unpriced.push(model);
+      byModel[model] = { usd: null, tokens: bucket };
+      continue;
+    }
+    if (!exact) estimated = true;
+
+    const amount =
+      (bucket.input * price.input +
+        bucket.output * price.output +
+        bucket.cacheWrite * price.cacheWrite +
+        bucket.cacheRead * price.cacheRead) / 1_000_000;
+
+    byModel[model] = { usd: amount, tokens: bucket, estimated: !exact };
+    usd += amount;
+  }
+
+  return { usd, byModel, estimated, unpriced, tableVersion: TABLE_VERSION };
+}
+
+/**
+ * What the same tokens would have cost with no cache reads — the number that
+ * turns "95% cache hit rate" from a statistic into a dollar figure.
+ */
+export function savingsFromCache(tokenSummary, overrides = {}) {
+  let saved = 0;
+  for (const [model, bucket] of Object.entries(tokenSummary.byModel ?? {})) {
+    const { price } = priceFor(model, overrides);
+    if (!price) continue;
+    saved += (bucket.cacheRead * (price.input - price.cacheRead)) / 1_000_000;
+  }
+  return saved;
+}

package/analytics/metrics/friction.mjs

@@ -0,0 +1,86 @@
+/**
+ * Permission blocks, time spent blocked, and which tools cause them.
+ *
+ * Friction is measurable and mostly fixable with an allowlist entry, so this
+ * metric exists to point at the specific rules worth adding — not to inform the
+ * user that friction exists, which they already know.
+ */
+
+import { KIND } from '../../ledger/schema.mjs';
+
+export const name = 'friction';
+/** Beyond this, the user walked away; it is not the permission prompt's fault. */
+const MAX_BLOCK_MS = 10 * 60 * 1000;
+
+export function create() {
+  return {
+    blocks: 0, byTool: new Map(), byTarget: new Map(),
+    blockedMs: 0, waiting: 0, interrupts: 0,
+    open: new Map(),
+  };
+}
+
+export function add(state, record) {
+  const session = record.session ?? 'unknown';
+
+  if (record.kind === KIND.TOOL_BLOCKED) {
+    state.blocks += 1;
+    bump(state.byTool, record.data.tool ?? 'Unknown');
+    const key = `${record.data.tool}${record.data.target ? ` ${record.data.target}` : ''}`;
+    bump(state.byTarget, key.slice(0, 80));
+    state.open.set(session, record.ts);
+    return;
+  }
+
+  // Any later event in that session means the block cleared.
+  const opened = state.open.get(session);
+  if (opened !== undefined) {
+    const waited = record.ts - opened;
+    if (waited > 0 && waited < MAX_BLOCK_MS) state.blockedMs += waited;
+    state.open.delete(session);
+  }
+
+  if (record.kind === KIND.NOTIFY && record.data.kind === 'waiting') state.waiting += 1;
+  if (record.kind === KIND.TOOL_POST && record.data.failed && record.data.tool === 'Bash') {
+    // interrupted commands surface as failures; counted separately in rework
+  }
+}
+
+export function done(state) {
+  return {
+    blocks: state.blocks,
+    blockedMs: state.blockedMs,
+    waiting: state.waiting,
+    byTool: Object.fromEntries(state.byTool),
+    byTarget: Object.fromEntries([...state.byTarget.entries()].sort((a, b) => b[1] - a[1]).slice(0, 25)),
+  };
+}
+
+export function merge(parts) {
+  const byTool = {};
+  const byTarget = {};
+  let blocks = 0;
+  let blockedMs = 0;
+  let waiting = 0;
+
+  for (const part of parts) {
+    blocks += part.blocks ?? 0;
+    blockedMs += part.blockedMs ?? 0;
+    waiting += part.waiting ?? 0;
+    for (const [key, count] of Object.entries(part.byTool ?? {})) byTool[key] = (byTool[key] ?? 0) + count;
+    for (const [key, count] of Object.entries(part.byTarget ?? {})) byTarget[key] = (byTarget[key] ?? 0) + count;
+  }
+
+  const ranked = Object.entries(byTarget).sort((a, b) => b[1] - a[1]);
+  return {
+    blocks, blockedMs, waiting, byTool,
+    byTarget: Object.fromEntries(ranked.slice(0, 25)),
+    // The single allowlist entry that would remove the most interruptions.
+    worstOffender: ranked[0] ? { target: ranked[0][0], count: ranked[0][1] } : null,
+    avgBlockMs: blocks ? Math.round(blockedMs / blocks) : 0,
+  };
+}
+
+function bump(map, key) {
+  map.set(key, (map.get(key) ?? 0) + 1);
+}

package/analytics/metrics/prompts.mjs

@@ -0,0 +1,93 @@
+/**
+ * Prompt length, corrections, and one-shot success.
+ *
+ * All proxies, and labelled as proxies wherever they are shown. In 'metadata'
+ * privacy mode nothing here reads text; it degrades to lengths and counts, which
+ * is most of the signal anyway — the correction flag is computed at classify
+ * time, before the text is dropped.
+ */
+
+import { KIND } from '../../ledger/schema.mjs';
+
+export const name = 'prompts';
+
+export function create() {
+  return {
+    count: 0, chars: 0, words: 0, corrections: 0, redactions: 0,
+    lengths: [], gaps: [], lastPrompt: new Map(),
+    sinceLastPrompt: new Map(), oneShot: 0, followUp: 0,
+  };
+}
+
+export function add(state, record) {
+  const session = record.session ?? 'unknown';
+
+  if (record.kind === KIND.PROMPT) {
+    state.count += 1;
+    state.chars += record.data.chars ?? 0;
+    state.words += record.data.words ?? 0;
+    state.redactions += record.data.redactions ?? 0;
+    state.lengths.push(record.data.words ?? 0);
+    if (record.data.correction) state.corrections += 1;
+
+    const previous = state.lastPrompt.get(session);
+    if (previous !== undefined) {
+      state.gaps.push(record.ts - previous);
+      // A prompt with no tool call since the last one is a re-prompt: the
+      // previous turn produced nothing the user wanted to build on.
+      if (state.sinceLastPrompt.get(session) === 0) state.followUp += 1;
+      else state.oneShot += 1;
+    }
+    state.lastPrompt.set(session, record.ts);
+    state.sinceLastPrompt.set(session, 0);
+    return;
+  }
+
+  if (record.kind === KIND.TOOL_POST) {
+    state.sinceLastPrompt.set(session, (state.sinceLastPrompt.get(session) ?? 0) + 1);
+  }
+}
+
+export function done(state) {
+  return {
+    count: state.count,
+    chars: state.chars,
+    words: state.words,
+    corrections: state.corrections,
+    redactions: state.redactions,
+    oneShot: state.oneShot,
+    followUp: state.followUp,
+    lengths: state.lengths.slice(0, 500),
+    gaps: state.gaps.slice(0, 500),
+  };
+}
+
+export function merge(parts) {
+  const out = { count: 0, chars: 0, words: 0, corrections: 0, redactions: 0, oneShot: 0, followUp: 0 };
+  const lengths = [];
+  const gaps = [];
+
+  for (const part of parts) {
+    for (const key of Object.keys(out)) out[key] += part[key] ?? 0;
+    lengths.push(...(part.lengths ?? []));
+    gaps.push(...(part.gaps ?? []));
+  }
+
+  return {
+    ...out,
+    avgWords: out.count ? Math.round(out.words / out.count) : 0,
+    medianWords: median(lengths),
+    correctionRate: out.count ? out.corrections / out.count : 0,
+    // Deliberately not "success rate". It measures whether the user had to
+    // re-ask, which is a proxy, and calling it anything stronger would be a lie.
+    reprompRate: (out.oneShot + out.followUp) ? out.followUp / (out.oneShot + out.followUp) : null,
+    medianGapMs: median(gaps),
+  };
+}
+
+function median(values) {
+  if (!values.length) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[middle] : Math.round((sorted[middle - 1] + sorted[middle]) / 2);
+}

package/analytics/metrics/rework.mjs

@@ -0,0 +1,113 @@
+/**
+ * Repeat edits, retry storms, and the error→fix cycle.
+ *
+ * The clearest signal that a loop is not converging. Detected sequentially — the
+ * fold sees records in chain order, which is exactly why this lives in the fold
+ * and not in a query.
+ */
+
+import { KIND } from '../../ledger/schema.mjs';
+
+export const name = 'rework';
+/** Two edits to one file inside this window are one change, not two. */
+const CHURN_WINDOW_MS = 12 * 60 * 1000;
+/** The same command failing this many times running is a storm, not a retry. */
+const STORM_THRESHOLD = 3;
+
+export function create() {
+  return {
+    lastEdit: new Map(), churn: new Map(),
+    failStreak: new Map(), storms: [],
+    errors: 0, calls: 0,
+    editsSinceVerify: 0, verifiedRuns: 0, unverifiedRuns: 0,
+  };
+}
+
+export function add(state, record) {
+  if (record.kind === KIND.FILE_TOUCH) {
+    const path = record.data.path;
+    state.editsSinceVerify += 1;
+    if (!path) return;
+
+    const previous = state.lastEdit.get(path);
+    if (previous !== undefined && record.ts - previous <= CHURN_WINDOW_MS) {
+      state.churn.set(path, (state.churn.get(path) ?? 1) + 1);
+    }
+    state.lastEdit.set(path, record.ts);
+    return;
+  }
+
+  if (record.kind === KIND.TOOL_PRE && record.data.verification) {
+    // A verification run closes the current stretch of unverified edits.
+    if (state.editsSinceVerify > 0) state.verifiedRuns += 1;
+    state.editsSinceVerify = 0;
+    return;
+  }
+
+  if (record.kind !== KIND.TOOL_POST) return;
+  state.calls += 1;
+
+  const key = `${record.data.tool}|${record.data.target ?? ''}`;
+  if (record.data.failed) {
+    state.errors += 1;
+    const streak = (state.failStreak.get(key) ?? 0) + 1;
+    state.failStreak.set(key, streak);
+    if (streak === STORM_THRESHOLD) {
+      state.storms.push({ key: key.slice(0, 80), at: record.ts, streak });
+    } else if (streak > STORM_THRESHOLD) {
+      state.storms[state.storms.length - 1].streak = streak;
+    }
+  } else {
+    state.failStreak.set(key, 0);
+  }
+}
+
+export function done(state) {
+  // Edits still outstanding when the day ended were never verified.
+  if (state.editsSinceVerify > 0) state.unverifiedRuns += 1;
+
+  return {
+    churn: Object.fromEntries([...state.churn.entries()].sort((a, b) => b[1] - a[1]).slice(0, 25)),
+    storms: state.storms.slice(0, 25),
+    errors: state.errors,
+    calls: state.calls,
+    verifiedRuns: state.verifiedRuns,
+    unverifiedRuns: state.unverifiedRuns,
+    danglingEdits: state.editsSinceVerify,
+  };
+}
+
+export function merge(parts) {
+  const churn = {};
+  const storms = [];
+  let errors = 0;
+  let calls = 0;
+  let verifiedRuns = 0;
+  let unverifiedRuns = 0;
+
+  for (const part of parts) {
+    for (const [path, count] of Object.entries(part.churn ?? {})) {
+      churn[path] = Math.max(churn[path] ?? 0, count);
+    }
+    storms.push(...(part.storms ?? []));
+    errors += part.errors ?? 0;
+    calls += part.calls ?? 0;
+    verifiedRuns += part.verifiedRuns ?? 0;
+    unverifiedRuns += part.unverifiedRuns ?? 0;
+  }
+
+  const ranked = Object.entries(churn).sort((a, b) => b[1] - a[1]);
+  const runs = verifiedRuns + unverifiedRuns;
+  return {
+    churn: Object.fromEntries(ranked.slice(0, 25)),
+    worstChurn: ranked[0] ? { path: ranked[0][0], edits: ranked[0][1] } : null,
+    storms: storms.slice(0, 25),
+    stormCount: storms.length,
+    errors,
+    calls,
+    errorRate: calls ? errors / calls : 0,
+    verifiedRuns,
+    unverifiedRuns,
+    verifyRate: runs ? verifiedRuns / runs : null,
+  };
+}

package/analytics/metrics/time.mjs

@@ -0,0 +1,104 @@
+/**
+ * Active time vs wall-clock, work blocks, hour-of-day, time to first tool.
+ *
+ * Active time is the sum of gaps below the idle threshold. A session left open
+ * over lunch is not an hour of work, and reporting it as one makes every
+ * downstream ratio — cost per hour, tools per hour, the whole efficiency
+ * story — a lie in the user's favour.
+ */
+
+import { KIND } from '../../ledger/schema.mjs';
+
+export const name = 'time';
+
+export function create() {
+  return {
+    hours: new Array(24).fill(0),
+    weekdays: new Array(7).fill(0),
+    activeMs: 0,
+    firstAt: null,
+    lastAt: null,
+    lastBySession: new Map(),
+    spans: new Map(),
+    firstToolDelays: [],
+    pendingPrompt: new Map(),
+  };
+}
+
+export function add(state, record, ctx) {
+  const ts = record.ts;
+  const date = new Date(ts);
+  state.hours[date.getHours()] += 1;
+  state.weekdays[date.getDay()] += 1;
+  state.firstAt = state.firstAt === null ? ts : Math.min(state.firstAt, ts);
+  state.lastAt = state.lastAt === null ? ts : Math.max(state.lastAt, ts);
+
+  const session = record.session ?? 'unknown';
+  const previous = state.lastBySession.get(session);
+  if (previous !== undefined) {
+    const gap = ts - previous;
+    if (gap > 0 && gap <= ctx.idleGapMs) state.activeMs += gap;
+  }
+  state.lastBySession.set(session, ts);
+
+  const span = state.spans.get(session);
+  if (!span) state.spans.set(session, { first: ts, last: ts });
+  else span.last = ts;
+
+  // How long from asking to the first thing actually happening.
+  if (record.kind === KIND.PROMPT) state.pendingPrompt.set(session, ts);
+  else if (record.kind === KIND.TOOL_PRE && state.pendingPrompt.has(session)) {
+    state.firstToolDelays.push(ts - state.pendingPrompt.get(session));
+    state.pendingPrompt.delete(session);
+  }
+}
+
+export function done(state) {
+  let wallMs = 0;
+  for (const span of state.spans.values()) wallMs += span.last - span.first;
+
+  return {
+    hours: state.hours,
+    weekdays: state.weekdays,
+    activeMs: state.activeMs,
+    wallMs,
+    firstAt: state.firstAt,
+    lastAt: state.lastAt,
+    firstToolDelays: state.firstToolDelays.slice(0, 400),
+  };
+}
+
+export function merge(parts) {
+  const hours = new Array(24).fill(0);
+  const weekdays = new Array(7).fill(0);
+  let activeMs = 0;
+  let wallMs = 0;
+  let firstAt = null;
+  let lastAt = null;
+  const delays = [];
+
+  for (const part of parts) {
+    (part.hours ?? []).forEach((value, index) => { hours[index] += value; });
+    (part.weekdays ?? []).forEach((value, index) => { weekdays[index] += value; });
+    activeMs += part.activeMs ?? 0;
+    wallMs += part.wallMs ?? 0;
+    if (part.firstAt != null) firstAt = firstAt === null ? part.firstAt : Math.min(firstAt, part.firstAt);
+    if (part.lastAt != null) lastAt = lastAt === null ? part.lastAt : Math.max(lastAt, part.lastAt);
+    delays.push(...(part.firstToolDelays ?? []));
+  }
+
+  return {
+    hours, weekdays, activeMs, wallMs, firstAt, lastAt,
+    // Median, not mean: one 40-minute stall should not redefine a typical wait.
+    medianFirstTool: median(delays),
+    activeShare: wallMs ? activeMs / wallMs : 0,
+    activeDays: parts.filter((part) => (part.activeMs ?? 0) > 0).length,
+  };
+}
+
+function median(values) {
+  if (!values.length) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[middle] : Math.round((sorted[middle - 1] + sorted[middle]) / 2);
+}

package/analytics/metrics/tokens.mjs

@@ -0,0 +1,88 @@
+/**
+ * Input, output, cache-read and cache-creation tokens, by model.
+ *
+ * Cache hit rate is the headline. It is the cheapest efficiency win available in
+ * Claude Code and almost nobody measures it — a session that keeps its prefix
+ * stable reads context at a fraction of the price of one that keeps reshuffling it.
+ */
+
+import { KIND } from '../../ledger/schema.mjs';
+
+export const name = 'tokens';
+
+export function create() {
+  return { byModel: new Map(), turnsWithTools: 0, toolUses: 0, turns: 0, sidechainTurns: 0 };
+}
+
+export function add(state, record) {
+  if (record.kind !== KIND.USAGE) return;
+  const data = record.data;
+  const model = data.model ?? 'unknown';
+
+  if (!state.byModel.has(model)) {
+    state.byModel.set(model, { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, thinking: 0, turns: 0 });
+  }
+  const bucket = state.byModel.get(model);
+  bucket.input += data.input ?? 0;
+  bucket.output += data.output ?? 0;
+  bucket.cacheRead += data.cacheRead ?? 0;
+  bucket.cacheWrite += data.cacheWrite ?? 0;
+  bucket.thinking += data.thinking ?? 0;
+  bucket.turns += 1;
+
+  state.turns += 1;
+  if (data.sidechain) state.sidechainTurns += 1;
+  if (data.toolUses > 0) {
+    state.turnsWithTools += 1;
+    state.toolUses += data.toolUses;
+  }
+}
+
+export function done(state) {
+  return {
+    byModel: Object.fromEntries(state.byModel),
+    turns: state.turns,
+    turnsWithTools: state.turnsWithTools,
+    toolUses: state.toolUses,
+    sidechainTurns: state.sidechainTurns,
+  };
+}
+
+export function merge(parts) {
+  const byModel = {};
+  let turns = 0;
+  let turnsWithTools = 0;
+  let toolUses = 0;
+  let sidechainTurns = 0;
+
+  for (const part of parts) {
+    for (const [model, bucket] of Object.entries(part.byModel ?? {})) {
+      byModel[model] ??= { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, thinking: 0, turns: 0 };
+      for (const key of Object.keys(bucket)) byModel[model][key] += bucket[key] ?? 0;
+    }
+    turns += part.turns ?? 0;
+    turnsWithTools += part.turnsWithTools ?? 0;
+    toolUses += part.toolUses ?? 0;
+    sidechainTurns += part.sidechainTurns ?? 0;
+  }
+
+  const totals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, thinking: 0 };
+  for (const bucket of Object.values(byModel)) {
+    for (const key of Object.keys(totals)) totals[key] += bucket[key];
+  }
+
+  const readable = totals.input + totals.cacheRead + totals.cacheWrite;
+  return {
+    ...totals,
+    byModel,
+    turns,
+    turnsWithTools,
+    toolUses,
+    sidechainTurns,
+    total: totals.input + totals.output + totals.cacheRead + totals.cacheWrite,
+    cacheHitRate: readable ? totals.cacheRead / readable : 0,
+    // Independent calls issued in one turn cost one round-trip; the same three
+    // across three turns cost three. This is the batching number.
+    callsPerTurn: turnsWithTools ? toolUses / turnsWithTools : 0,
+  };
+}