syndes 0.3.3 → 0.4.0

package/dashboard/web/views/overview.js

@@ -3,16 +3,25 @@
  *
  * Four questions, in the order people actually ask them:
  *   1. Am I working well?     the score, and what dragged it
- *   2. What did it cost me?   throughput and spend, with the shape of the trend
- *   3. When did I work?       a day-by-day timeline
+ *   2. What did it take?      throughput and burn rate, with the shape of it
+ *   3. When did I work?       hour by hour on one day, day by day over a range
  *   4. What should I change?  the top findings, with their evidence
  *
  * Anything that does not answer one of those four is not on this page.
+ *
+ * The page has two shapes, because one day and thirty days are different
+ * questions rather than the same question at different widths. Over a range the
+ * x axis is days; on a single day it is hours. A week's chart drawn with one
+ * point on it is not a simpler chart, it is a broken one — and the single day is
+ * now the default, so it is the shape that has to be right first.
  */
 
 import { api } from '../api.js';
-import { h, card, figure, trend, chip, dot, meter, legend, empty, compact, usd, duration, percent } from '../ui.js';
-import { dial, capsules, timeline, dualLine } from '../charts.js';
+import {
+  h, card, figure, trend, chip, dot, meter, legend, empty,
+  compact, duration, percent, perHour, times, dayLabel,
+} from '../ui.js';
+import { dial, capsules, timeline, dualLine, dayStrip } from '../charts.js';
 
 /** Tone by what a tool costs you, which is what the colour is claiming. */
 const FAMILY_TONE = {
@@ -20,17 +29,25 @@ const FAMILY_TONE = {
   edit: 'white', execute: 'white', web: 'white', mcp: 'white', other: 'white',
 };
 
-export async function render({ range, go }) {
+const NAMES = { 'claude-code': 'Claude Code', codex: 'Codex' };
+
+export async function render({ range, days, go, setDay, setScope }) {
   const [data, practices] = await Promise.all([api.overview(range), api.practices()]);
 
   if ((data.ledger?.seq ?? -1) < 0) return firstRun();
 
+  // The server's answer, not the client's guess: it resolved the spec, so it is
+  // the one that knows whether this turned out to be a single day.
+  const oneDay = data.range.days.length === 1;
+  if (oneDay && !data.metrics.records) return quietDay(data.range.days[0], days, { setDay, setScope });
+
+
   // Fixed top row, and the bottom row takes whatever is left — so the view is
   // exactly one screen and the findings list scrolls inside its own card.
   return h('div.content--fit', {
     style: 'display:grid;grid-template-rows:auto minmax(0,1fr);gap:var(--s4);min-height:0',
   }, [
-    h('div.grid.g-3', {}, [scoreCard(data), throughputCard(data), timelineCard(data)]),
+    h('div.grid.g-3', {}, [scoreCard(data), throughputCard(data, oneDay), shapeCard(data, oneDay)]),
     h('div.grid.fill', { style: 'grid-template-columns:minmax(0,1fr) minmax(0,1.6fr)' }, [
       distributionCard(data),
       fixCard(practices.findings, go),
@@ -59,6 +76,54 @@ function firstRun() {
   ]);
 }
 
+/**
+ * A day with nothing on it.
+ *
+ * This became the common case the moment one day became the default: open the
+ * dashboard before you have started and every chart is empty. Five empty charts
+ * read as a broken tool, so the day says it is quiet in words and then offers the
+ * two ways out — the last day that does have something on it, and the week.
+ *
+ * The suggested day comes from the picker's own index, so it is never a guess
+ * about which day had work: it is the same list the dropdown is showing. The
+ * shell fetches that list in the background, which on a first load can land
+ * after this panel — so the panel asks for it when it arrives empty rather than
+ * dropping the one button that gets somebody out of an empty day.
+ */
+async function quietDay(theDay, days = [], { setDay, setScope }) {
+  let index = days;
+  if (!index.length) {
+    index = await api.days().then((body) => body.days ?? []).catch(() => []);
+  }
+  const previous = index.find((entry) => entry.day < theDay && entry.records > 0);
+
+  return h('div', { style: 'display:grid;place-items:center;height:100%' }, [
+    h('div', { style: 'max-width:540px;display:grid;gap:18px;justify-items:center;text-align:center' }, [
+      h('div', {
+        style: 'font-size:24px;font-weight:750;letter-spacing:-0.02em;text-transform:uppercase',
+        text: `Nothing recorded ${preposition(theDay)}`,
+      }),
+      h('p', { style: 'color:var(--ink-2);line-height:1.7;margin:0',
+        text: 'The chain is intact and recording — this day simply has no sessions on it yet. Step back a day with the arrows, or widen the window.' }),
+      h('div', { style: 'display:flex;gap:10px;flex-wrap:wrap;justify-content:center' }, [
+        previous
+          ? h('button.btn.btn--lime', {
+              text: `Go to ${dayLabel(previous.day)}`,
+              onclick: () => setDay(previous.day),
+            })
+          : null,
+        h('button.btn.btn--ghost', { text: 'Last 7 days', onclick: () => setScope('7d') }),
+      ]),
+    ]),
+  ]);
+}
+
+/** "today" reads better than "on today"; a date needs the preposition. */
+function preposition(theDay) {
+  const label = dayLabel(theDay, { long: true });
+  return label === 'Today' || label === 'Yesterday' ? label.toLowerCase() : `on ${label}`;
+}
+
 // ── 1. Score ───────────────────────────────────────────────────────────────
 
 function scoreCard({ score, scoreDelta }) {
@@ -89,7 +154,7 @@ function scoreCard({ score, scoreDelta }) {
   ], { note: 'weighted' });
 }
 
-// ── 2. Throughput and spend ────────────────────────────────────────────────
+// ── 2. Throughput and what it took ─────────────────────────────────────────
 
 /**
  * Which agent the work came from.
@@ -105,55 +170,118 @@ function sourceChips(metrics) {
   return sources.map(([id, bucket]) => chip(`${NAMES[id] ?? id} · ${compact(bucket.toolCalls)}`));
 }
 
-const NAMES = { 'claude-code': 'Claude Code', codex: 'Codex' };
-
-function throughputCard({ headline, previousHeadline: before, series, cost, metrics }) {
+/**
+ * Throughput, and the rate the usage window went at.
+ *
+ * The second figure used to be a dollar amount. It is a burn rate now, because
+ * a Claude plan bills a month and not a token: the invented price was the one
+ * number on this page nobody is charged. New tokens per active hour IS the
+ * scarcity on a subscription, and unlike a price it moves when you change how
+ * you work. analytics/metrics/window.mjs has the full argument, including why
+ * the rate divides new tokens rather than the cache-read total.
+ */
+function throughputCard({ headline, previousHeadline: before, series, metrics }, oneDay) {
   return card('Throughput', [
     h('div.pair', {}, [
       figure('Active time', duration(headline.activeMs), { small: true }),
-      figure('Spend', usd(headline.usd), { small: true }),
+      figure('New tokens / active hour', perHour(headline.freshPerHour), { small: true }),
     ]),
+
+    // A single day gets counts where a range gets a chart. The hourly SHAPE of a
+    // day is the next card's entire job, and two charts of the same series is
+    // worse than one — so this side spends the space on the numbers instead.
+    oneDay
+      ? h('div.pair', {}, [
+          figure('Tool calls', compact(headline.toolCalls), { small: true }),
+          figure('Prompts', String(headline.prompts), { small: true }),
+          figure('Sessions', String(headline.sessions), { small: true }),
+        ])
+      : null,
+
     // One trend line, not one per figure: repeating "no prior period" twice
     // spends two rows saying nothing.
     trend(headline.toolCalls, before.toolCalls, { format: (value) => `${compact(value)} calls` }),
-    h('div', { style: 'flex:1;min-height:0;display:grid;align-items:center' }, [
+
+    oneDay ? null : h('div', { style: 'flex:1;min-height:0;display:grid;align-items:center' }, [
       dualLine(
-        series.map((day) => day.toolCalls),
-        series.map((day) => day.tokens / 1000),
+        series.map((entry) => entry.toolCalls),
+        series.map((entry) => entry.tokens / 1000),
         { height: 110 },
       ),
     ]),
-    legend([
+    oneDay ? null : legend([
       { tone: 'lime', label: 'tool calls' },
       { tone: 'orange', label: 'tokens' },
     ]),
-    h('div', { style: 'display:flex;gap:10px;flex-wrap:wrap' }, [
+
+    h('div', {
+      style: `display:flex;gap:10px;flex-wrap:wrap;align-content:end${oneDay ? ';flex:1;min-height:0' : ''}`,
+    }, [
       chip(`${percent(headline.cacheHitRate)} from cache`, 'lime'),
-      chip(`${compact(headline.tokens)} tokens`),
-      cost.estimated ? chip('estimated pricing') : null,
+      chip(`${compact(headline.tokens)} tokens read`),
+      chip(`${compact(headline.fresh)} new`),
+      // Restating the total under another name is not a second number, so this
+      // only appears once there is more than one ask to average over.
+      headline.prompts > 1 && headline.freshPerPrompt !== null
+        ? chip(`${compact(headline.freshPerPrompt)} per prompt`)
+        : null,
+      headline.cacheLeverage === null ? null : chip(`${times(headline.cacheLeverage)} context reuse`),
       ...sourceChips(metrics),
     ]),
-  ]);
+  ], { note: oneDay ? 'this day' : null });
 }
 
 // ── 3. When the work happened ──────────────────────────────────────────────
 
-function timelineCard({ series }) {
+function shapeCard(data, oneDay) {
+  return oneDay ? hourCard(data) : dayCard(data);
+}
+
+/**
+ * One day, by the hour, in minutes worked.
+ *
+ * Minutes and not event counts: twelve tool calls in an hour is not the same
+ * thing as twelve minutes of work, and a day drawn from record counts reports a
+ * busy minute as a busy hour. analytics/metrics/time.mjs folds both series for
+ * exactly this reason.
+ */
+function hourCard({ hourActiveMs, hours }) {
+  const minutes = (hourActiveMs ?? []).map((ms) => Math.round(ms / 60_000));
+  const worked = minutes.reduce((sum, value) => sum + value, 0);
+
+  const slots = minutes.map((value, hour) => ({
+    label: String(hour).padStart(2, '0'),
+    value,
+    tone: 'lime',
+    title: value
+      ? `${String(hour).padStart(2, '0')}:00 · ${value}m active · ${hours?.[hour] ?? 0} events`
+      : `${String(hour).padStart(2, '0')}:00 · nothing recorded`,
+  }));
+
+  return card('Active minutes by hour', [
+    worked
+      ? dayStrip(slots, { height: 150, labelEvery: 3, label: 'active minutes by hour of the day' })
+      : empty('No active time recorded on this day'),
+    legend([{ tone: 'lime', label: 'minutes worked' }], `${worked}m`),
+  ], { note: '24 hours, local' });
+}
+
+function dayCard({ series }) {
   const days = series.slice(-9);
-  const maxMinutes = Math.max(...days.map((day) => day.activeMs / 60_000), 10);
+  const maxMinutes = Math.max(...days.map((entry) => entry.activeMs / 60_000), 10);
   const step = Math.max(10, Math.ceil(maxMinutes / 4 / 10) * 10);
   const ticks = [];
   for (let value = 0; value <= maxMinutes + step; value += step) ticks.push({ at: value, label: String(value) });
 
-  const bars = days.map((day) => ({
-    row: day.day.slice(5).replace('-', '.'),
+  const bars = days.map((entry) => ({
+    row: entry.day.slice(5).replace('-', '.'),
     start: 0,
-    end: day.activeMs / 60_000,
-    value: `${Math.round(day.activeMs / 60_000)}m`,
+    end: entry.activeMs / 60_000,
+    value: `${Math.round(entry.activeMs / 60_000)}m`,
     empty: 'no activity',
     // Orange marks a day the context window ran out — the thing worth spotting
     // in a week at a glance.
-    tone: day.compacts > 0 ? 'orange' : 'lime',
+    tone: entry.compacts > 0 ? 'orange' : 'lime',
   }));
 
   return card('Active minutes by day', [
@@ -163,7 +291,7 @@ function timelineCard({ series }) {
     legend([
       { tone: 'lime', label: 'clean day' },
       { tone: 'orange', label: 'context ran out' },
-    ], days.reduce((sum, day) => sum + Math.round(day.activeMs / 60_000), 0)),
+    ], days.reduce((sum, entry) => sum + Math.round(entry.activeMs / 60_000), 0)),
   ]);
 }
 
@@ -195,6 +323,14 @@ function distributionCard({ metrics }) {
 
 // ── 5. What to change ──────────────────────────────────────────────────────
 
+/**
+ * The findings are NOT scoped to the selected window.
+ *
+ * The practice engine reads its own recent history, because a rule about retry
+ * storms needs the run of events that produced one and cannot answer from a day
+ * you happen to be looking at. The note says so rather than letting the card
+ * imply it is about the day above it.
+ */
 function fixCard(findings, go) {
   const live = findings.filter((finding) => !finding.muted).slice(0, 3);
 
@@ -209,6 +345,7 @@ function fixCard(findings, go) {
         h('div.finding__fix', {}, [h('span', { text: finding.fix })]),
       ]))
     : [empty('No rule found a pattern worth changing.')]), {
+    note: 'recent habits, not this window',
     actions: h('button.btn.btn--ghost.btn--sm', { text: 'All habits', style: 'margin-left:auto', onclick: () => go('habits') }),
   });
 }

package/dashboard/web/views/settings.js

@@ -88,7 +88,7 @@ async function paint(page) {
       toggle('Tool calls', config.track.tools, (v) => save('track.tools', v), 'Most of the score is built from these.'),
       toggle('Prompts', config.track.prompts, (v) => save('track.prompts', v)),
       toggle('Permission requests', config.track.permissions, (v) => save('track.permissions', v)),
-      toggle('Tokens and cost', config.track.transcript, (v) => save('track.transcript', v), 'Read incrementally from the session transcript.'),
+      toggle('Tokens and cache', config.track.transcript, (v) => save('track.transcript', v), 'Read incrementally from the session transcript.'),
       toggle('Git commits', config.track.git, (v) => save('track.git', v)),
     ]),
 

package/dashboard/web/views/team.js

@@ -4,9 +4,13 @@
  * Four questions, in the order two people sharing a plan actually ask them:
  *   1. Whose share is it?        the split, and which way it moved
  *   2. What is the pool doing?   totals, and whether the numbers are live
- *   3. Were we in each other's way?  the contention grid — the one thing
+ *   3. Were we in each other's way?  the contention chart — the one thing
  *      neither person can see from their own machine
- *   4. How did each day break down?  the daily split, and who is in the pool
+ *   4. How did it break down?        the split, and who is in the pool
+ *
+ * The page defaults to one day, like the rest of the dashboard, because that is
+ * the question a shared plan actually raises: not "who used more this month" but
+ * "are we throttling each other right now". A week's average cannot answer it.
  *
  * The page is live while it is open: it holds one event stream, and the server
  * polls the pool only while that stream exists. When the view is replaced the
@@ -17,9 +21,9 @@
 import { api } from '../api.js';
 import {
   h, card, figure, trend, chip, dot, meter, legend, empty, modal,
-  compact, usd, duration, percent, when, DASH,
+  compact, duration, percent, perHour, when, dayLabel, DASH,
 } from '../ui.js';
-import { dotMatrix, laneSplit, splitBar } from '../charts.js';
+import { dotMatrix, hourMatrix, laneSplit, splitBar } from '../charts.js';
 
 export async function render({ range }) {
   const data = await api.team(range);
@@ -129,7 +133,18 @@ function shareCard(data, me) {
   ]);
 }
 
-// 2. What is the pool doing
+/**
+ * 2. What is the pool doing
+ *
+ * The fourth figure used to be a notional dollar amount with a paragraph under
+ * it apologising for being notional. Both are gone. On a shared plan nobody is
+ * billed per token, so the number was an invention — and a figure that needs a
+ * disclaimer to be read correctly has already failed.
+ *
+ * What replaces it is the rate the SHARED window is being spent at, which is the
+ * actual scarcity two people on one account are splitting. See
+ * analytics/metrics/window.mjs.
+ */
 function poolCard(data, live) {
   const sync = data.sync ?? {};
   const failed = sync.ok === false && sync.error;
@@ -137,12 +152,12 @@ function poolCard(data, live) {
   return card('The pool', [
     h('div.grid', { style: 'grid-template-columns:1fr 1fr;gap:var(--s4)' }, [
       figure('people', String(data.totals.people), { small: true }),
-      figure('tokens', compact(data.totals.tokens), {
+      figure('tokens read', compact(data.totals.tokens), {
         small: true,
         trend: trend(data.totals.tokens, data.totals.tokens - (data.totals.deltaTokens ?? 0), { format: compact }),
       }),
       figure('active time', duration(data.totals.activeMs), { small: true }),
-      figure('notional cost', usd(data.totals.usd), { small: true }),
+      figure('new tokens / active hour', perHour(data.rates?.freshPerHour), { small: true }),
     ]),
 
     h('div', { style: 'display:grid;gap:6px;margin-top:auto' }, [
@@ -157,46 +172,69 @@ function poolCard(data, live) {
       h('span.card__note', { text: `Last exchange ${sync.at ? when(sync.at) : DASH}` }),
       failed ? h('span.card__note', { style: 'color:var(--orange)', text: String(sync.error).slice(0, 120) }) : null,
       h('span.card__note', {
-        // Said plainly on the page rather than buried in a doc: on a shared plan
-        // the dollars are what these tokens WOULD have cost at API rates, and
-        // presenting an estimate as a bill would be the wrong kind of confident.
-        text: 'Cost is notional — a shared plan bills a subscription, not tokens.',
+        // Said plainly on the page rather than left to be inferred: the scarce
+        // thing here is the window, so that is what the rate measures. Cache
+        // reads are excluded because they are context nobody had to re-send.
+        text: 'No prices: a shared plan bills a subscription. The rate counts new tokens only.',
       }),
     ]),
   ]);
 }
 
-// 3. Were we in each other's way
+/**
+ * 3. Were we in each other's way
+ *
+ * Two pictures of one question, because a day and a fortnight are not the same
+ * shape. Over a range: days across, three-hour bands down, one dot per band —
+ * good for spotting a pattern. On a single day: hours across, a lane per person
+ * down — good for seeing that the two of you were both on it at four, and which
+ * two. The server decides which (analytics/team.mjs sets `grid.hourly`), because
+ * it is the side that resolved the range.
+ */
 function contentionCard(data) {
   const grid = data.grid;
   const overlapping = grid.overlapBands > 0;
+  const unit = grid.hourly ? 'hour' : 'band';
 
-  return card('When each of you worked', [
+  return card(grid.hourly ? 'Who worked when' : 'When each of you worked', [
     h('div', { style: 'display:flex;align-items:baseline;gap:var(--s3)' }, [
-      figure('of working hours overlapped', percent(grid.overlapRate), { small: true }),
+      figure(`of working ${unit}s overlapped`, percent(grid.overlapRate), { small: true }),
       overlapping
-        ? chip(`${grid.overlapBands} band${grid.overlapBands === 1 ? '' : 's'}`, 'orange')
+        ? chip(`${grid.overlapBands} ${unit}${grid.overlapBands === 1 ? '' : 's'}`, 'orange')
         : chip('no overlap', 'lime'),
     ]),
-    dotMatrix(grid),
+    h('div.scroll-x', {}, [grid.hourly ? hourMatrix(grid) : dotMatrix(grid)]),
     legend([
-      { tone: 'lime', label: 'one person had the window' },
-      { tone: 'orange', label: 'two or more at once' },
+      { tone: 'lime', label: 'had the window alone' },
+      { tone: 'orange', label: 'shared it with someone' },
     ]),
     h('span.card__note', {
       text: overlapping
-        ? 'Orange bands are where you were both spending the same rate limit.'
+        ? `Orange ${unit}s are where you were both spending the same rate limit.`
         : 'Nobody has collided in this period.',
     }),
-  ], { note: `${grid.bandHours}-hour bands` });
+  ], { note: grid.hourly ? 'one day, by the hour' : `${grid.bandHours}-hour bands` });
 }
 
-// 4a. How did each day break down
+/**
+ * 4a. How each day broke down.
+ *
+ * One row per day with a capsule per person. A single selected day is one row,
+ * which is small but not degraded — it still answers who took the day, and the
+ * contention chart beside it is the one that spreads a single day out.
+ */
 function splitCard(data) {
+  const oneDay = data.range.days.length === 1;
+  const title = oneDay ? 'The split' : 'Daily split';
   const rows = data.lanes.filter((row) => row.total > 0);
-  if (!rows.length) return card('Daily split', [empty('No shared activity in this range yet.')]);
 
-  return card('Daily split', [
+  if (!rows.length) {
+    return card(title, [empty(oneDay
+      ? `Nobody in the pool recorded anything on ${dayLabel(data.range.days[0])}.`
+      : 'No shared activity in this range yet.')]);
+  }
+
+  return card(title, [
     h('div.card__scroll', {}, [
       laneSplit(rows, { format: compact }),
     ]),
@@ -204,7 +242,7 @@ function splitCard(data) {
       { tone: 'lime', label: 'you' },
       { tone: 'white', label: 'everyone else' },
     ], compact(data.totals.tokens)),
-  ], { note: 'newest first' });
+  ], { note: oneDay ? dayLabel(data.range.days[0]) : 'newest first' });
 }
 
 // 4b. The people

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "syndes",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "SynDes — a tamper-evident ledger of everything you do in Claude Code, an efficiency score built from it, and a local dashboard that shows you how you actually work. Splits one shared account between the people on it. macOS, Windows and Linux. Zero dependencies.",
   "keywords": [
     "syndes",
@@ -16,7 +16,6 @@
     "dashboard",
     "hooks",
     "tokens",
-    "cost",
     "macos",
     "windows",
     "linux",

package/practices/catalog.mjs

@@ -29,7 +29,7 @@ export const CATALOG = {
   },
   'prompt-specificity': {
     title: 'A lot of prompts are corrections',
-    why: 'A correction means the previous turn missed. The cost is not the correction — it is the whole turn that was thrown away, at full token price.',
+    why: 'A correction means the previous turn missed. What it costs you is not the correction — it is the whole turn that was thrown away, and every token that went into it.',
     fix: 'Name the file, the function and the expected outcome in the first prompt.',
   },
   'delegate-wide-search': {

package/runtime/config.mjs

@@ -22,7 +22,7 @@ export const DEFAULTS = {
     tools: true,       // PreToolUse + PostToolUse — the expensive pair, on by default
     prompts: true,
     permissions: true,
-    transcript: true,  // token, cost and cache numbers
+    transcript: true,  // token and cache numbers
     git: true,
   },
 

package/runtime/worker.mjs

@@ -162,7 +162,7 @@ function count(session, event, last) {
   if (last?.kind === KIND.TOOL_POST && last.data.failed) counts.errors += 1;
 }
 
-/** Token, cost and cache numbers, read incrementally from each transcript. */
+/** Token and cache numbers, read incrementally from each transcript. */
 function collectUsage(touched) {
   const drafts = [];
 

package/src/report.mjs

@@ -7,7 +7,7 @@
 
 import {
   bold, grey, cyan, green, red, yellow, write, rule, table, bar, sparkline,
-  compact, usd, duration, percent, width, DOT,
+  compact, perHour, times, duration, percent, width, DOT,
 } from './term.mjs';
 import { overview } from '../analytics/index.mjs';
 import { evaluate } from '../practices/engine.mjs';
@@ -15,7 +15,7 @@ import { nameFor } from '../collect/projects.mjs';
 
 export async function report(spec = '7d', { practices = true } = {}) {
   const data = await overview(spec);
-  const { headline, previousHeadline: before, score, metrics, cost } = data;
+  const { headline, previousHeadline: before, score, metrics } = data;
 
   write();
   write(`${bold('syndes')} ${grey(DOT)} ${data.range.label}`);
@@ -42,14 +42,16 @@ export async function report(spec = '7d', { practices = true } = {}) {
     [grey('prompts'), String(headline.prompts), delta(headline.prompts, before.prompts)],
     [grey('tool calls'), compact(headline.toolCalls), delta(headline.toolCalls, before.toolCalls)],
     [grey('active time'), duration(headline.activeMs), grey(`of ${duration(headline.wallMs)} open`)],
-    [grey('tokens'), compact(headline.tokens), grey(`${percent(headline.cacheHitRate)} from cache`)],
-    [grey('cost'), usd(headline.usd) + (cost.estimated ? grey('*') : ''), delta(headline.usd, before.usd, usd)],
+    [grey('tokens read'), compact(headline.tokens), grey(`${percent(headline.cacheHitRate)} from cache`)],
+    // No dollars. A Claude plan bills a month, so the scarce thing is the window
+    // and that is what these two measure. analytics/metrics/window.mjs says why.
+    [grey('new tokens'), compact(headline.fresh), grey(`${times(headline.cacheLeverage)} context reuse`)],
+    [grey('burn rate'), perHour(headline.freshPerHour), delta(headline.freshPerHour, before.freshPerHour, perHour)],
+    [grey('per prompt'), compact(headline.freshPerPrompt), grey(`${(headline.callsPerWindow ?? 0).toFixed(1)} calls per 100k`)],
     [grey('files changed'), String(headline.files), headline.commits ? grey(`${headline.commits} commits`) : ''],
     [grey('interruptions'), String(headline.blocks), headline.compacts ? grey(`${headline.compacts} compactions`) : ''],
   ], { align: ['left', 'right', 'left'] }).map((line) => `  ${line}`).join('\n'));
 
-  if (cost.estimated) write(grey(`  * priced from the ${cost.tableVersion} table by model family`));
-
   // ── Trend ─────────────────────────────────────────────────────────────────
   if (data.series.length > 1) {
     write();

package/src/term.mjs

@@ -291,9 +291,21 @@ export function compact(value) {
   return String(Math.round(value));
 }
 
-export function usd(value) {
+/**
+ * A per-hour rate, and a multiplier. Mirrors dashboard/web/ui.js so the terminal
+ * report and the dashboard never disagree about what "1.2M/h" means.
+ *
+ * An em dash for null, never 0: a rate we could not measure must not read as a
+ * rate of nothing. See analytics/metrics/window.mjs.
+ */
+export function perHour(value) {
+  if (value === null || value === undefined) return '—';
+  return `${compact(value)}/h`;
+}
+
+export function times(value, digits = 0) {
   if (value === null || value === undefined) return '—';
-  return value >= 100 ? `$${Math.round(value)}` : `$${value.toFixed(2)}`;
+  return `${value.toFixed(digits)}×`;
 }
 
 export function duration(ms) {

package/analytics/metrics/cost.mjs

@@ -1,83 +0,0 @@
-/**
- * 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;
-}