syndes 0.3.3 → 0.4.0

package/README.md

@@ -20,9 +20,9 @@ practice rules, the dashboard — is agent-agnostic, so adding another is one
 adapter, not a rewrite. `syndes sources` shows what it can see.
 
 **Records every move.** Every prompt, tool call, permission block, compaction,
-interrupt, token and dollar — appended to a hash-chained log that cannot be
-edited, re-ordered or back-dated without `syndes verify` naming the exact
-record where the chain breaks.
+interrupt and token — appended to a hash-chained log that cannot be edited,
+re-ordered or back-dated without `syndes verify` naming the exact record where
+the chain breaks.
 
 **Tells you how to work better.** A dozen practice rules run over that ledger and
 surface at most one nudge, at a moment that does not interrupt you, always with
@@ -36,11 +36,18 @@ repo or a synced folder, so you get the actual split: who used what, when, and
 which hours you spent competing for the same rate-limit window. Counts and
 tokens are shared; prompts, paths and commands never leave the machine.
 
-**Shows you the whole picture.** `syndes dashboard` opens a local
-dashboard: your efficiency score and its five pillars, token and cost
-breakdowns, cache hit rate, active time versus wall-clock, permission friction,
-tool mix, per-project history — every number clickable through to the records
-that produced it.
+**Shows you the whole picture, a day at a time.** `syndes dashboard` opens a
+local dashboard on today, with arrows and a day list to move: your efficiency
+score and its five pillars, active minutes hour by hour, cache hit rate, token
+volume and the rate your usage window is going at, permission friction, tool
+mix, per-project history — every number clickable through to the records that
+produced it. Widen to 7, 30 or 90 days when you want the trend instead.
+
+**No prices.** A Claude plan bills a month, so a per-token cost is a number
+nobody is charged, and SynDes does not invent one. What it measures instead is
+the usage window: new tokens per active hour, what one prompt costs in them, how
+much work each 100k buys, and how many times over your context was served from
+cache rather than re-sent.
 
 **No password to invent.** The dashboard opens straight from the command line;
 the link it prints carries a one-time key. If you want a lock, use the one your

package/analytics/index.mjs

@@ -7,10 +7,9 @@
  */
 
 import { rangeFor, previousRange, localDay } from './ranges.mjs';
-import { rollupsFor, mergeRollups } from './rollup.mjs';
+import { rollupsFor, mergeRollups, loadRollup, coveredDays } from './rollup.mjs';
 import { score } from './score.mjs';
-import { costOf, savingsFromCache } from './metrics/cost.mjs';
-import { loadConfig } from '../runtime/config.mjs';
+import { windowRates } from './metrics/window.mjs';
 import { nameFor, loadProjects } from '../collect/projects.mjs';
 import { readRange, height } from '../ledger/read.mjs';
 import { KIND } from '../ledger/schema.mjs';
@@ -20,14 +19,7 @@ export { rangeFor, previousRange, localDay };
 async function summarise(range) {
   const rollups = await rollupsFor(range);
   const merged = mergeRollups(rollups);
-  const prices = loadConfig().prices ?? {};
-  return {
-    range,
-    rollups,
-    merged,
-    cost: costOf(merged.tokens, prices),
-    cacheSavings: savingsFromCache(merged.tokens, prices),
-  };
+  return { range, rollups, merged, rates: windowRates(merged) };
 }
 
 /** Everything the overview screen needs, plus the same numbers one period back. */
@@ -56,18 +48,19 @@ export async function overview(spec = '7d') {
       // the single most useful thing to spot across a week.
       compacts: (rollup.metrics?.context?.autoCompacts ?? 0) + (rollup.metrics?.context?.manualCompacts ?? 0),
       sessions: (rollup.metrics?.volume?.sessions ?? []).length,
-      cost: 0,
     })),
     hours: current.merged.time.hours,
+    // Time, not event counts. This is what a single selected day is drawn from.
+    hourActiveMs: current.merged.time.hourActiveMs ?? new Array(24).fill(0),
     weekdays: current.merged.time.weekdays,
     metrics: current.merged,
-    cost: current.cost,
-    cacheSavings: current.cacheSavings,
+    rates: current.rates,
+    previousRates: previous.rates,
     ledger: height(),
   };
 }
 
-function headlineOf({ merged, cost }) {
+function headlineOf({ merged, rates }) {
   return {
     sessions: merged.volume.sessionCount,
     prompts: merged.prompts.count,
@@ -76,7 +69,13 @@ function headlineOf({ merged, cost }) {
     wallMs: merged.time.wallMs,
     tokens: merged.tokens.total,
     cacheHitRate: merged.tokens.cacheHitRate,
-    usd: cost.usd,
+    // No dollar figure. See analytics/metrics/window.mjs for why there is not one,
+    // and why these rates divide new tokens rather than the cache-read total.
+    fresh: rates.fresh,
+    freshPerHour: rates.freshPerHour,
+    freshPerPrompt: rates.freshPerPrompt,
+    callsPerWindow: rates.callsPerWindow,
+    cacheLeverage: rates.cacheLeverage,
     files: merged.volume.fileCount,
     commits: merged.volume.commits,
     compacts: merged.context.compacts,
@@ -161,6 +160,43 @@ export async function sessionDetail(sessionId) {
   return events;
 }
 
+/**
+ * Every local day the ledger covers, newest first — what a day picker offers.
+ *
+ * Reads the rollup cache and never folds anything. This answers a dropdown, and
+ * a dropdown must not be the thing that rebuilds a year of chain the first time
+ * somebody opens it.
+ *
+ * A day with no rollup written yet reports `records: null`, not 0. The picker
+ * shows "not counted yet" differently from a day that was genuinely quiet —
+ * conflating the two would tell someone their work was not recorded.
+ *
+ * Today is always listed even before it has a segment, because "show me today"
+ * must be offered on a morning where nothing has happened yet.
+ */
+export function dayIndex({ limit = 180 } = {}) {
+  const today = localDay(Date.now());
+  const days = coveredDays().filter((day) => day <= today);
+  if (!days.includes(today)) days.push(today);
+
+  return days.slice(-limit).reverse().map((day) => {
+    // Any version, because the record count survives a fold changing shape and
+    // the picker would otherwise go blank for every day after an upgrade. The
+    // metrics behind it are only read when the cache is current.
+    const rollup = loadRollup(day, { anyVersion: true });
+    const current = rollup && !rollup.stale;
+    return {
+      day,
+      records: rollup ? rollup.records : null,
+      activeMs: current ? rollup.metrics?.time?.activeMs ?? 0 : null,
+      tokens: current ? totalTokens(rollup.metrics?.tokens) : null,
+      prompts: current ? rollup.metrics?.prompts?.count ?? 0 : null,
+      final: rollup ? Boolean(rollup.final) : false,
+      stale: Boolean(rollup?.stale),
+    };
+  });
+}
+
 export async function byProject(spec = '30d') {
   const range = rangeFor(spec);
   const buckets = new Map();

package/analytics/metrics/time.mjs

@@ -3,8 +3,15 @@
  *
  * 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
+ * downstream ratio — tokens per hour, tools per hour, the whole efficiency
  * story — a lie in the user's favour.
+ *
+ * Two hour-of-day series, because they answer different questions. `hours`
+ * counts records, which is what the team contention grid compares across
+ * machines. `hourActiveMs` is time, which is what a single day's shape is
+ * actually made of — twelve events in an hour is not the same as twelve minutes
+ * of work, and a day view drawn from event counts reports a busy minute as a
+ * busy hour.
  */
 
 import { KIND } from '../../ledger/schema.mjs';
@@ -14,6 +21,7 @@ export const name = 'time';
 export function create() {
   return {
     hours: new Array(24).fill(0),
+    hourActiveMs: new Array(24).fill(0),
     weekdays: new Array(7).fill(0),
     activeMs: 0,
     firstAt: null,
@@ -37,7 +45,10 @@ export function add(state, record, ctx) {
   const previous = state.lastBySession.get(session);
   if (previous !== undefined) {
     const gap = ts - previous;
-    if (gap > 0 && gap <= ctx.idleGapMs) state.activeMs += gap;
+    if (gap > 0 && gap <= ctx.idleGapMs) {
+      state.activeMs += gap;
+      chargeHours(state.hourActiveMs, previous, ts);
+    }
   }
   state.lastBySession.set(session, ts);
 
@@ -59,6 +70,7 @@ export function done(state) {
 
   return {
     hours: state.hours,
+    hourActiveMs: state.hourActiveMs,
     weekdays: state.weekdays,
     activeMs: state.activeMs,
     wallMs,
@@ -70,6 +82,7 @@ export function done(state) {
 
 export function merge(parts) {
   const hours = new Array(24).fill(0);
+  const hourActiveMs = new Array(24).fill(0);
   const weekdays = new Array(7).fill(0);
   let activeMs = 0;
   let wallMs = 0;
@@ -79,6 +92,7 @@ export function merge(parts) {
 
   for (const part of parts) {
     (part.hours ?? []).forEach((value, index) => { hours[index] += value; });
+    (part.hourActiveMs ?? []).forEach((value, index) => { hourActiveMs[index] += value; });
     (part.weekdays ?? []).forEach((value, index) => { weekdays[index] += value; });
     activeMs += part.activeMs ?? 0;
     wallMs += part.wallMs ?? 0;
@@ -88,7 +102,7 @@ export function merge(parts) {
   }
 
   return {
-    hours, weekdays, activeMs, wallMs, firstAt, lastAt,
+    hours, hourActiveMs, 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,
@@ -96,6 +110,29 @@ export function merge(parts) {
   };
 }
 
+/**
+ * Charge one active gap to the hours it actually crosses.
+ *
+ * A twenty-minute gap starting at 10:55 is five minutes of the 10:00 hour and
+ * fifteen of the 11:00 one. Charging the whole gap to the hour it ended in would
+ * bend a day's shape around where the clock happened to fall, and the hourly
+ * chart exists precisely to show that shape.
+ *
+ * Calendar arithmetic on the hour boundary, so the 23:00 hour rolls into the
+ * next day rather than overflowing an index.
+ */
+function chargeHours(hourActiveMs, from, to) {
+  let cursor = from;
+  while (cursor < to) {
+    const date = new Date(cursor);
+    const hour = date.getHours();
+    const boundary = new Date(date.getFullYear(), date.getMonth(), date.getDate(), hour + 1).getTime();
+    const until = Math.min(to, boundary);
+    hourActiveMs[hour] += until - cursor;
+    cursor = until;
+  }
+}
+
 function median(values) {
   if (!values.length) return null;
   const sorted = [...values].sort((a, b) => a - b);

package/analytics/metrics/window.mjs

@@ -0,0 +1,94 @@
+/**
+ * What the usage window is being spent at, and how much work each window buys.
+ *
+ * This module exists because the one it replaced did not earn its place. SynDes
+ * used to price tokens from an API rate card and print a dollar figure beside
+ * the real counts. Nobody on a Claude subscription is charged that number — the
+ * plan bills a month, not a token — so the figure was a confident invention
+ * sitting next to measurements, and a reader who catches one made-up number
+ * stops trusting the counts beside it.
+ *
+ * The scarce resource on a subscription is the usage window, so that is what
+ * gets measured: how fast it empties, what a single ask costs in it, and how much
+ * work came out of it. All three move when you change your context, your
+ * batching or your prompts, which is the bar every metric here has to clear.
+ *
+ * ## Why "new" tokens and not all of them
+ *
+ * Cache reads are the overwhelming majority of a token total — typically 97–99%
+ * of it, because a stable prefix is re-read on every turn. A rate computed over
+ * the total is therefore a rate of cache reads wearing a different name: it
+ * reads in tens of millions per hour, moves with conversation length rather than
+ * with anything the user did, and is unusable as a headline.
+ *
+ * So every rate here divides NEW tokens — input + output + cache writes. Those
+ * are the tokens that had to be produced or sent for the first time. The cache
+ * reads are not discarded; they are already reported as the cache hit rate,
+ * which is the honest place for them, and the total still appears as volume.
+ *
+ * Rates, never totals. A rate compares across a day, a week, and somebody else's
+ * machine; a total only says who worked longer.
+ */
+
+export const name = 'window';
+
+const HOUR_MS = 3_600_000;
+/** A rate over less measured work than this is noise wearing a decimal point. */
+const MIN_ACTIVE_MS = 3 * 60_000;
+/** The unit work is measured against. ~100k new tokens is about one full window. */
+export const WINDOW_TOKENS = 100_000;
+
+/** New tokens: produced or sent for the first time. Cache reads are not new. */
+export function freshTokensOf(tokenSummary) {
+  if (!tokenSummary) return 0;
+  return (tokenSummary.input ?? 0) + (tokenSummary.output ?? 0) + (tokenSummary.cacheWrite ?? 0);
+}
+
+/**
+ * Rates from raw totals — for a pool, which is summed across people rather than
+ * folded from records.
+ *
+ * Every rate is `null` rather than 0 when its denominator is missing. "We could
+ * not measure this" and "you burned nothing" are different answers, and a figure
+ * that renders them the same is the quiet kind of lie: an idle morning would
+ * read as perfect efficiency.
+ */
+export function ratesFromTotals({ fresh = 0, tokens = 0, activeMs = 0, calls = 0, prompts = 0 } = {}) {
+  const hours = activeMs / HOUR_MS;
+  const windows = fresh / WINDOW_TOKENS;
+  const measurable = activeMs >= MIN_ACTIVE_MS && fresh > 0;
+
+  return {
+    activeMs,
+    tokens,
+    fresh,
+    /** How fast the window empties while you are actually working. */
+    freshPerHour: measurable ? fresh / hours : null,
+    /** What one ask costs. Rises as a conversation accumulates context. */
+    freshPerPrompt: prompts ? fresh / prompts : null,
+    /** How much work a window buys. Low means tokens went to context, not work. */
+    callsPerWindow: windows ? calls / windows : null,
+    /** How many times over the context was served from cache rather than re-sent. */
+    cacheLeverage: fresh ? tokens / fresh : null,
+  };
+}
+
+/**
+ * @param {object} merged  from rollup.mergeRollups()
+ * @returns {{activeMs, tokens, fresh, freshPerHour, freshPerPrompt, callsPerWindow, cacheLeverage}}
+ */
+export function windowRates(merged) {
+  return ratesFromTotals({
+    fresh: freshTokensOf(merged?.tokens),
+    tokens: merged?.tokens?.total ?? 0,
+    activeMs: merged?.time?.activeMs ?? 0,
+    calls: merged?.tools?.calls ?? 0,
+    prompts: merged?.prompts?.count ?? 0,
+  });
+}
+
+/** This is a derived view, not a fold: it reads a merged summary and keeps nothing. */
+export function create() { return {}; }
+export function add() {}
+export function done() { return {}; }
+export function merge() { return {}; }

package/analytics/rollup.mjs

@@ -29,7 +29,7 @@ import * as prompts from './metrics/prompts.mjs';
 export const METRICS = [volume, time, tokens, tools, context, friction, rework, prompts];
 
 /** Bumped whenever a fold changes shape, so stale caches rebuild themselves. */
-export const ROLLUP_VERSION = 1;
+export const ROLLUP_VERSION = 2;
 
 export async function buildDay(day) {
   const config = loadConfig();
@@ -65,12 +65,27 @@ export async function buildDay(day) {
   };
 }
 
-export function loadRollup(day) {
+/**
+ * A cached rollup, or null.
+ *
+ * A version mismatch is a miss, because the metric shapes inside may have
+ * changed and reading them as if they had not is how a chart ends up drawing a
+ * field that moved.
+ *
+ * `anyVersion` is the exception, and it is narrow: the ENVELOPE — day, records,
+ * final — has never changed shape and cannot, since those fields are what the
+ * cache is keyed and invalidated on. A caller that only needs "did this day have
+ * anything in it" can have that answer across an upgrade instead of being told
+ * "not counted yet" about every day in the picker until the worker catches up.
+ * Such a rollup is flagged `stale`, so nothing can read its metrics by accident.
+ */
+export function loadRollup(day, { anyVersion = false } = {}) {
   const file = rollupFile(day);
   if (!existsSync(file)) return null;
   try {
     const rollup = JSON.parse(readFileSync(file, 'utf8'));
-    return rollup.version === ROLLUP_VERSION ? rollup : null;
+    if (rollup.version === ROLLUP_VERSION) return rollup;
+    return anyVersion ? { ...rollup, stale: true } : null;
   } catch {
     return null;
   }

package/analytics/team.mjs

@@ -2,11 +2,12 @@
  * The shared-account view: who used how much, and when you were in each
  * other's way.
  *
- * The headline number here is deliberately NOT dollars. On a shared plan there
- * is no per-token bill to split — the scarce thing is the usage window, and two
- * people working the same hour throttle each other in a way neither of them can
- * see from their own machine. So this module computes share, and it computes
- * contention, and it treats cost as the secondary figure it actually is.
+ * There is no dollar figure here, and there is not one anywhere else either. On
+ * a shared plan there is no per-token bill to split — the scarce thing is the
+ * usage window, and two people working the same hour throttle each other in a
+ * way neither of them can see from their own machine. So this module computes
+ * share, and it computes contention, and the secondary figure is the rate the
+ * shared window is being spent at (analytics/metrics/window.mjs).
  *
  * Everything is derived from sanitised peer rollups (sync/share.mjs), which
  * carry counts and no content. Nothing here reads a peer's records, because
@@ -15,15 +16,23 @@
 
 import { rangeFor, previousRange } from './ranges.mjs';
 import { mergeRollups, METRICS } from './rollup.mjs';
-import { costOf } from './metrics/cost.mjs';
+import { ratesFromTotals, freshTokensOf } from './metrics/window.mjs';
 import { score } from './score.mjs';
 import { readPool, loadState, teamConfig, isEnabled, poolRoot } from '../sync/index.mjs';
 import { identity, initialsOf } from '../runtime/identity.mjs';
-import { loadConfig } from '../runtime/config.mjs';
 
 /** Three-hour bands: eight rows is a grid you can read, twenty-four is a wall. */
 const BAND_HOURS = 3;
 const BANDS = 24 / BAND_HOURS;
+/**
+ * One selected day gets hourly resolution.
+ *
+ * A single day at three-hour bands is eight dots in one column — technically the
+ * same chart, practically unreadable, and it throws away the only axis a day
+ * view has. At one-hour bands the day has twenty-four cells to spread across,
+ * which is what makes "we were both on it at four" visible.
+ */
+const DAY_BAND_HOURS = 1;
 /** Beyond this the grid stops being a picture and starts being a spreadsheet. */
 const MAX_GRID_DAYS = 14;
 
@@ -34,7 +43,6 @@ const MAX_GRID_DAYS = 14;
 export async function team(spec = '7d') {
   const range = rangeFor(spec);
   const before = previousRange(range);
-  const prices = loadConfig().prices ?? {};
   const me = identity();
 
   const enabled = isEnabled();
@@ -76,8 +84,15 @@ export async function team(spec = '7d') {
         wallMs: merged.time.wallMs ?? 0,
         compacts: merged.context.compacts ?? 0,
         blocks: merged.friction.blocks ?? 0,
-        usd: costOf(merged.tokens, prices).usd,
+        fresh: freshTokensOf(merged.tokens),
       },
+      rates: ratesFromTotals({
+        fresh: freshTokensOf(merged.tokens),
+        tokens,
+        activeMs: merged.time.activeMs ?? 0,
+        calls: merged.tools.calls ?? 0,
+        prompts: merged.prompts.count ?? 0,
+      }),
       previousTokens: totalTokens(mergedBefore.tokens),
       // A peer sharing at `summary` still has every pillar the score reads,
       // because the score never needed a path or a session id.
@@ -121,37 +136,58 @@ export async function team(spec = '7d') {
     peers,
     totals: {
       tokens: poolTokens,
-      usd: peers.reduce((sum, peer) => sum + peer.totals.usd, 0),
-      prompts: peers.reduce((sum, peer) => sum + peer.totals.prompts, 0),
-      toolCalls: peers.reduce((sum, peer) => sum + peer.totals.toolCalls, 0),
-      activeMs: peers.reduce((sum, peer) => sum + peer.totals.activeMs, 0),
-      sessions: peers.reduce((sum, peer) => sum + peer.totals.sessions, 0),
+      fresh: sum(peers, (peer) => peer.totals.fresh),
+      prompts: sum(peers, (peer) => peer.totals.prompts),
+      toolCalls: sum(peers, (peer) => peer.totals.toolCalls),
+      activeMs: sum(peers, (peer) => peer.totals.activeMs),
+      sessions: sum(peers, (peer) => peer.totals.sessions),
       people: peers.length,
       deltaTokens: poolBefore ? poolTokens - poolBefore : null,
     },
+    // The rate the SHARED window is being spent at. Summed across people rather
+    // than folded, which is why it goes through ratesFromTotals and not
+    // windowRates — there is no one merged rollup for a pool to read.
+    rates: ratesFromTotals({
+      fresh: sum(peers, (peer) => peer.totals.fresh),
+      tokens: poolTokens,
+      activeMs: sum(peers, (peer) => peer.totals.activeMs),
+      calls: sum(peers, (peer) => peer.totals.toolCalls),
+      prompts: sum(peers, (peer) => peer.totals.prompts),
+    }),
     grid: contentionGrid(peers, range.days),
     lanes: laneRows(peers, range.days),
   };
 }
 
+function sum(items, pick) {
+  return items.reduce((total, item) => total + (pick(item) ?? 0), 0);
+}
+
 /**
  * The contention grid — the one picture that answers "were we in each other's
  * way".
  *
- * Each cell is a three-hour band of one day. Size carries volume; colour carries
- * how many people were working in it, which on a shared plan is the thing that
- * actually costs you: one person alone gets the whole window, two people split
- * it and both get throttled. Colour is therefore load-bearing here in exactly
- * the way the palette intends — orange means look at this, and it means it
- * because that band is where your limits were being spent twice.
+ * Each cell is a band of one day — three hours across a range, one hour when a
+ * single day is selected. Size carries volume; colour carries how many people
+ * were working in it, which on a shared plan is the thing that actually costs
+ * you: one person alone gets the whole window, two people split it and both get
+ * throttled. Colour is therefore load-bearing here in exactly the way the
+ * palette intends — orange means look at this, and it means it because that band
+ * is where your limits were being spent twice.
+ *
+ * `byDevice` is kept per cell rather than reduced to a count, because a one-day
+ * view draws a lane per person out of it and the count alone cannot say WHO.
  */
 function contentionGrid(peers, days) {
   const window = days.slice(-MAX_GRID_DAYS);
+  const hourly = window.length === 1;
+  const bandHours = hourly ? DAY_BAND_HOURS : BAND_HOURS;
+  const bands = 24 / bandHours;
   const cells = [];
   let peak = 0;
 
   for (const day of window) {
-    for (let band = 0; band < BANDS; band += 1) {
+    for (let band = 0; band < bands; band += 1) {
       const byDevice = {};
       let total = 0;
 
@@ -159,7 +195,7 @@ function contentionGrid(peers, days) {
         const entry = peer.series.find((point) => point.day === day);
         if (!entry) continue;
         let count = 0;
-        for (let hour = band * BAND_HOURS; hour < (band + 1) * BAND_HOURS; hour += 1) {
+        for (let hour = band * bandHours; hour < (band + 1) * bandHours; hour += 1) {
           count += entry.hours[hour] ?? 0;
         }
         if (count > 0) byDevice[peer.deviceId] = count;
@@ -170,7 +206,7 @@ function contentionGrid(peers, days) {
       cells.push({
         day,
         band,
-        hour: band * BAND_HOURS,
+        hour: band * bandHours,
         total,
         people: Object.keys(byDevice).length,
         byDevice,
@@ -181,8 +217,16 @@ function contentionGrid(peers, days) {
   const overlapping = cells.filter((cell) => cell.people > 1);
   return {
     days: window,
-    bands: BANDS,
-    bandHours: BAND_HOURS,
+    bands,
+    bandHours,
+    // The chart draws a different picture for one day than for a range, and it
+    // should not have to infer which from the length of an array.
+    hourly,
+    // So a one-day lane chart can label its rows without being handed the peers
+    // a second time. Ordered as the peers are: biggest share first.
+    people: peers.map((peer) => ({
+      deviceId: peer.deviceId, name: peer.name, initials: peer.initials, isMe: peer.isMe,
+    })),
     cells,
     peak,
     overlapBands: overlapping.length,

package/bin/cli.mjs

@@ -17,7 +17,7 @@ import {
 } from '../runtime/paths.mjs';
 import {
   bold, grey, cyan, green, red, yellow, write, rule, table, OK, FAIL, WARN, DOT,
-  confirm, compact, usd, duration, percent, bar, width, ask, pad, spinner, banner, beat, stream,
+  confirm, compact, perHour, duration, percent, bar, width, ask, pad, spinner, banner, beat, stream,
 } from '../src/term.mjs';
 import { install } from '../src/install.mjs';
 import { runBriefing, showBriefingIfPending, clearPending } from '../src/briefing.mjs';
@@ -292,7 +292,7 @@ async function cmdStatus() {
   write(table([
     [grey('prompts'), String(today.prompts), grey('tool calls'), compact(today.toolCalls)],
     [grey('active'), duration(today.activeMs), grey('tokens'), compact(today.tokens)],
-    [grey('files'), String(today.files), grey('cost'), usd(today.usd)],
+    [grey('files'), String(today.files), grey('burn'), perHour(today.freshPerHour)],
   ], { align: ['left', 'right', 'left', 'right'] }).map((line) => `  ${line}`).join('\n'));
 
   write();

package/collect/transcript.mjs

@@ -1,7 +1,7 @@
 /**
  * Incremental transcript tail → token usage, model, cache hits, turn shape.
  *
- * Tokens, cost and cache efficiency are not in the hook payload; they are in the
+ * Tokens and cache efficiency are not in the hook payload; they are in the
  * session transcript JSONL that `transcript_path` points at. Reading it whole on
  * every event would be quadratic over a long session, so a byte offset per
  * session is kept and only the new tail is parsed.

package/dashboard/api/index.mjs

@@ -102,6 +102,17 @@ export async function projects({ url }) {
   return { data: await analytics.byProject(url.searchParams.get('range') ?? '30d') };
 }
 
+/**
+ * The days the day picker offers.
+ *
+ * Cheap by construction: it reads the rollup cache and folds nothing, because a
+ * dropdown must never be the thing that rebuilds a year of chain.
+ */
+export async function days({ url }) {
+  const limit = Math.min(Number(url.searchParams.get('limit') ?? 180), 740);
+  return { data: { days: analytics.dayIndex({ limit }), today: analytics.localDay(Date.now()) } };
+}
+
 export async function timeline({ url }) {
   const range = analytics.rangeFor(url.searchParams.get('range') ?? '7d');
   const limit = Math.min(Number(url.searchParams.get('limit') ?? 3000), 20_000);

package/dashboard/router.mjs

@@ -29,6 +29,7 @@ export const ROUTES = {
   'GET /api/session': api.sessionDetail,
   'GET /api/tools': api.tools,
   'GET /api/projects': api.projects,
+  'GET /api/days': api.days,
   'GET /api/timeline': api.timeline,
   'GET /api/practices': api.practices,
   'POST /api/practices': api.practiceAction,

package/dashboard/web/api.js

@@ -65,6 +65,7 @@ export const api = {
   session: (id) => get(`/api/session?id=${encodeURIComponent(id)}`),
   tools: (range) => get(`/api/tools?range=${encodeURIComponent(range)}`),
   projects: (range) => get(`/api/projects?range=${encodeURIComponent(range)}`),
+  days: () => get('/api/days'),
   timeline: (range) => get(`/api/timeline?range=${encodeURIComponent(range)}`),
 
   practices: () => get('/api/practices'),

package/dashboard/web/app.css

@@ -191,6 +191,37 @@ a { color: inherit; text-decoration: none; }
 .dropdown[aria-expanded="true"] svg { transform: rotate(180deg); }
 .dropdown[aria-expanded="true"] { background: var(--surface-3); }
 
+/* ── Day stepper ──────────────────────────────────────────────────────── */
+
+/* One control, not three. The arrows and the dropdown share a single capsule so
+   the group reads as the day picker it is, rather than as two buttons that
+   happen to sit either side of a menu. The inner dropdown drops its own pill
+   background for the same reason. */
+.stepper {
+  display: inline-flex;
+  align-items: center;
+  gap: 2px;
+  padding: 0 4px;
+  height: 44px;
+  border-radius: var(--r-pill);
+  background: var(--surface);
+}
+.stepper .dropdown { background: transparent; padding: 0 var(--s2); }
+.stepper .dropdown:hover { background: var(--surface-3); }
+
+.stepper__btn {
+  width: 32px; height: 32px;
+  border: 0; border-radius: var(--r-pill);
+  background: transparent; color: var(--ink-2);
+  display: grid; place-items: center;
+  cursor: pointer; flex: none;
+}
+.stepper__btn:hover { background: var(--surface-3); color: var(--ink); }
+.stepper__btn svg { display: block; }
+/* Disabled rather than removed: a control that vanishes reflows the row under
+   the pointer, and the dimmed arrow is what says "this is today". */
+.stepper__btn:disabled { opacity: 0.3; cursor: default; background: transparent; }
+
 .dropdown__menu {
   position: fixed;
   z-index: 60;