rvlib-shipkit 2.2.0 → 2.3.0

package/CHANGELOG.md

@@ -1,3 +1,41 @@
+## 2.3.0
+
+- **A sound is a review view.** `sk review add --audio <sound>`, a sound in `--view`, `add-view <id> "<label>" --audio <sound>`, or a before and after of two sounds: the store keeps the sound and draws its waveform (`wave.png`, `before-wave.png`), and the hub shows each waveform over a player, one row a side. A sound takes reactions and words, never a rectangle; a pair is never a sound and an image.
+- **The hub's review page draws the repo's parts, and embeds in another tool.** The answer column shows the item's data view (its kind's facts, links, a text or a line diff, a live frame he opens) and offers a pair's animation (cut, fade or wipe; mp4 or gif; labels en, fr or none). With a dispatcher, « board » lists the raised items by state, each topic and worker, a stale claim marked, and who holds the role. `<base>/embed/?page=review` (or `trailer`) serves the page alone, bundled once a process with relative asset paths, so a proxy can frame it under its own origin and a prefix; the same origin guard honours `x-forwarded-host`; the page posts `{ shipkit: 'route', page, hash }` to its parent and moves on `{ shipkit: 'go', hash }`.
+- **`review({...})` carries what only one repo knows.** A kind's `flags` and `parse` turn `sk review add --subject place --where z:1,2` into its subject and topic; the unit's `flags`, `add` and `addView` hooks check and fill a card before it is written; `live: { frames, stop }` makes `sk review add --wip --live <name>` a draft card on the repo's live shot, stopped by `ready`; `verbs` adds the repo's own `sk review <verb>`.
+- **`review({...})`: a repo's parts of the review store, in one unit.** Any `<name>.shipkit.ts` may default-export `review({ kinds, topics, dispatcher, sources, auto, anim })` (`rvlib-shipkit/src/shipkit-files.ts`). A kind declares its label and icon, and on the server its `key` (what names one subject), `near` (two subjects of one topic close enough to be one card), `problems` (what is wrong with a subject), and its data view (`facts`, `links`, `live`, `text`), which the hub fetches from `GET /api/review/<id>/view`. When a unit declares kinds or topics, `add`, `raise` and every read refuse others (`shot`, `screen` and `frame` always pass). The unit file is found by a walk cached on the walked dirs' times and a text test, never by importing every unit file.
+- **`sk review`: the dispatcher, the workers and every generic verb.** `dispatcher --as <name> [--take]` (one holder, 30 minutes idle before another takes it), `dispatch`, `ask`, `drop`, `reassign`, `next <topic> | --lane <lane>`, `blocked`, `done`, `topics`, `board`, `ready`, `delete` (a player's test report at its source and here), `marks`, `anim` (a pair as a looping cut, fade or wipe, mp4 or gif, cached), `auto` and `auto run <id> [--dry]`. `inbox` and `watch` list the items nobody takes (2 minutes after the last message, then every 2 hours); `inbox`, `board`, `next` and `watch` pull the unit's sources first; `show` and `seen` take a report's ref (`live#3`). Without a dispatcher in the unit, a worker claims a new item as it is. Routes `POST /api/review/raise` and `/api/review/rate` raise an owner's note and his mark from any tool.
+- **`sk review` answers in about 0.15 s on a 3318 item store.** Its threads index their links once per list (420 ms of lookups became 21), the store stamps two directories an item, and the index is its own file, `.review-index.shipkit.json`, so a second code reading the store no longer throws it away.
+
+- **`sk trailer`: a score composed in the `.trailer` file, rendered offline in Bun.** The header reads `score tempo <bpm> [meter] [grid] [reverb <s> <mix>] [fade-in] [volume]`, `track <name> <instrument> [volume]` (up to 16), `drums <letter>=<instrument> …` and a `code` block of TypeScript; a section reads `play <track> <expression>` (a quoted string is a melody, `play *` a record of tracks, deeper lines continue it), `drums`, `mark`, and `stop at <time>`, which cuts the score and its reverb dead so a sound after it plays alone. The syntax is pkm-multi's, verbatim, `stop` added. The compose helpers are in scope (`mel`, `arp`, `bass`, `voice`, `chart`, `rep`, `seq`, `transpose`, `rest`, `parseChord`, `midiToNote`, `INST`, `KIT`, `additive`), and with no `export const instruments` the score plays the default palette, now with `sub` and `clap`. `sk trailer check` compiles the score in about 0.1 s, every error at its line (a play of the wrong length in bars, an unknown instrument or token, the TypeScript failing). The synth (`src/trailer/score/synth.ts`) renders every note as the browser synth the language comes from does (band limited tables softened per pitch band, ADSR, biquad, unison, vibrato, sweep, glide, pan), through a convolution room and the master chain (compressor, limiter, soft ceiling), in Bun with no browser: about 0.25 s for 9 s of music, cached on its notes and the synth's code. The build mixes it under the voices and sfx, ducked by `duck`, prints each section's RMS and peak, and refuses a section whose notes make no sound. New verb `sk trailer score [file]`: the score alone as `out/<cut>.score.wav` and `out/<cut>.score.png` (the waveform over the spectrum, a line at each section and the stop), with the integrated loudness.
+
+- **`sk time`: where the agents' time went, from every Claude Code transcript on the machine.** Every config root (`~/.claude`, `~/.claude-<name>`), sub-agent runs included, read into one index, `~/.shipkit/agent-time.sqlite`: a file is read again only when it changed, a live session only from where the last read stopped, and a session copied into a second account counts once (a tool use id is unique). The index keeps the sessions Claude Code prunes. The first build read 65 GB in about 70 s, niced, resumable, one progress line; a warm query answers in about 0.2 s for a week of a busy repo, under 1 s for all of it. The summary opens on what costs the most, each line a measured total with its cause: file edits through Bash (`python3 (edit)`, `sed -i (edit)`, `cat > (write)`) against the Edit tool's p50, failed runs and their reruns, polling loops and their timeouts, the auto mode classifier (cheap commands it checked against the same commands a rule allowed, an estimate), and the calls that waited for a human allow. Then the wall cut once per moment (model, tools, a human allow, sub-agent wait, background wait, waiting on the human, idle left out), the commands grouped by shape (`git commit`, `bun test <file>`, `sk ci --only lint`, `(until) grep`) with calls, total, p50, p95 and max, and the human's prompts with three signals by rule (status ping, slowness, correction), each joined to the longest calls of the 10 minutes before. Views `commands`, `tools`, `slow`, `fails`, `feedback`, `sessions`; `--since`, `--all`, repo paths, `--top`, `--json`. Commands and prompts print through the leak guard's keyword lists and token shapes.
+- **One transcript reader for `sk reflect` and `sk time`** (`src/reflect/transcript.ts`): a line in, its events out (a typed or queued prompt, a wake, a tool use, its result with how it ended and how it was allowed, a reply). `sk reflect` keeps the same prompts as before, now through it, and skips the `api-request` lines (most of a transcript's bytes) before parsing them.
+
+- **`sk time` shows turn count, what makes agents slow when no command is.** Every call costs a model turn before it. The summary gives, for the main sessions and for the sub-agents, the model time before each call, the share of single read calls and the share sent in parallel. The sub-agent lines lead with a verdict (turn count or command speed, with a fix line when reads pile up one per turn), then their work split (model, tools, their own waits), run length p50 and p90, and calls per run. The `turns` view lists the runs that worked longest with their turns, read and parallel shares and model per turn, then the read shapes by the model time of the turns that issued them. A read is Read, Grep, Glob, or a Bash command of a read shape whose every part reads (a redirect to a file, `sed -i`, `find -delete` or `-exec`, `tee`, or a second command that writes or runs makes it not one), judged when a call is indexed and again when the rules change (`src/agent-time/turns.ts`). A call is parallel when it starts while the previous call still runs, within 2 s of its start. The model stretch before a call comes from the same sweep that cuts the wall. pkm-multi, every recorded session: sub-agents worked 905.4h, model 67%, 7.7 s of model before each of 283,821 calls, 51% single reads, 2.3% in parallel.
+- **A message relayed into a sub-agent ends its park.** The harness writes "The coordinator sent a message while you were working" (or the user, or another session) into a sub-agent as an `isMeta` user entry with no peer origin, which the transcript reader dropped, so a sub-agent that handed back and sat for hours until someone wrote to it counted those hours as model: 352h of pkm-multi's sub-agent time. It is now a `message` event that counts as a prompt (idle past 30 minutes). The index version moves to 6, so every file is read again once.
+
+## Unreleased (patch)
+
+- **The rail's icons come in three sizes.** Folded, the list's foot shows an S, M or L button: 18, 24 or 32px icons, the rail 44, 50 or 58px wide to fit, kept per browser (`hub:rail-icon`). M is the default.
+- **The project list folds to an icon rail.** ⌘B, the fold button at the list's foot, or a drag of its separator below the list's min folds it to 44px of icons: the names, the ⌘ hints and the step hint hide, a badge rides its icon's corner, the hover card still names the row. A drag out or ⌘B again unfolds it to its kept width; the fold is kept per browser (`hub:list-rail`). The dock moves to ⌘⇧B.
+- **⌘; opens the insights**, its filter focused, so a package name is one key and a word away.
+- **↑ ↓ walk every section again, review and trailer included.** Their pages claim the arrows for their cards and shots, so a walk down from the readme stopped on review. The arrows now stay the tree's while its cursor walks it, and a click in the page hands them back to the page (`RepoSt.pageKey`, `TreeSvc.leave`).
+- **A light theme.** The button at the project list's foot cycles dark, light and auto (the system's), kept per browser. Every colour of the hub was already a token, so the light theme is a second token block (`:root[data-theme=light]`) and the guard fails a token it leaves out. A repo's name and mark use its colorLight on a light page, its colorDark on a dark one, everywhere: the list, the strip, the header, the dock, the plan.
+- **The review page places the card against its answer: `top`, `left` or `auto`.** A switch on the card's top bar, kept with the review prefs. `top` stacks the card over the answer in one column, its boundary dragged; `left` keeps them side by side; `auto` stacks when the page is narrower than 900px (`STACK_PX`), measured on the page itself, so the project list and the sidebar count.
+- **The review list narrows to 160px** (it stopped at 220). Under 250px a card puts its title on top, a 40px image under it beside the badges, the filters one a line. A thread's fold is the tree's chevron in a round 24px button, rotating as it opens, instead of a tiny ▾.
+- **A repo's sidebar narrows to 150px** (it stopped at 220). Under 200px its ⌥ key hints and the filter's a, n, r letters hide, so the section names keep the room.
+- **A repo's review and trailer sections sit right under the readme**, before contracts, and the review row wears its own pink hue (`--review`) so it reads at a glance.
+- **One select shape across the hub.** Every native `select` and every segmented bar (the activity and insights pickers, the severity filter, the review and trailer bars) is one 22px pill with the live segment on the selection wash; the activity page's own `.acwin` bar is gone, merged into `.seg`.
+
+- **`sk trailer`: a section that plays after the score's `stop` is an error at its play.** Its notes were never rendered, and the build then refused the measured silence as a volume 0. A section after the stop with no play stays legal. The synth's soft ceiling now clamps its input first, as a browser wave shaper does, so an overdriven score peaks where the browser's does (-0.7 dBFS), and the hot guard reads that ceiling.
+
+- **`sk trailer`: the final mix is held under -1 dBTP, and the build says its loudness.** The mix's limiter ran with alimiter's default auto level, which lifts the output back to 0 dBFS, and it limited sample peaks only: a cut measured +0.4 dBTP. It now limits at 4 times the sample rate with auto level off, and a mix whose aac encode still overshoots (a limited square wave rang 2.1 dB past the limit) is made again that much lower. `sk trailer` prints the integrated LUFS and true peak of the score and of the final mix, warns past -1 dBTP, and fails past 0 dBTP.
+
+- **`sk trailer`: a word that opens on a single quote fails at its line.** The language quotes with double quotes only, so `film take 'clip=walk&cam=low'` handed the project CLI a word with the quotes inside it, and the film took a wrong key without a word. The error names the double quoted form to write. A tokenizer error on a film line no longer adds "films nothing" for its shot.
+
+- **`sk time` books a wait on a sub-agent as background wait, never as model time.** A sub-agent hand-back or another session's message reaches the session as a user entry flagged `isMeta` (`turnOrigin: 'peer'`), which the transcript reader skipped, so the gap before it counted as model thinking: pkm-multi showed model 35% where it is 14%, and background wait 34% where it is 55%. The index version moves to 5, so every file is read again once (about 70 s).
+
 ## 2.2.0
 
 - **The project CLI kit, `rvlib-shipkit/cli-kit`, and a project CLI from `sk start`.** A repo's own CLI is `runProjectCli({ name, root, families })`: the first word loads only its family, the bare listing prints one line per command (0.027 s on a fresh repo), and every run is logged to `.shipkit/logs/<cli>-calls.jsonl`. A command over code that exists is a row, `verbs([{ path, category, description, examples, run: { bun } | { cmd } | { tool, cold } }])`, never a second implementation. A row marked `essential` lands on the everyday page, and a row marked `film: 'still' | 'clip'` takes `--out` (resolved against the caller's cwd), a clip also `--seconds`, and fails when it exits 0 without writing `--out`. The kit adds `<cli> commands` (`--out` and `--essentials` write the agent pages, `--check` fails on a stale page or a row with no category, a long description or no example starting with its words, `--json` is the registry for other tools) and `<cli> calls`. `sk start` writes the skeleton on day one: `src/cli.ts`, `src/cli/cmd_Dev.ts` with a dev row and a commented shot row, both agent pages generated, the agent index loading the essentials page, package.json `cli` and a `bin` of the repo name. `sk start <name> --cli` writes it into a repo with history, and refuses one that already has a CLI. The scaffold tsconfig names `types: ["bun"]`, which TypeScript 7 needs for Bun's globals.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rvlib-shipkit",
-    "version": "2.2.0",
+    "version": "2.3.0",
     "funding": "https://github.com/sponsors/rvion",
     "description": "All-in-one repo companion: ci gate (task DAG), auto-discovered health checks, release-contract fulfillness, asks queue, md-wiki tools, asset atelier, live tui",
     "license": "MIT",

package/src/agent-time/mask.ts

@@ -0,0 +1,43 @@
+// What `sk time` prints comes from his sessions: commands and prompts can
+// carry a token or a private name. Every line passes through here first: the
+// leak guard's own keyword list (machine wide and the repo's), then the token
+// shapes no list has to name.
+import { existsSync, readFileSync } from 'fs'
+import { join } from 'path'
+import { KEYWORD_FILE } from '../core/layout.ts'
+import { type ParsedPatterns, globalKeywordFile, parsePatterns } from '../hooks/leak-guard.ts'
+
+/** token shapes masked whatever the lists say */
+const TOKEN_SHAPES: RegExp[] = [
+    /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g,
+    /(?<![A-Za-z0-9_-])sk-[A-Za-z0-9_-]{20,}/g,
+    /\bgh[pousr]_[A-Za-z0-9]{30,}/g,
+    /\bxox[baprs]-[A-Za-z0-9-]{10,}/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\b(?:Bearer|token|Token)\s+[A-Za-z0-9._~+/=-]{16,}/g,
+    /\b(?:api[_-]?key|secret|password|passwd|token)\s*[=:]\s*['"]?[^\s'"]{8,}/gi,
+    /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+]
+
+const escapeRegex = (s: string): string => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+export type Masker = (text: string) => string
+
+/** a masker over parsed keyword rows plus the token shapes */
+export function makeMasker(p: ParsedPatterns): Masker {
+    const res: RegExp[] = [
+        ...TOKEN_SHAPES,
+        ...p.substrings.map((s) => new RegExp(escapeRegex(s), 'gi')),
+        ...p.words.map((w) => new RegExp(w.re.source, 'giu')),
+        ...p.regexes.map((r) => new RegExp(r.re.source, 'gi')),
+    ]
+    return (text) => res.reduce((t, re) => t.replace(re, '***'), text)
+}
+
+/** the masker this machine and repo call for: the global keyword list and
+ *  the repo's own, when they exist */
+export function loadMasker(root: string | null): Masker {
+    const files = [globalKeywordFile(), root == null ? null : join(root, KEYWORD_FILE)].filter((f): f is string => f != null && existsSync(f))
+    const text = files.map((f) => readFileSync(f, 'utf8')).join('\n')
+    return makeMasker(parsePatterns(text))
+}

package/src/agent-time/render.ts

@@ -0,0 +1,187 @@
+// `sk time` as text: verdict first, one line a row, ids not dumps. The default
+// view answers "where did the time go and what wastes it" in about 25 lines;
+// each sub view goes one level deeper on one question.
+import type { Breakdown } from './timeline.ts'
+import { type ShapeRow, type TimeReport, total } from './report.ts'
+import type { TurnStats } from './turns.ts'
+
+export const VIEWS = ['summary', 'commands', 'tools', 'slow', 'fails', 'feedback', 'sessions', 'turns'] as const
+export type View = (typeof VIEWS)[number]
+
+/** 0.4s, 12s, 4m10s, 3.2h */
+export function fmtMs(ms: number): string {
+    if (ms < 1000) return `${(ms / 1000).toFixed(1)}s`
+    if (ms < 60_000) return `${Math.round(ms / 1000)}s`
+    if (ms < 3_600_000) {
+        const m = Math.floor(ms / 60_000)
+        const s = Math.round((ms % 60_000) / 1000)
+        return s === 0 ? `${m}m` : `${m}m${String(s).padStart(2, '0')}s`
+    }
+    return `${(ms / 3_600_000).toFixed(1)}h`
+}
+
+const day = (t: number): string => new Date(t).toISOString().slice(0, 10)
+const when = (t: number): string => new Date(t).toISOString().slice(5, 16).replace('T', ' ')
+const pct = (part: number, whole: number): string => (whole <= 0 ? '0%' : `${Math.round((100 * part) / whole)}%`)
+const n = (x: number): string => x.toLocaleString('en-US')
+const account = (a: string): string => (a === '.claude' ? 'cc1' : a.replace(/^\.claude-/, ''))
+
+function table(head: string[], rows: string[][]): string[] {
+    const all = [head, ...rows]
+    const w = head.map((_, i) => Math.max(...all.map((r) => (r[i] ?? '').length)))
+    return all.map((r) => `  ${r.map((c, i) => (i === 0 ? c.padEnd(w[i] ?? 0) : c.padStart(w[i] ?? 0))).join('  ')}`.trimEnd())
+}
+
+const shapeRows = (rows: ShapeRow[]): string[][] =>
+    rows.map((r) => [r.shape.slice(0, 44), n(r.calls), fmtMs(r.ms), fmtMs(r.p50), fmtMs(r.p95), fmtMs(r.max), r.failed === 0 ? '' : `${r.failed}`])
+
+function wallLine(b: Breakdown): string {
+    const w = total(b, false)
+    const part = (label: string, ms: number): string => `${label} ${pct(ms, w)} ${fmtMs(ms)}`
+    return `wall ${fmtMs(w)}: ${[part('model', b.model), part('tools', b.tools), part('your allow', b.approval), part('sub-agent wait', b.subagent), part('background wait', b.background), part('waiting on you', b.human)].join(' · ')}`
+}
+
+function header(r: TimeReport): string[] {
+    const span = r.from == null ? 'all recorded' : `since ${day(r.from)}`
+    const repos = r.repos.length > 3 ? `${r.repos.length} repos` : r.repos.join(', ')
+    const pruned = r.prunedSessions > 0 ? ` (${r.prunedSessions} kept after Claude Code pruned them)` : ''
+    return [
+        `${repos} · ${span} · ${r.accounts.length} account${r.accounts.length === 1 ? '' : 's'} · ${n(r.sessions)} sessions${pruned} · ${n(r.subagentRuns)} sub-agent runs`,
+        wallLine(r.wall),
+        `idle (no prompt for ${30}m+) left out: ${fmtMs(r.wall.idle)}`,
+        `${n(r.callCount)} tool calls, ${fmtMs(r.callMs)} of call time (parallel calls overlap, so it can pass the wall)`,
+    ]
+}
+
+/** a share in percent, one decimal under 10 */
+const share = (part: number, whole: number): string => {
+    if (whole <= 0) return '0%'
+    const p = (100 * part) / whole
+    return p < 10 ? `${p.toFixed(1)}%` : `${Math.round(p)}%`
+}
+
+/** model time a call: one decimal, it is the number a change moves */
+const perCall = (ms: number): string => (ms < 60_000 ? `${(ms / 1000).toFixed(1)}s` : fmtMs(ms))
+
+/** the three turn metrics: model before each call, single reads, parallel */
+const turnMetrics = (t: TurnStats): string => `${perCall(t.calls === 0 ? 0 : t.model / t.calls)} of model before each call · ${share(t.reads, t.calls)} single reads · ${share(t.parallel, t.calls)} in parallel`
+
+/** what the work went to, verdict first: turns or commands, then the fix */
+function turnVerdict(t: TurnStats, model: number, tools: number): string[] {
+    const work = model + tools
+    if (model <= tools) return [`command speed, not turns: tools ${pct(tools, work)} of the work, model ${pct(model, work)}; the slow commands are below`]
+    const out = [`turn count, not command speed: model ${pct(model, work)} of the work, ${turnMetrics(t)}`]
+    if (t.reads >= 0.3 * t.calls && t.parallel < 0.1 * t.calls) out.push('  fix: fewer turns (several reads in one turn, a project command that returns the whole answer)')
+    return out
+}
+
+/** the turn metrics of the main sessions, then the sub-agents' verdict and work */
+function turnsSection(r: TimeReport): { main: string[]; sub: string[] } {
+    const { main, sub } = r.turns
+    const out = { main: [] as string[], sub: [] as string[] }
+    if (main.calls > 0) out.main.push(`main sessions, ${n(main.calls)} calls: ${turnMetrics(main)}`)
+    if (sub.runs > 0) {
+        const w = sub.work
+        const busy = w.model + w.tools + w.approval + w.subagent + w.background
+        const waits = busy - w.model - w.tools
+        const [verdict, ...fix] = turnVerdict(sub, w.model, w.tools)
+        out.sub.push(
+            `sub-agents: ${verdict}`,
+            ...fix,
+            `  ${n(sub.runs)} runs worked ${fmtMs(busy)}: model ${fmtMs(w.model)} · tools ${fmtMs(w.tools)} · their own waits ${fmtMs(waits)} · ${n(sub.calls)} calls · a run p50 ${fmtMs(sub.runP50)} p90 ${fmtMs(sub.runP90)}, ${n(sub.callsP50)} calls p50`,
+        )
+    }
+    return out
+}
+
+const bashOnly = (r: TimeReport): ShapeRow[] => r.shapes.filter((s) => s.tool === 'Bash')
+
+function summary(r: TimeReport): string[] {
+    const turns = turnsSection(r)
+    const out = [...header(r), ...turns.main]
+    if (turns.sub.length > 0) out.push('', ...turns.sub)
+    if (r.insights.length > 0) out.push('', 'what costs the most (measured, biggest first; ~ = estimate)', ...r.insights.map((i) => `  ${`${i.estimate ? '~' : ''}${fmtMs(i.ms)}`.padStart(7)}  ${i.text}`))
+    out.push('', 'commands by total time (Bash shapes)', ...table(['shape', 'calls', 'total', 'p50', 'p95', 'max', 'fail'], shapeRows(bashOnly(r).slice(0, 8))))
+    const p95 = [...bashOnly(r)].filter((s) => s.calls >= 5).sort((a, b) => b.p95 - a.p95).slice(0, 4)
+    if (p95.length > 0) out.push('', 'slowest per call (p95, 5 calls or more)', ...p95.map((s) => `  ${fmtMs(s.p95).padStart(6)}  ${s.shape} (${s.calls} calls, ${fmtMs(s.ms)} total)`))
+    const waste = [...r.shapes].filter((s) => s.failed > 0).sort((a, b) => b.failedMs - a.failedMs || b.failed - a.failed).slice(0, 4)
+    if (waste.length > 0) out.push('', 'failures (time in failed runs, run again after a fail, of those unchanged)', ...waste.map((s) => `  ${fmtMs(s.failedMs).padStart(6)}  ${s.shape}: ${s.failed} failed, ${s.retried} run again, ${s.blind} unchanged${s.timeouts > 0 ? `, ${s.timeouts} timeouts` : ''}`))
+    out.push('', ...feedbackHead(r))
+    const slow = r.feedback.hits.filter((h) => h.signals.some((s) => s.signal === 'slow')).slice(-3)
+    for (const h of slow) out.push(complaint(h))
+    out.push('', 'more: sk time commands | tools | slow | fails | feedback | sessions | turns, --json')
+    return out
+}
+
+function feedbackHead(r: TimeReport): string[] {
+    const f = r.feedback
+    const out = [`feedback: ${n(f.prompts)} prompts (${n(f.queued)} typed mid-run) · ${f.counts.status} status pings · ${f.counts.slow} slowness · ${f.counts.correction} corrections`]
+    for (const sig of ['status', 'slow'] as const) {
+        const by = new Map<string, number>()
+        for (const h of f.hits) if (h.signals.some((s) => s.signal === sig) && h.ran[0] != null) by.set(h.ran[0].shape, (by.get(h.ran[0].shape) ?? 0) + 1)
+        const top = [...by].sort((a, b) => b[1] - a[1]).slice(0, 4)
+        if (top.length > 0) out.push(`  the longest run before his ${sig === 'status' ? 'status pings' : 'slowness complaints'}: ${top.map(([k, v]) => `${k} ×${v}`).join(', ')}`)
+    }
+    return out
+}
+
+function complaint(h: TimeReport['feedback']['hits'][number]): string {
+    const ran = h.ran.length === 0 ? 'nothing ran in the 10 minutes before' : h.ran.map((c) => `${c.shape} ${fmtMs(c.ms)}${c.open ? ' (no result)' : ''}`).join(', ')
+    return `  ${when(h.at)} ${h.signals.map((s) => s.rule).join(',')} "${h.text.slice(0, 70)}" ← ${ran}`
+}
+
+export function render(r: TimeReport, view: View, top: number): string {
+    let out: string[]
+    switch (view) {
+        case 'summary':
+            out = summary(r)
+            break
+        case 'commands':
+            out = [`${n(r.shapes.length)} shapes, by total time (every tool but sub-agents)`, ...table(['shape', 'calls', 'total', 'p50', 'p95', 'max', 'fail', 'rerun', 'timeout'], r.shapes.slice(0, top).map((s) => [...(shapeRows([s])[0] ?? []), `${s.retried || ''}`, `${s.timeouts || ''}`]))]
+            break
+        case 'tools':
+            out = [`${r.tools.length} tools, by total call time`, ...table(['tool', 'calls', 'total', 'p50', 'p95', 'max', 'fail'], shapeRows(r.tools.slice(0, top)))]
+            break
+        case 'slow':
+            out = [`the ${Math.min(top, r.slowest.length)} slowest Bash calls`, ...r.slowest.slice(0, top).map((s) => `  ${fmtMs(s.ms).padStart(6)}  ${when(s.at)}  ${account(s.account).padEnd(12)} ${s.session.slice(0, 8)}${s.agent ? ' sub' : '    '}  ${s.outcome ?? 'no result'}  ${s.cmd}`)]
+            break
+        case 'fails': {
+            const rows = [...r.shapes].filter((s) => s.failed + s.blocked > 0).sort((a, b) => b.failedMs - a.failedMs || b.failed - a.failed).slice(0, top)
+            out = [`${rows.length} shapes failed or were blocked, by time in failed runs`, ...table(['shape', 'failed', 'time lost', 'run again', 'unchanged', 'timeout', 'blocked'], rows.map((s) => [s.shape.slice(0, 44), `${s.failed}`, fmtMs(s.failedMs), `${s.retried}`, `${s.blind}`, `${s.timeouts}`, `${s.blocked}`]))]
+            break
+        }
+        case 'feedback': {
+            const f = r.feedback
+            out = [...feedbackHead(r), `rules that matched: ${Object.entries(f.rules).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k} ${v}`).join(' · ') || 'none'}`]
+            for (const sig of ['slow', 'status', 'correction'] as const) {
+                const hs = f.hits.filter((h) => h.signals.some((s) => s.signal === sig))
+                if (hs.length === 0) continue
+                out.push('', `${sig} (${hs.length}, latest ${Math.min(top, hs.length)})`, ...hs.slice(-top).map(complaint))
+            }
+            break
+        }
+        case 'sessions':
+            out = [`${r.sessionRows.length} sessions, by wall (idle left out)`, ...table(['session', 'account', 'start', 'wall', 'model', 'tools', 'sub', 'bg', 'you', 'calls', 'agents', 'first prompt'], r.sessionRows.slice(0, top).map((s) => [s.session.slice(0, 8), account(s.account), when(s.start), fmtMs(total(s.wall, false)), fmtMs(s.wall.model), fmtMs(s.wall.tools), fmtMs(s.wall.subagent), fmtMs(s.wall.background), fmtMs(s.wall.human), `${s.calls}`, `${s.subagents}`, s.first.slice(0, 40)]))]
+            break
+        case 'turns': {
+            const t = r.turns
+            const reads = t.reads.reduce((a, x) => a + x.model, 0)
+            const ts = turnsSection(r)
+            out = [
+                ...ts.main,
+                ...ts.sub,
+                '',
+                `the ${Math.min(top, t.rows.length)} runs that worked longest (work: model, tools, your allow; wall adds their waits on other agents; a sub-agent run is session and agent id)`,
+                ...table(['run', 'account', 'start', 'work', 'wall', 'model', 'calls', 'turns', 'read', 'parallel', 'model/turn'], t.rows.slice(0, top).map((x) => {
+                    const turns = x.turns.calls - x.turns.parallel
+                    return [`${x.session.slice(0, 8)}${x.agent === '' ? '' : ` ${x.agent.replace(/^agent-/, '').slice(0, 8)}`}`, account(x.account), when(x.start), fmtMs(x.work), fmtMs(x.wall), fmtMs(x.turns.model), n(x.turns.calls), n(turns), share(x.turns.reads, x.turns.calls), share(x.turns.parallel, x.turns.calls), perCall(turns === 0 ? 0 : x.turns.model / turns)]
+                })),
+                '',
+                `read shapes by the model time of the turns that issued them (${fmtMs(reads)} in all)`,
+                ...table(['read', 'calls', 'model', 'per call'], t.reads.slice(0, top).map((x) => [x.shape, n(x.calls), fmtMs(x.model), perCall(x.calls === 0 ? 0 : x.model / x.calls)])),
+            ]
+            break
+        }
+    }
+    return `${out.join('\n')}\n`
+}

package/src/agent-time/report.ts

@@ -0,0 +1,335 @@
+// `sk time` from the index rows: where the wall went, which commands ate the
+// time, what failed and ran again, and what he said while it ran.
+//
+// The constraint a reader breaks first: one session can sit in two or three
+// config roots (a session imported into another account to resume it there).
+// Streams are merged by session and agent, and calls deduped by their tool
+// use id, or every imported session counts twice.
+import { type PromptEntry, dedupePrompts } from '../reflect/prompt-corpus.ts'
+import type { Outcome } from '../reflect/transcript.ts'
+import type { Masker } from './mask.ts'
+import { type Signal, signalsOf } from './signals.ts'
+import type { FileRow, Loaded } from './store.ts'
+import { type ReadCost, type TurnStats, addTurns, emptyTurns, turnsOf } from './turns.ts'
+import { type Breakdown, type Call, type Mark, type Stream, FAILED, IDLE_MS, addBreakdown, callMs, type Closed, closeCalls, emptyBreakdown, quantileSorted, ranBefore, retries, wallBreakdown } from './timeline.ts'
+
+export type ShapeRow = { shape: string; tool: string; calls: number; ms: number; approvals: number; approvalMs: number; p50: number; p95: number; max: number; failed: number; timeouts: number; blocked: number; retried: number; blind: number; failedMs: number }
+
+export type SlowCall = { ms: number; shape: string; cmd: string; at: number; account: string; session: string; agent: boolean; outcome: Outcome | null; open: boolean }
+
+export type Complaint = { at: number; session: string; account: string; text: string; signals: { signal: Signal; rule: string }[]; ran: { shape: string; cmd: string; ms: number; open: boolean }[] }
+
+/** one session or one sub-agent run, by its turns */
+export type TurnRow = { session: string; agent: string; account: string; start: number; work: number; wall: number; turns: TurnStats }
+
+/** turn count: the main sessions and the sub-agents apart, the runs with the
+ *  most wall, and the read shapes by the model time of the turns that issued them */
+export type TurnReport = {
+    main: TurnStats
+    sub: TurnStats & { runs: number; work: Breakdown; runP50: number; runP90: number; callsP50: number }
+    rows: TurnRow[]
+    reads: ReadCost[]
+}
+
+export type SessionRow = { session: string; account: string; repo: string; start: number; wall: Breakdown; calls: number; subagents: number; first: string }
+
+export type TimeReport = {
+    repos: string[]
+    from: number | null
+    to: number
+    accounts: string[]
+    sessions: number
+    subagentRuns: number
+    /** history whose transcript Claude Code already pruned, still in the index */
+    prunedSessions: number
+    wall: Breakdown
+    subagentWork: number
+    callCount: number
+    callMs: number
+    shapes: ShapeRow[]
+    tools: ShapeRow[]
+    slowest: SlowCall[]
+    feedback: { prompts: number; queued: number; counts: Record<Signal, number>; rules: Record<string, number>; hits: Complaint[] }
+    sessionRows: SessionRow[]
+    turns: TurnReport
+    /** the measured waste, biggest first: each with the number behind it */
+    insights: Insight[]
+}
+
+export type Insight = { id: 'classifier' | 'bash-edits' | 'polling' | 'failed' | 'approval'; ms: number; estimate: boolean; text: string }
+
+/** commands that cost nothing to run: their time is the harness around them */
+const CHEAP = new Set(['grep', 'sed', 'cat', 'ls', 'head', 'tail', 'wc', 'git status', 'echo', 'pwd', 'rg'])
+
+const isEdit = (shape: string): boolean => shape.endsWith('(edit)') || shape === 'cat > (write)'
+const isPolling = (shape: string): boolean => shape.startsWith('(until)') || shape.startsWith('(while)') || shape === 'sleep'
+
+const fmt = (ms: number): string => (ms < 1000 ? `${(ms / 1000).toFixed(1)}s` : ms < 60_000 ? `${Math.round(ms / 1000)}s` : ms < 3_600_000 ? `${Math.round(ms / 60_000)}m` : `${(ms / 3_600_000).toFixed(1)}h`)
+
+const p50Of = (xs: number[]): number => quantileSorted(xs.sort((a, b) => a - b), 0.5)
+
+/** the waste the rows add up to, each a cause with its number */
+export function insightsOf(calls: Closed[], wall: Breakdown, shapes: ShapeRow[]): Insight[] {
+    const out: Insight[] = []
+    const bash = calls.filter((c) => c.tool === 'Bash')
+    const cheap = bash.filter((c) => CHEAP.has(c.shape))
+    const viaClassifier = cheap.filter((c) => c.perm === 'classifier').map(callMs)
+    const viaRule = cheap.filter((c) => c.perm === 'rule').map(callMs)
+    const classified = bash.filter((c) => c.perm === 'classifier').length
+    if (viaClassifier.length >= 20 && viaRule.length >= 20) {
+        const c = p50Of(viaClassifier)
+        const r = p50Of(viaRule)
+        if (c > r) out.push({ id: 'classifier', ms: (c - r) * classified, estimate: true, text: `the auto mode classifier checked ${classified.toLocaleString('en-US')} Bash calls before they ran: a cheap command (grep, sed, cat, ls) takes p50 ${fmt(c)} through it, ${fmt(r)} when a rule allows it. fix: allow rules for the read only commands agents repeat` })
+    }
+    const edits = bash.filter((c) => isEdit(c.shape))
+    const editTool = calls.filter((c) => c.tool === 'Edit').map(callMs)
+    if (edits.length > 0) {
+        const ms = edits.map(callMs)
+        const bashP50 = p50Of(ms)
+        const toolP50 = editTool.length >= 20 ? p50Of(editTool) : null
+        const saved = toolP50 == null || toolP50 >= bashP50 ? '' : `, about ${fmt((bashP50 - toolP50) * edits.length)} back at the Edit tool's p50 ${fmt(toolP50)}`
+        out.push({ id: 'bash-edits', ms: ms.reduce((a, b) => a + b, 0), estimate: false, text: `${edits.length.toLocaleString('en-US')} file edits through Bash (python3 heredocs, sed -i, perl -i, cat >), p50 ${fmt(bashP50)}${saved}` })
+    }
+    const polls = bash.filter((c) => isPolling(c.shape))
+    if (polls.length > 0) {
+        const timeouts = polls.filter((c) => c.outcome === 'timeout').length
+        const top = shapes.filter((s) => isPolling(s.shape)).slice(0, 3).map((s) => `${s.shape} ${fmt(s.ms)}`).join(', ')
+        out.push({ id: 'polling', ms: polls.map(callMs).reduce((a, b) => a + b, 0), estimate: false, text: `${polls.length.toLocaleString('en-US')} polling waits (until and while loops, sleep), ${timeouts} hit the Bash timeout: ${top}` })
+    }
+    const failed = bash.filter((c) => c.outcome != null && FAILED.has(c.outcome))
+    if (failed.length > 0) {
+        const rerun = shapes.reduce((a, s) => a + s.retried, 0)
+        const blind = shapes.reduce((a, s) => a + s.blind, 0)
+        out.push({ id: 'failed', ms: failed.map(callMs).reduce((a, b) => a + b, 0), estimate: false, text: `${failed.length.toLocaleString('en-US')} failed Bash runs (non zero exit, error, timeout), ${rerun} run again, ${blind} of them unchanged` })
+    }
+    if (wall.approval > 0) {
+        const n = calls.filter((c) => c.approval).length
+        const top = [...shapes].filter((s) => s.approvals > 0).sort((a, b) => b.approvalMs - a.approvalMs).slice(0, 3).map((s) => `${s.shape} ${fmt(s.approvalMs)}`).join(', ')
+        out.push({ id: 'approval', ms: wall.approval, estimate: false, text: `waiting for you to allow ${n} call${n === 1 ? '' : 's'}: ${top}` })
+    }
+    return out.sort((a, b) => b.ms - a.ms)
+}
+
+type Group = { key: string; session: string; agent: string; files: FileRow[]; stream: Stream; closed: Closed[] }
+
+/** one stream per session and agent, every copy of it merged */
+export function mergeStreams(loaded: Loaded): Group[] {
+    const groups = new Map<string, Group>()
+    for (const f of loaded.files) {
+        const key = `${f.session}/${f.agent}`
+        const g = groups.get(key) ?? { key, session: f.session, agent: f.agent, files: [], stream: { calls: [], marks: [] }, closed: [] }
+        g.files.push(f)
+        groups.set(key, g)
+    }
+    for (const g of groups.values()) {
+        const calls = new Map<string, Call>()
+        const marks = new Map<string, Mark>()
+        for (const f of g.files) {
+            for (const c of loaded.calls.get(f.id) ?? []) {
+                const have = calls.get(c.id)
+                if (have == null || (have.end == null && c.end != null)) calls.set(c.id, c)
+            }
+            for (const m of loaded.marks.get(f.id) ?? []) marks.set(`${m.at}/${m.kind}`, m)
+        }
+        g.stream = { calls: [...calls.values()], marks: [...marks.values()] }
+        g.closed = closeCalls(g.stream)
+    }
+    return [...groups.values()]
+}
+
+function pushTo<K, V>(m: Map<K, V[]>, k: K, v: V): void {
+    const list = m.get(k)
+    if (list == null) m.set(k, [v])
+    else list.push(v)
+}
+
+/** the k items of largest `key`, largest first, without sorting the list */
+function topBy<T>(xs: T[], k: number, key: (x: T) => number): T[] {
+    const top: { x: T; v: number }[] = []
+    for (const x of xs) {
+        const v = key(x)
+        if (top.length === k && v <= (top[k - 1] as { v: number }).v) continue
+        let i = top.length
+        while (i > 0 && (top[i - 1] as { v: number }).v < v) i--
+        top.splice(i, 0, { x, v })
+        if (top.length > k) top.pop()
+    }
+    return top.map((t) => t.x)
+}
+
+const isFailed = (o: Outcome | null): boolean => o != null && FAILED.has(o)
+
+function rowsBy(calls: { c: Closed; key: string }[], retriesByKey: Map<string, { retried: number; blind: number }>): ShapeRow[] {
+    const by = new Map<string, Closed[]>()
+    for (const { c, key } of calls) {
+        const list = by.get(key)
+        if (list == null) by.set(key, [c])
+        else list.push(c)
+    }
+    return [...by].map(([key, cs]): ShapeRow => {
+        const ms = new Float64Array(cs.length)
+        const row: ShapeRow = { shape: key, tool: cs[0]?.tool ?? '', calls: cs.length, ms: 0, approvals: 0, approvalMs: 0, p50: 0, p95: 0, max: 0, failed: 0, timeouts: 0, blocked: 0, retried: 0, blind: 0, failedMs: 0 }
+        cs.forEach((c, i) => {
+            const d = callMs(c)
+            ms[i] = d
+            row.ms += d
+            if (c.approval) {
+                row.approvals++
+                row.approvalMs += d
+            }
+            if (isFailed(c.outcome)) {
+                row.failed++
+                row.failedMs += d
+            }
+            if (c.outcome === 'timeout') row.timeouts++
+            if (c.outcome === 'blocked' || c.outcome === 'denied') row.blocked++
+        })
+        ms.sort()
+        const sorted = Array.from(ms)
+        const r = retriesByKey.get(key)
+        return { ...row, p50: quantileSorted(sorted, 0.5), p95: quantileSorted(sorted, 0.95), max: sorted[sorted.length - 1] ?? 0, retried: r?.retried ?? 0, blind: r?.blind ?? 0 }
+    }).sort((a, b) => b.ms - a.ms || b.calls - a.calls)
+}
+
+export function buildReport(loaded: Loaded, q: { repos: string[]; from: number | null; to: number; repoOf: (project: string) => string }, mask: Masker): TimeReport {
+    const from = q.from ?? -Infinity
+    const groups = mergeStreams(loaded)
+    const accounts = new Set<string>()
+    const wall = emptyBreakdown()
+    let subagentWork = 0
+    const all: { c: Closed; g: Group }[] = []
+    const retryShape = new Map<string, { retried: number; blind: number }>()
+    const sessionRows: SessionRow[] = []
+    const subsBySession = new Map<string, number>()
+    for (const g of groups) if (g.agent !== '') subsBySession.set(g.session, (subsBySession.get(g.session) ?? 0) + 1)
+    const promptsByFile = new Map<number, Loaded['prompts']>()
+    for (const p of loaded.prompts) pushTo(promptsByFile, p.file_id, p)
+    const mainTurns = emptyTurns()
+    const subTurns = emptyTurns()
+    const subWork = emptyBreakdown()
+    const runMs: number[] = []
+    const runCalls: number[] = []
+    const turnRows: TurnRow[] = []
+    const readCosts = new Map<string, ReadCost>()
+
+    for (const g of groups) {
+        for (const f of g.files) accounts.add(f.account)
+        const turnModel = new Float64Array(g.closed.length)
+        const b = wallBreakdown(g.stream, from, q.to, IDLE_MS, g.closed, turnModel)
+        const t = turnsOf(g.closed, b.model, turnModel, readCosts)
+        const work = b.model + b.tools + b.approval + b.subagent + b.background
+        if (t.calls > 0) turnRows.push({ session: g.session, agent: g.agent, account: g.files[0]?.account ?? '', start: g.closed[0]?.start ?? 0, work: b.model + b.tools + b.approval, wall: work, turns: t })
+        if (g.agent === '') addTurns(mainTurns, t)
+        else {
+            addTurns(subTurns, t)
+            addBreakdown(subWork, b)
+            runMs.push(work)
+            runCalls.push(t.calls)
+        }
+        if (g.agent === '') {
+            addBreakdown(wall, b)
+            const firstPrompt = g.files.flatMap((f) => promptsByFile.get(f.id) ?? []).sort((a, b2) => a.at - b2.at)[0]
+            sessionRows.push({
+                session: g.session,
+                account: g.files[0]?.account ?? '',
+                repo: q.repoOf(g.files[0]?.project ?? ''),
+                start: [...g.stream.marks.map((m) => m.at), ...g.stream.calls.map((c) => c.start)].reduce((a, b) => (b < a ? b : a), Infinity),
+                wall: b,
+                calls: g.stream.calls.length,
+                subagents: subsBySession.get(g.session) ?? 0,
+                first: firstPrompt == null ? '' : mask(firstPrompt.text.replace(/\s+/g, ' ').slice(0, 70)),
+            })
+        } else subagentWork += work
+        for (const c of g.closed) all.push({ c, g })
+        for (const r of retries(g.closed)) {
+            const x = retryShape.get(r.failed.shape) ?? { retried: 0, blind: 0 }
+            x.retried++
+            if (r.blind) x.blind++
+            retryShape.set(r.failed.shape, x)
+        }
+    }
+
+    const bash = all.filter(({ c }) => c.tool === 'Bash')
+    const shapes = rowsBy(all.filter(({ c }) => c.tool !== 'Agent' && c.tool !== 'Task').map(({ c }) => ({ c, key: c.shape })), retryShape)
+    // the Bash shapes first: they are the commands; other tools stay in the table
+    shapes.sort((a, b) => b.ms - a.ms)
+    const tools = rowsBy(all.map(({ c }) => ({ c, key: c.tool })), new Map())
+    const slowest: SlowCall[] = topBy(bash, 40, ({ c }) => callMs(c))
+        .map(({ c, g }) => ({ ms: callMs(c), shape: c.shape, cmd: mask(c.cmd.replace(/\s+/g, ' ').slice(0, 120)), at: c.start, account: g.files[0]?.account ?? '', session: g.session, agent: g.agent !== '', outcome: c.outcome, open: c.open }))
+
+    // feedback: his prompts, deduped across copies, signals by rule, and for a
+    // slowness complaint what every stream of that session was running
+    const fileById = new Map(loaded.files.map((f) => [f.id, f]))
+    const groupsBySession = new Map<string, Group[]>()
+    for (const g of groups) pushTo(groupsBySession, g.session, g)
+    const counts: Record<Signal, number> = { status: 0, slow: 0, correction: 0 }
+    const rules: Record<string, number> = {}
+    const hits: Complaint[] = []
+    const typed: (PromptEntry & { file: FileRow })[] = []
+    for (const p of loaded.prompts) {
+        const f = fileById.get(p.file_id)
+        if (f == null || f.agent !== '') continue
+        typed.push({ uuid: `${p.at}/${p.origin}/${p.text}`, timestamp: new Date(p.at).toISOString(), sessionId: f.session, account: f.account, text: p.text, origin: p.origin, file: f })
+    }
+    typed.sort((a, b) => a.timestamp.localeCompare(b.timestamp))
+    const kept = dedupePrompts(typed) as (PromptEntry & { file: FileRow })[]
+    const repoGroups = (session: string): Group[] => groupsBySession.get(session) ?? []
+    let sortedAll: Closed[] | null = null
+    const allSorted = (): Closed[] => (sortedAll ??= all.map(({ c }) => c).sort((a, b) => a.start - b.start))
+    for (const p of kept) {
+        const signals = signalsOf(p.text)
+        if (signals.length === 0) continue
+        for (const s of signals) {
+            counts[s.signal]++
+            rules[s.rule] = (rules[s.rule] ?? 0) + 1
+        }
+        const at = Date.parse(p.timestamp)
+        const notAgent = (c: Closed) => c.tool !== 'Agent' && c.tool !== 'Task'
+        // his session first; a fresh session had nothing running, so then every
+        // session of the repo in those minutes
+        let ran = repoGroups(p.file.session).flatMap((g) => ranBefore(g.closed, at)).filter(notAgent)
+        if (ran.length === 0) ran = ranBefore(allSorted(), at).filter(notAgent)
+        hits.push({
+            at,
+            session: p.file.session,
+            account: p.account,
+            text: mask(p.text.replace(/\s+/g, ' ').slice(0, 160)),
+            signals,
+            ran: ran.sort((a, b) => callMs(b) - callMs(a)).slice(0, 3).map((c) => ({ shape: c.shape, cmd: mask(c.cmd.replace(/\s+/g, ' ').slice(0, 80)), ms: callMs(c), open: c.open })),
+        })
+    }
+    const prompts = kept.length
+    const queued = kept.filter((p) => p.origin === 'queued').length
+
+    const mains = groups.filter((g) => g.agent === '')
+    return {
+        repos: q.repos,
+        from: q.from,
+        to: q.to,
+        accounts: [...accounts].sort(),
+        sessions: mains.length,
+        subagentRuns: groups.length - mains.length,
+        prunedSessions: mains.filter((g) => g.files.every((f) => f.gone === 1)).length,
+        wall,
+        subagentWork,
+        callCount: all.length,
+        callMs: all.reduce((a, { c }) => a + callMs(c), 0),
+        shapes,
+        tools,
+        slowest,
+        feedback: { prompts, queued, counts, rules, hits },
+        sessionRows: sessionRows.sort((a, b) => total(b.wall, false) - total(a.wall, false)),
+        turns: {
+            main: mainTurns,
+            sub: { ...subTurns, runs: runMs.length, work: subWork, runP50: quantileSorted(runMs.sort((a, b) => a - b), 0.5), runP90: quantileSorted(runMs, 0.9), callsP50: quantileSorted(runCalls.sort((a, b) => a - b), 0.5) },
+            rows: topBy(turnRows, 200, (r) => r.work),
+            reads: [...readCosts.values()].sort((a, b) => b.model - a.model),
+        },
+        insights: insightsOf(all.map(({ c }) => c), wall, shapes),
+    }
+}
+
+/** the wall of a breakdown; idle left out unless asked */
+export const total = (b: Breakdown, idle: boolean): number => b.model + b.tools + b.approval + b.subagent + b.background + b.human + (idle ? b.idle : 0)
+
+export { IDLE_MS }