@zenera/cli 1.1.25 → 1.1.26

package/dist/meta/finetune/improvements.js

@@ -1,11 +1,24 @@
 import { randomUUID } from 'node:crypto';
-import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
+import { writeApplyBrief } from "./apply-brief.js";
+import { costChanges, limits, measure, overLimits } from "./cost.js";
 import { errorIn, sizeOf } from "./failure.js";
-import { writeApply } from "./report.js";
+import { forProse } from "./feedback.js";
+import { patchFiles, writeApply } from "./report.js";
 import { readJson, Stopped } from "./tuning.js";
-import { envelopesIn, spent } from "./usage.js";
+import { applyTokens, spent } from "./usage.js";
 const pad = (n) => String(n).padStart(3, '0');
+const kept = (d) => d?.decision === 'applied' || d?.decision === 'merged';
+const DECIDED = new Set(['applied', 'merged', 'rejected', 'deferred', 'structural']);
+/** `<request> <improvement>` for each improvement of inputs.json that decisions.json gives no valid decision. */
+export function undecided(dir) {
+    const inputs = readJson(join(dir, 'inputs.json')) ?? [];
+    const decided = readJson(join(dir, 'decisions.json')) ?? {};
+    return inputs.flatMap((f) => forProse(f)
+        .filter((i) => !DECIDED.has(decided[f.id]?.[i.id]?.decision ?? ''))
+        .map((i) => `${f.id} ${i.id}`));
+}
 export class Improvements {
     #t;
     pending = [];
@@ -53,10 +66,85 @@ export class Improvements {
     isApplied(id) {
         return this.#applied.has(id);
     }
-    /** Parks until an apply has taken this feedback, the worker free meanwhile. Taken already - after a restart - returns at once. */
+    /**
+     * Every apply's decisions, later ones over earlier, per improvement. An edit
+     * that was undone kept nothing, so what it applied or merged reads `discarded`.
+     */
+    decisions() {
+        const all = {};
+        for (const a of this.applies()) {
+            const undone = a.applied?.discarded;
+            for (const [id, byImprovement] of Object.entries(readJson(join(a.dir, 'decisions.json')) ?? {})) {
+                for (const [i, d] of Object.entries(byImprovement ?? {})) {
+                    (all[id] ??= {})[i] =
+                        undone && kept(d)
+                            ? {
+                                ...d,
+                                decision: 'discarded',
+                                note: `${d.note ?? ''} - undone: ${undone}`.trim(),
+                            }
+                            : d;
+                }
+            }
+        }
+        return all;
+    }
+    /** Improvements held back for want of a second case, and not taken up since. */
+    deferred() {
+        const open = new Map();
+        for (const a of this.applies()) {
+            const inputs = new Map((a.inputs ?? []).map((f) => [f.id, f]));
+            const undone = Boolean(a.applied?.discarded);
+            for (const [id, byImprovement] of Object.entries(readJson(join(a.dir, 'decisions.json')) ?? {})) {
+                for (const [i, d] of Object.entries(byImprovement ?? {})) {
+                    const key = `${id} ${i}`;
+                    if (d?.decision === 'deferred') {
+                        const improvement = inputs.get(id)?.improvements.find((x) => x.id === i) ??
+                            open.get(key)?.improvement;
+                        if (improvement) {
+                            open.set(key, {
+                                request: id,
+                                case: inputs.get(id)?.case ?? open.get(key)?.case ?? id.split('@')[0],
+                                apply: a.name,
+                                improvement,
+                                ...(d.note ? { note: d.note } : {}),
+                            });
+                        }
+                    }
+                    else if (!undone) {
+                        open.delete(key);
+                    }
+                }
+            }
+        }
+        return [...open.values()];
+    }
+    /** The skills an apply made or changed for this request: the case's next run should load them. */
+    skillsFor(id) {
+        const mine = this.decisions()[id] ?? {};
+        return [
+            ...new Set(Object.values(mine)
+                .filter((d) => kept(d) && d.skill)
+                .map((d) => d.skill)),
+        ];
+    }
+    /** Nothing of this request was applied, merged or deferred, and some of it is structural: prose cannot fix it. */
+    #structural(id) {
+        const mine = Object.values(this.decisions()[id] ?? {});
+        const structural = mine.filter((d) => d.decision === 'structural');
+        if (structural.length === 0 ||
+            mine.some((d) => kept(d) || d.decision === 'deferred' || d.decision === 'discarded')) {
+            return undefined;
+        }
+        return structural.map((d) => d.note || 'structural').join('; ');
+    }
+    /**
+     * Parks until an apply has taken this feedback, the worker free meanwhile. Taken already - after a restart - returns at once.
+     * `structural` when the apply found nothing prose can fix.
+     */
     async apply(feedback, s) {
         if (this.#applied.has(feedback.id)) {
-            return;
+            return this.#outcome(feedback.id);
         }
         if (!this.pending.some((f) => f.id === feedback.id)) {
             this.pending.push(feedback);
@@ -68,7 +156,7 @@ export class Improvements {
             case: feedback.case,
             phase: feedback.phase,
             attempt: feedback.attempt,
-            detail: `${feedback.improvements.length} improvement(s), worker freed`,
+            detail: `${forProse(feedback).length} improvement(s), worker freed`,
         });
         this.#t.unseat(s);
         try {
@@ -82,7 +170,24 @@ export class Improvements {
         finally {
             this.parked--;
         }
+        const outcome = this.#outcome(feedback.id);
+        if (outcome.structural) {
+            return outcome;
+        }
         await this.#t.seat(s, true);
+        return outcome;
+    }
+    #outcome(id) {
+        const structural = this.#structural(id);
+        return structural ? { structural } : {};
+    }
+    /** A recheck's request: queued like a parked case's, with no case waiting on it. */
+    regressed(feedback) {
+        if (!this.#applied.has(feedback.id) &&
+            !this.pending.some((f) => f.id === feedback.id) &&
+            !this.inApply.some((f) => f.id === feedback.id)) {
+            this.pending.push(feedback);
+        }
     }
     /** Before a run starts: wait out an apply, or stop. */
     async notApplying() {
@@ -96,7 +201,10 @@ export class Improvements {
     async loop() {
         while (!this.#t.finished) {
             await this.#t.tick();
-            if (this.#t.stopping || this.pending.length === 0) {
+            if (this.#t.stopping) {
+                continue;
+            }
+            if (this.pending.length === 0) {
                 continue;
             }
             if (this.pending.length < this.#t.config.applyAt &&
@@ -112,6 +220,20 @@ export class Improvements {
             }
         }
     }
+    /** What the agents read when the tuning began - its first version, even for a tuning begun before this was kept. */
+    async baseline() {
+        const file = join(this.#t.dir, 'baseline.json');
+        const saved = readJson(file)?.cost;
+        if (saved) {
+            return saved;
+        }
+        const first = this.#t.system.rows()[0];
+        const at = first ? this.#t.system.snapshotDir(first.v) : undefined;
+        const cost = await measure(at && existsSync(at) ? at : this.#t.root);
+        mkdirSync(this.#t.dir, { recursive: true });
+        writeFileSync(file, `${JSON.stringify({ at: new Date().toISOString(), version: first?.v ?? 0, cost }, null, 2)}\n`);
+        return cost;
+    }
     async #applyNow() {
         const t = this.#t;
         this.applying = true;
@@ -139,13 +261,23 @@ export class Improvements {
         const t = this.#t;
         const startedAt = new Date().toISOString();
         mkdirSync(dir, { recursive: true });
-        writeFileSync(join(dir, 'inputs.json'), `${JSON.stringify(batch.map((f) => ({
-            ...f,
-            file: join(t.attemptDir({ id: f.case, rev: f.caseRev }, f.phase, f.attempt), 'feedback.json'),
-        })), null, 2)}\n`);
-        const total = batch.reduce((n, f) => n + f.improvements.length, 0);
+        writeFileSync(join(dir, 'inputs.json'), `${JSON.stringify(batch.map((f) => {
+            const at = f.dir ?? t.attemptDir({ id: f.case, rev: f.caseRev }, f.phase, f.attempt);
+            const missed = readJson(join(at, 'run.json'))?.missedSkills;
+            const { dir: _, ...rest } = f;
+            return {
+                ...rest,
+                improvements: forProse(f),
+                file: join(at, 'feedback.json'),
+                ...(missed?.length ? { missedSkills: missed } : {}),
+            };
+        }), null, 2)}\n`);
+        writeFileSync(join(dir, 'deferred.json'), `${JSON.stringify(this.deferred(), null, 2)}\n`);
+        const total = batch.reduce((n, f) => n + forProse(f).length, 0);
         this.current = { since: Date.now(), name, dir, requests: batch.length };
         let to = from;
+        let discarded;
+        let bytes;
         if (total > 0) {
             t.event({
                 what: 'apply',
@@ -153,17 +285,20 @@ export class Improvements {
             });
             writeApply(t, dir);
             try {
-                await this.#edit(dir, from);
+                const done = await this.#edit(dir, from);
+                bytes = done.bytes;
+                if ('discarded' in done) {
+                    discarded = done.discarded;
+                }
+                else {
+                    to = done.to;
+                }
             }
             catch (err) {
                 writeFileSync(join(dir, 'failed.json'), `${JSON.stringify({ at: new Date().toISOString(), startedAt, error: err.message }, null, 2)}\n`);
                 writeApply(t, dir);
                 throw err;
             }
-            to = t.system.record('apply', name).v;
-            if (to !== from) {
-                writeFileSync(join(dir, 'diff.patch'), t.system.diff(from, to));
-            }
         }
         const applied = {
             ids: batch.map((f) => f.id),
@@ -172,6 +307,8 @@ export class Improvements {
             at: new Date().toISOString(),
             startedAt,
             ...(total === 0 ? { skipped: true } : {}),
+            ...(discarded ? { discarded } : {}),
+            ...(bytes ? { bytes } : {}),
         };
         writeFileSync(join(dir, 'applied.json'), `${JSON.stringify(applied, null, 2)}\n`);
         writeApply(t, dir);
@@ -181,22 +318,78 @@ export class Improvements {
         this.count++;
         this.current = undefined;
         t.event({
-            what: 'applied',
-            detail: `${name}: v${from} -> v${to}, see applies/${name}/APPLY.md`,
-            result: total === 0 ? 'nothing to change' : `v${from} → v${to}`,
+            what: discarded ? 'apply undone' : 'applied',
+            detail: `${name}: ${discarded ? `undone - ${discarded}` : `v${from} -> v${to}`}, see applies/${name}/APPLY.md`,
+            result: total === 0 ? 'nothing to change' : discarded ? 'undone' : `v${from} → v${to}`,
             took: Date.now() - Date.parse(startedAt),
-            tokens: spent(envelopesIn(dir, 'apply')),
+            tokens: spent(applyTokens(dir)),
         });
+        if (!discarded && to !== from) {
+            t.rechecks.queue(name);
+        }
     }
-    /** The meta agent edits; `zen check` must pass, or the edit is undone and tried once more. */
+    /** What an apply is handed about the prose: sizes, limits, and which files grew. */
+    async #writeBudget(dir, now) {
+        const start = await this.baseline();
+        const { files: _, ...rest } = now;
+        writeFileSync(join(dir, 'budget.json'), `${JSON.stringify({
+            ...rest,
+            start: { total: start.total, alwaysRead: start.alwaysRead },
+            ...limits(start, this.#t.config),
+        }, null, 2)}\n`);
+        const touched = new Map();
+        for (const a of this.applies()) {
+            if (!a.applied || a.applied.discarded || !existsSync(join(a.dir, 'diff.patch'))) {
+                continue;
+            }
+            for (const f of patchFiles(readFileSync(join(a.dir, 'diff.patch'), 'utf8'))) {
+                touched.set(f.file, [...(touched.get(f.file) ?? []), a.name]);
+            }
+        }
+        const growth = Object.keys(now.files)
+            .map((file) => ({
+            file,
+            start: start.files[file] ?? 0,
+            now: now.files[file],
+            changes: touched.get(file)?.length ?? 0,
+            recent: (touched.get(file) ?? []).slice(-5),
+        }))
+            .sort((a, b) => b.now - b.start - (a.now - a.start));
+        writeFileSync(join(dir, 'growth.json'), `${JSON.stringify(growth, null, 2)}\n`);
+    }
+    /**
+     * The meta agent edits, then two gates: `zen check` and the budget. A failed
+     * gate undoes the edit and the agent tries once more, told why. `zen check`
+     * failing twice is fatal - the agent cannot leave the project loadable; the
+     * budget failing twice only undoes it. What the edit broke elsewhere is the
+     * rechecks' to find, after it.
+     */
     async #edit(dir, from) {
         const t = this.#t;
+        const name = basename(dir);
+        const before = await measure(t.root);
+        await this.#writeBudget(dir, before);
+        const bound = limits(await this.baseline(), t.config);
+        const gate = { before, limits: bound };
+        writeFileSync(join(dir, 'gate.json'), `${JSON.stringify(gate)}\n`);
+        const unchanged = { before: before.total, after: before.total };
+        const at = (step) => {
+            if (this.current) {
+                this.current.step = step;
+            }
+        };
         for (let attempt = 1;; attempt++) {
+            at('edit');
             const session = randomUUID();
             writeFileSync(join(dir, 'session'), `${session}\n`);
             const applyLog = join(dir, 'apply.log');
             const checkLog = join(dir, 'check.log');
             const offset = { apply: sizeOf(applyLog), check: sizeOf(checkLog) };
+            // An undone attempt's record must not pass for this one's.
+            for (const f of ['decisions.json', 'changes.md']) {
+                rmSync(join(dir, f), { force: true });
+            }
+            const brief = await writeApplyBrief(t, dir, attempt);
             const res = await t.zen([
                 'meta',
                 'run',
@@ -206,24 +399,88 @@ export class Improvements {
                 session,
                 '--events',
                 join(dir, 'apply.events.jsonl'),
+                '--prompt-file',
+                brief,
                 '/finetune-apply',
                 dir,
             ], applyLog);
             writeFileSync(join(dir, attempt === 1 ? 'apply.json' : `apply-${attempt}.json`), res.stdout);
+            // An agent cut off by its provider can still exit 0, having decided nothing.
+            const missing = res.code === 0 ? undecided(dir) : [];
+            if (missing.length > 0) {
+                writeFileSync(join(dir, 'missing.md'), [
+                    `# Attempt ${attempt} was undone: decisions missing`,
+                    '',
+                    'Written by the tuning loop: the apply ended without a decision for these improvements, so the project was put back. This attempt must write `decisions.json` with every one of them, and `changes.md`.',
+                    '',
+                    ...missing.map((m) => `- ${m}`),
+                    '',
+                ].join('\n'));
+                t.error(`apply ${name}${attempt > 1 ? ` try ${attempt}` : ''}`, `the apply ended without a decision for ${missing.length} improvement(s)`, applyLog);
+                t.system.restore(from);
+                if (attempt === 2) {
+                    throw new Error(`apply ${dir} ended twice without deciding every improvement - see missing.md`);
+                }
+                t.event({
+                    what: 'apply retry',
+                    detail: `no decision for ${missing.length} improvement(s)`,
+                });
+                continue;
+            }
+            at('check');
             const check = await t.zen(['check', '--no-models', '--no-sandbox'], checkLog);
-            if (res.code === 0 && check.code === 0) {
-                return;
+            if (res.code !== 0 || check.code !== 0) {
+                const e = res.code !== 0
+                    ? errorIn(applyLog, offset.apply)
+                    : errorIn(checkLog, offset.check);
+                t.error(`apply ${name}${attempt > 1 ? ` try ${attempt}` : ''}`, `${res.code !== 0 ? 'the apply failed' : 'zen check failed after the apply'}${e.message ? `: ${e.message}` : ''}`, e.log);
+                t.system.restore(from);
+                if (attempt === 2) {
+                    throw new Error(`apply ${dir} left the project broken twice - see check.log`);
+                }
+                t.event({
+                    what: 'apply retry',
+                    detail: res.code !== 0 ? 'the apply failed' : 'zen check failed',
+                });
+                continue;
             }
-            const e = res.code !== 0 ? errorIn(applyLog, offset.apply) : errorIn(checkLog, offset.check);
-            t.error(`apply ${basename(dir)}${attempt > 1 ? ` try ${attempt}` : ''}`, `${res.code !== 0 ? 'the apply failed' : 'zen check failed after the apply'}${e.message ? `: ${e.message}` : ''}`, e.log);
-            t.system.restore(from);
-            if (attempt === 2) {
-                throw new Error(`apply ${dir} left the project broken twice - see check.log`);
+            const after = await measure(t.root);
+            const over = overLimits(before, after, bound);
+            if (over.length > 0) {
+                writeFileSync(join(dir, 'budget.md'), [
+                    `# Attempt ${attempt} was undone: over the limits`,
+                    '',
+                    'Written by the tuning loop: this edit grew what the agents read past a limit, so the project was put back. The next attempt reads this file to know what to cut.',
+                    '',
+                    ...over.map((o) => `- ${o}`),
+                    '',
+                    '## What moved',
+                    '',
+                    ...costChanges(before, after),
+                    '',
+                ].join('\n'));
+                t.system.restore(from);
+                if (attempt === 2) {
+                    return { discarded: `over the limits: ${over[0]}`, bytes: unchanged };
+                }
+                t.event({ what: 'apply retry', detail: `over the limits: ${over[0]}` });
+                continue;
             }
-            t.event({
-                what: 'apply retry',
-                detail: res.code !== 0 ? 'the apply failed' : 'zen check failed',
-            });
+            const to = t.system.record('apply', name).v;
+            if (to === from) {
+                return { to, bytes: unchanged };
+            }
+            writeFileSync(join(dir, 'diff.patch'), t.system.diff(from, to));
+            const moved = costChanges(before, after);
+            writeFileSync(join(dir, 'cost.md'), [
+                '# What moved',
+                '',
+                'Written by the tuning loop once this apply passed its gates: bytes before and after it - what each agent reads on every call, each skill body, each file under agents/.',
+                '',
+                ...(moved.length > 0 ? moved : ['Nothing the agents read changed size.']),
+                '',
+            ].join('\n'));
+            return { to, bytes: { before: before.total, after: after.total } };
         }
     }
     /** Requests every apply so far took, for the report. */

package/dist/meta/finetune/live.d.ts

@@ -1,11 +1,7 @@
 import type { EventLine } from '../host.ts';
 import type { StepFailure, Tuning } from './tuning.ts';
-import { type Stage } from './usage.ts';
-export interface ModelSpend {
-    calls: number;
-    input: number;
-    output: number;
-}
+import { type Stage, type Tokens } from './usage.ts';
+export type ModelSpend = Tokens;
 /** One events file, folded as it grows. */
 export interface Activity {
     model?: string;
@@ -13,8 +9,14 @@ export interface Activity {
     input: number;
     output: number;
     byModel: Record<string, ModelSpend>;
-    /** the latest tool call or thing said */
+    /** the latest tool call, with what was said just before it, or the latest thing said */
     last?: string;
+    /** said since the last tool call */
+    said?: string;
+    /** what the agent is doing now: `says: …`, `thinks: …` or `runs: …` */
+    now?: string;
+    /** the last few `now` lines, oldest first */
+    recent: string[];
     /** the latest lines, oldest first */
     lines: EventLine[];
 }
@@ -27,6 +29,10 @@ export interface NowRow {
     sinceMs: number;
     stage?: Stage;
     act?: Activity;
+    /** what it is doing now, in one line */
+    now?: string;
+    /** the last few such lines, oldest first */
+    recent?: string[];
 }
 export interface TokenRow extends ModelSpend {
     stage: Stage;
@@ -61,6 +67,10 @@ export interface Snapshot {
     /** the latest step failures, newest first */
     errors: StepFailure[];
 }
+/** What the applier runs once the agent is done. */
+export declare const CHECK_NOW = "runs: zen check --no-models --no-sandbox";
+/** `now` lines a step keeps. */
+export declare const KEEP_NOW = 6;
 /** Reads only what each events file gained since the last look; a file cleared for a new step starts over. */
 export declare class Tails {
     #private;

package/dist/meta/finetune/live.js

@@ -7,7 +7,27 @@ const KEEP_ERRORS = 5;
 const PHASE_WORD = { nomem: 'no memory', mem: 'with memory' };
 /** Not log rows: a start shows in `now` and ends in an event of its own, an error has its own section. */
 const UNLOGGED = new Set(['run', 'analyze', 'apply', 'memory merge', 'idle', 'error']);
-const blank = () => ({ calls: 0, input: 0, output: 0, byModel: {}, lines: [] });
+/** Shell tools: their subject is the command itself. */
+const SHELL = new Set(['bash', 'run_command', 'run_command_background']);
+/** What the applier runs once the agent is done. */
+export const CHECK_NOW = 'runs: zen check --no-models --no-sandbox';
+/** `now` lines a step keeps. */
+export const KEEP_NOW = 6;
+const blank = () => ({
+    calls: 0,
+    input: 0,
+    output: 0,
+    byModel: {},
+    recent: [],
+    lines: [],
+});
+function doing(a, line) {
+    a.now = line;
+    a.recent.push(line);
+    if (a.recent.length > KEEP_NOW) {
+        a.recent.shift();
+    }
+}
 function fold(a, text) {
     let e;
     try {
@@ -26,16 +46,24 @@ function fold(a, text) {
         a.calls++;
         a.input += e.in;
         a.output += e.out;
-        const m = (a.byModel[model] ??= { calls: 0, input: 0, output: 0 });
+        const m = (a.byModel[model] ??= { calls: 0, input: 0, cached: 0, output: 0, reasoning: 0 });
         m.calls++;
         m.input += e.in;
+        m.cached += e.cached;
         m.output += e.out;
+        m.reasoning += e.reasoning;
     }
     else if (e.type === 'tool' && e.phase === 'start') {
-        a.last = `${e.name} ${e.subject}`.trim();
+        const tool = `${e.name} ${e.subject}`.trim();
+        a.last = a.said ? `${a.said} · ${tool}` : tool;
+        a.said = undefined;
+        doing(a, `runs: ${SHELL.has(e.name) && e.subject ? e.subject : tool}`);
     }
-    else if (e.type === 'say') {
+    else if (e.type === 'say' || e.type === 'think') {
+        // A call's thought comes before what it said, so the words win.
+        a.said = e.text;
         a.last = e.text;
+        doing(a, `${e.type === 'say' ? 'says' : 'thinks'}: ${e.text}`);
     }
 }
 /** Reads only what each events file gained since the last look; a file cleared for a new step starts over. */
@@ -117,27 +145,34 @@ export function snapshot(t) {
         if (!w.case || (w.step !== 'run' && w.step !== 'analyze')) {
             continue;
         }
-        const dir = t.attemptDir(w.case, w.phase ?? 'nomem', w.attempt ?? 1);
+        const dir = t.workDir({ ...w, case: w.case });
+        const act = watch(join(dir, w.step === 'run' ? 'events.jsonl' : 'analyze.events.jsonl'));
         now.push({
             key: `w${w.slot}`,
             who: `worker ${w.slot}`,
             step: w.step,
-            what: `${w.case.id} · ${PHASE_WORD[w.phase ?? 'nomem']} try ${w.attempt ?? 1}`,
+            what: `${w.case.id} · ${w.recheck ? 'recheck' : PHASE_WORD[w.phase ?? 'nomem']} try ${w.attempt ?? 1}`,
             sinceMs: clock - w.since,
             stage: w.step,
-            act: watch(join(dir, w.step === 'run' ? 'events.jsonl' : 'analyze.events.jsonl')),
+            act,
+            ...(act.now ? { now: act.now, recent: [...act.recent] } : {}),
         });
     }
     const q = t.improvements;
     if (q.current?.dir) {
+        const checking = q.current.step === 'check';
+        const act = watch(join(q.current.dir, 'apply.events.jsonl'));
+        const line = checking ? CHECK_NOW : act.now;
+        const recent = checking ? [...act.recent, CHECK_NOW].slice(-KEEP_NOW) : [...act.recent];
         now.push({
             key: 'apply',
             who: 'applier',
-            step: 'apply',
+            step: checking ? 'check' : 'apply',
             what: `apply ${basename(q.current.dir)} · ${q.current.requests} request(s)`,
             sinceMs: clock - q.current.since,
             stage: 'apply',
-            act: watch(join(q.current.dir, 'apply.events.jsonl')),
+            act,
+            ...(line ? { now: line, recent } : {}),
         });
     }
     else if (q.current) {
@@ -163,10 +198,20 @@ export function snapshot(t) {
     const sums = new Map();
     const add = (stage, model, s) => {
         const key = `${stage}\u0000${model}`;
-        const row = sums.get(key) ?? { stage, model, calls: 0, input: 0, output: 0 };
+        const row = sums.get(key) ?? {
+            stage,
+            model,
+            calls: 0,
+            input: 0,
+            cached: 0,
+            output: 0,
+            reasoning: 0,
+        };
         row.calls += s.calls;
         row.input += s.input;
+        row.cached += s.cached;
         row.output += s.output;
+        row.reasoning += s.reasoning;
         sums.set(key, row);
     };
     for (const stage of STAGES) {
@@ -218,6 +263,7 @@ export function publish(t) {
         // A live view that failed to draw must not stop the tuning.
         return undefined;
     }
+    t.live = snap;
     for (const watcher of t.watchers) {
         watcher(snap);
     }