@zenera/cli 1.1.25 → 1.1.26

package/dist/meta/finetune/report.js

@@ -1,13 +1,13 @@
-import { MERMAID_URL } from '@zenera/neo';
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync, } from 'node:fs';
 import { basename, dirname, join, relative, sep } from 'node:path';
 import { safe } from "../host.js";
 import { DatasetStore } from "./dataset/store.js";
 import { DATASET_DIR } from "./dataset/types.js";
-import { feedbackId, readFeedback } from "./feedback.js";
+import { feedbackId, forDataset, lead, readFeedback, } from "./feedback.js";
+import { RECHECK_TRIES } from "./recheck.js";
 import { resultOf, selection } from "./sampler.js";
 import { readJson } from "./tuning.js";
-import { envelopesIn, mergeModels, mergeStages, runMetrics, runTokens, short, STAGES, total, } from "./usage.js";
+import { applyTokens, envelopesIn, mergeModels, mergeStages, runMetrics, runTokens, short, STAGES, total, } from "./usage.js";
 const PHASE_WORD = { nomem: 'no memory', mem: 'with memory' };
 function atomic(file, text) {
     mkdirSync(dirname(file), { recursive: true });
@@ -19,6 +19,12 @@ export const cell = (text) => String(text ?? '')
     .replace(/\s*\n\s*/g, ' ')
     .replace(/\|/g, '\\|')
     .trim() || '-';
+/** Markdown as a blockquote, paragraphs kept. */
+const quote = (text) => text
+    .trim()
+    .split('\n')
+    .map((l) => (l.trim() ? `> ${l}` : '>'))
+    .join('\n');
 /** A link from `from` (a directory) to `to`, safe for spaces. */
 const link = (label, from, to) => `[${label}](<${relative(from, to).split(sep).join('/')}>)`;
 export function since(ms) {
@@ -32,6 +38,15 @@ export function since(ms) {
     }
     return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, '0')}m`;
 }
+/** The analyze session of one try, kept in its folder. */
+export function analyzeSession(dir) {
+    try {
+        return readFileSync(join(dir, 'session'), 'utf8').trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function attemptsOf(t, c) {
     const dir = t.caseDir(c);
     let names = [];
@@ -57,11 +72,7 @@ export function attemptsOf(t, c) {
         .sort((a, b) => Number(a.phase === 'mem') - Number(b.phase === 'mem') || a.attempt - b.attempt);
 }
 function decisions(t) {
-    const all = {};
-    for (const a of t.improvements.applies()) {
-        Object.assign(all, readJson(join(a.dir, 'decisions.json')) ?? {});
-    }
-    return all;
+    return t.improvements.decisions();
 }
 /** A run's tokens per model: recorded at the run, or read from its trajectory. */
 function runByModel(run) {
@@ -115,9 +126,14 @@ function tokenTable(by) {
         '',
     ];
 }
-const rubricScore = (f) => {
+export const rubricScore = (f) => {
     const r = Object.values(f?.rubric ?? {});
-    return r.length ? `${r.filter((x) => x === 'pass').length}/${r.length}` : '-';
+    const invalid = r.filter((x) => x === 'invalid').length;
+    const graded = r.length - invalid;
+    if (!r.length) {
+        return '-';
+    }
+    return `${r.filter((x) => x === 'pass').length}/${graded}${invalid ? ` (${invalid} invalid)` : ''}`;
 };
 // ---------------------------------------------------------------------------
 // What a run did, and how it moved from the try it is compared with
@@ -375,9 +391,10 @@ export function writeFeedback(t, c) {
     const attempts = attemptsOf(t, c);
     const latest = [...attempts].reverse().find((a) => a.feedback);
     const decided = decisions(t);
-    const session = existsSync(join(t.caseDir(c), 'session'))
-        ? readFileSync(join(t.caseDir(c), 'session'), 'utf8').trim()
-        : undefined;
+    const session = [...attempts]
+        .reverse()
+        .map((a) => analyzeSession(a.dir))
+        .find(Boolean);
     const lines = [];
     const say = (...more) => {
         lines.push(...more);
@@ -400,7 +417,10 @@ export function writeFeedback(t, c) {
         const f = latest.feedback;
         say(`## Latest analysis - ${PHASE_WORD[latest.phase]}, try ${latest.attempt}: ${f.verdict ?? '?'}, rubric ${rubricScore(f)}${f.done ? ', done' : ''}`, '');
         if (f.summary) {
-            say(`> ${cell(f.summary)}`, '');
+            say(quote(f.summary), '');
+        }
+        if (latest.run?.missedSkills?.length) {
+            say(`Never loaded the skill(s) an apply made for it: ${latest.run.missedSkills.map((s) => `\`${s}\``).join(', ')}.`, '');
         }
         const id = feedbackId(c.id, latest.phase, latest.attempt, t.round(c));
         const improvements = f.improvements ?? [];
@@ -408,11 +428,13 @@ export function writeFeedback(t, c) {
             say('### Improvements', '', '| # | Change | File | Decision |', '| --- | --- | --- | --- |');
             for (const i of improvements) {
                 const d = decided[id]?.[i.id];
-                const decision = d?.decision
-                    ? `${d.decision}${d.note ? `: ${d.note}` : ''}`
-                    : t.improvements.isApplied(id)
-                        ? 'applied (no decision recorded)'
-                        : 'waiting for an apply';
+                const decision = forDataset(i)
+                    ? 'for the dataset - `zen meta dataset`, never an apply'
+                    : d?.decision
+                        ? `${d.decision}${d.note ? `: ${d.note}` : ''}`
+                        : t.improvements.isApplied(id)
+                            ? 'applied (no decision recorded)'
+                            : 'waiting for an apply';
                 say(`| ${cell(i.id)} | ${cell(i.change)} | ${cell(i.file)} | ${cell(decision)} |`);
             }
             say('');
@@ -476,13 +498,12 @@ export function writeFeedback(t, c) {
     }
     const md = `${lines.join('\n')}\n`;
     atomic(file, md);
-    atomic(join(here, 'FEEDBACK.html'), markdownPage(`${c.id} - ${basename(t.root)}`, md, !t.finished && !resultOf(t, c)));
 }
 // ---------------------------------------------------------------------------
 // APPLY.md - one apply: every request, every decision, every file it changed
 // ---------------------------------------------------------------------------
 /** A fence longer than any run of backticks in `text`, so nothing inside can close it. */
-function fence(text) {
+export function fence(text) {
     const longest = Math.max(0, ...(text.match(/`+/g) ?? []).map((r) => r.length));
     return '`'.repeat(Math.max(3, longest + 1));
 }
@@ -526,12 +547,15 @@ export function writeApply(t, dir) {
         : '';
     const files = patchFiles(patch);
     const improvements = inputs.reduce((n, f) => n + f.improvements.length, 0);
+    const consolidation = applied?.kind === 'consolidate' || existsSync(join(dir, 'consolidate.json'));
     const status = failed
         ? 'failed - the project was put back as it was'
         : applied
-            ? applied.skipped
-                ? 'nothing to change'
-                : 'applied'
+            ? applied.discarded
+                ? `undone - ${applied.discarded}`
+                : applied.skipped
+                    ? 'nothing to change'
+                    : 'applied'
             : 'in progress';
     const started = applied?.startedAt ??
         failed?.startedAt ??
@@ -549,22 +573,32 @@ export function writeApply(t, dir) {
         }
     }
     const out = [
-        `# Apply ${name}${applied ? ` - v${applied.from} → v${applied.to}` : ''}`,
+        `# ${consolidation ? 'Consolidation' : 'Apply'} ${name}${applied && !applied.discarded ? ` - v${applied.from} → v${applied.to}` : ''}`,
         '',
         link('← status', here, join(t.dir, 'STATUS.md')),
         '',
         '| Status | Started | Finished | Took | Requests | Improvements | Files changed | Retried |',
         '| --- | --- | --- | --- | --- | --- | --- | --- |',
-        `| ${status} | ${when(started)} | ${when(finished)} | ${took} | ${inputs.length} | ${improvements} | ${files.length} | ${retried ? 'yes - the first attempt failed zen check' : 'no'} |`,
+        `| ${cell(status)} | ${when(started)} | ${when(finished)} | ${took} | ${inputs.length} | ${improvements} | ${files.length} | ${retried ? 'yes - the first attempt was undone' : 'no'} |`,
         '',
     ];
+    if (consolidation) {
+        out.push('A consolidation answers no request: it may only shrink what the agents read, and change no rule.', '');
+    }
     if (failed) {
         out.push(`> ${cell(failed.error)}`, '');
     }
     if (envelope?.sessionId) {
         out.push(`The apply session: \`zen meta resume ${basename(t.root)} ${envelope.sessionId}\` - ask it why it changed what it changed.`, '');
     }
-    out.push('## Decisions', '', '| Applied | Merged | Rejected | Structural | Undecided |', '| --- | --- | --- | --- | --- |', `| ${tally.applied ?? 0} | ${tally.merged ?? 0} | ${tally.rejected ?? 0} | ${tally.structural ?? 0} | ${tally.undecided ?? 0} |`, '', '## Requests', '');
+    if (!consolidation) {
+        const deferred = readJson(join(dir, 'deferred.json')) ?? [];
+        out.push('## Decisions', '', '| Applied | Merged | Rejected | Deferred | Structural | Undecided |', '| --- | --- | --- | --- | --- | --- |', `| ${tally.applied ?? 0} | ${tally.merged ?? 0} | ${tally.rejected ?? 0} | ${tally.deferred ?? 0} | ${tally.structural ?? 0} | ${tally.undecided ?? 0} |`, '');
+        if (deferred.length > 0) {
+            out.push(`${deferred.length} improvement(s) held back by earlier applies were offered again: ${link('deferred.json', here, join(dir, 'deferred.json'))}.`, '');
+        }
+        out.push('## Requests', '');
+    }
     inputs.forEach((f, n) => {
         const tryDir = f.file
             ? dirname(f.file)
@@ -581,9 +615,9 @@ export function writeApply(t, dir) {
             run ? link('run', here, run.dir) : '',
             run?.report ? link('report', here, run.report) : '',
         ].filter(Boolean);
-        out.push(`### ${n + 1}. ${f.case} - ${PHASE_WORD[f.phase]}, try ${f.attempt}: ${f.verdict}, rubric ${rubricScore(f)}`, '', `\`${f.id}\` · ${links.join(' · ')}`, '');
+        out.push(`### ${n + 1}. ${f.case} - ${f.recheck ? `recheck after ${f.recheck}` : PHASE_WORD[f.phase]}, try ${f.attempt}: ${f.verdict}, rubric ${rubricScore(f)}`, '', `\`${f.id}\` · ${links.join(' · ')}`, '');
         if (f.summary) {
-            out.push(`> ${cell(f.summary)}`, '');
+            out.push(quote(f.summary), '');
         }
         if (f.improvements.length === 0) {
             out.push('No improvements asked for.', '');
@@ -622,24 +656,78 @@ export function writeApply(t, dir) {
     const check = join(dir, 'check.log');
     if (existsSync(check)) {
         const tail = readFileSync(check, 'utf8').trimEnd().split('\n').slice(-40).join('\n');
-        const verdict = failed
-            ? 'failed on both attempts'
-            : retried
-                ? 'failed once; the edit was undone and the second attempt passed'
-                : applied
-                    ? 'passed'
-                    : 'running';
+        const verdict = failed ? 'failed on both attempts' : applied ? 'passed' : 'running';
         const tick = fence(tail);
         out.push(verdict, '', `${tick}text`, tail || '(no output)', tick, '');
     }
     else {
         out.push(applied?.skipped ? '_Not run: nothing was changed._' : '_Not run yet._', '');
     }
-    if (applied) {
-        out.push('## Cases sent back to run', '', ...inputs.map((f) => `- ${link(f.case, here, feedbackPath(t, { id: f.case }))} - ${PHASE_WORD[f.phase]}, try ${f.attempt + 1} on v${applied.to}`), '');
+    out.push(...gates(t, dir, applied));
+    if (applied && !consolidation) {
+        out.push('## Cases sent back to run', '', ...inputs.map((f) => f.recheck
+            ? `- ${link(f.case, here, feedbackPath(t, { id: f.case }))} - regressed after ${f.recheck}; rechecked first on v${applied.to}`
+            : `- ${link(f.case, here, feedbackPath(t, { id: f.case }))} - ${PHASE_WORD[f.phase]}, try ${f.attempt + 1} on v${applied.to}`), '');
     }
+    out.push(...recheckSection(t, here, (r) => r.apply === name));
     atomic(applyPath(dir), `${out.join('\n')}\n`);
 }
+/** The budget: what the edit cost every later call. */
+function gates(t, dir, applied) {
+    const out = [];
+    const budget = readJson(join(dir, 'budget.json'));
+    if (budget) {
+        out.push('## The prose', '', 'What every call reads, in bytes, summed over the agents: house rules, prompt, preloaded skills, skill index lines.', '', '| At the start | Before | After | Budget | Ceiling |', '| --- | --- | --- | --- | --- |', `| ${budget.start.total} | ${budget.total} | ${applied?.bytes?.after ?? '-'} | +${budget.budget} | ${budget.ceiling} |`, '');
+        const over = join(dir, 'budget.md');
+        if (existsSync(over)) {
+            out.push(readFileSync(over, 'utf8').trim().replace(/^#/gm, '###'), '');
+        }
+        const moved = join(dir, 'cost.md');
+        if (existsSync(moved)) {
+            out.push(readFileSync(moved, 'utf8').trim().replace(/^#/gm, '###'), '');
+        }
+    }
+    return out;
+}
+const RECHECK_WORD = {
+    queued: 'queued',
+    running: 'running',
+    passed: 'passed',
+    regressed: 'regressed',
+    void: 'void',
+};
+/** Rechecks, newest first: on an apply's page its own, on STATUS.md the latest. */
+function recheckSection(t, here, which, limit = 50) {
+    const all = t.rechecks.all().filter(which);
+    if (all.length === 0) {
+        return [];
+    }
+    const n = (s) => all.filter((r) => r.state === s).length;
+    const out = [
+        '## Rechecks',
+        '',
+        `Cases that passed before, run again without memory on the version an apply made. One that fails both of its ${RECHECK_TRIES} tries has regressed, and its fixes join the improvement queue.`,
+        '',
+        `passed **${n('passed')}** · regressed **${n('regressed')}** · void **${n('void')}** · queued or running **${n('queued') + n('running')}**`,
+        '',
+        '| Apply | Case | State | Tries | Request | Note |',
+        '| --- | --- | --- | --- | --- | --- |',
+    ];
+    for (const r of [...all].reverse().slice(0, limit)) {
+        const tries = t.rechecks
+            .tryDirs(r)
+            .map((d, i) => {
+            const word = r.tries?.[i] ?? 'running';
+            return existsSync(join(d, 'analysis.md'))
+                ? link(word, here, join(d, 'analysis.md'))
+                : link(word, here, d);
+        })
+            .join(', ');
+        out.push(`| ${link(r.apply, here, applyPath(join(t.improvements.dir, r.apply)))} | ${link(r.case, here, feedbackPath(t, { id: r.case }))} | ${RECHECK_WORD[r.state]} | ${tries || '-'} | ${cell(r.request)} | ${cell(r.note)} |`);
+    }
+    out.push('');
+    return out;
+}
 // ---------------------------------------------------------------------------
 // The memory section of STATUS.md
 // ---------------------------------------------------------------------------
@@ -677,256 +765,315 @@ function memorySection(t, here) {
 // ---------------------------------------------------------------------------
 // STATUS.md - the whole tuning
 // ---------------------------------------------------------------------------
-const STEP_CLASS = {
-    idle: 'idle',
-    run: 'run',
-    analyze: 'analyze',
-    parked: 'parked',
-};
-// One diagram per worker: the path its case takes through both phases, with
-// the step it is on now filled in.
+/** Longest live line in a sentence, and in a diagram box. */
+const NOW_CELL = 100;
+const NOW_LABEL = 60;
+const cut = (text, max) => text.length > max ? `${text.slice(0, max - 1).trimEnd()}…` : text;
+/** One line, every mark that would style it escaped. */
+const escaped = (text) => text
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/[\\`*_[\]<>|~&]/g, '\\$&');
+/** A live line in running text: cut, and escaped. */
+export const liveCell = (text) => text ? escaped(cut(text.replace(/\s+/g, ' ').trim(), NOW_CELL)) : '-';
+/**
+ * Several live lines in one cell, oldest first. Each ends in `<br>`, so zen view draws
+ * one row per line, cut at the width the column gets rather than wrapped.
+ */
+const liveCells = (lines) => lines?.length ? lines.map((l) => `${escaped(l)}<br>`).join('') : '-';
+/** A live line in a diagram label: only what `safe` lets through, so it cannot break out. */
+const liveLabel = (text) => text ? cut(safe(text, Number.MAX_SAFE_INTEGER), NOW_LABEL) : '';
+/** What a worker's agent is doing, if the live snapshot has it on the step the worker is on. */
+function nowOf(t, w) {
+    return liveRow(t, w)?.now;
+}
+const liveRow = (t, w) => t.live?.now.find((r) => r.key === `w${w.slot}` && r.step === w.step);
+const applierRow = (t) => t.live?.now.find((r) => r.key === 'apply');
+/** What a step under way has spent so far; it reaches the files only when the step ends. */
+const inFlight = (row) => row?.stage && row.act ? { [row.stage]: row.act.byModel } : {};
+const applierNow = (t) => applierRow(t)?.now;
 function idleWord(t) {
     if (t.improvements.applying) {
         return 'idle - no run starts during an apply';
     }
     return t.drained ? 'idle - no case left to start' : 'idle';
 }
-function workerDiagram(t, w) {
-    if (!w.case) {
-        return [
-            '```mermaid',
-            'flowchart LR',
-            `    w["worker ${w.slot} · ${idleWord(t)} · ${since(Date.now() - w.since)}"]`,
-            '    classDef idle fill:#6e7781,color:#fff',
-            '    class w idle',
-            '```',
-        ];
-    }
-    const phase = w.phase ?? 'nomem';
-    const p = phase === 'mem' ? 'm' : 'n';
-    const current = `${p}${w.step === 'analyze' ? 'a' : w.step === 'parked' ? 'p' : 'r'}`;
+const DIAGRAM_HEAD = [
+    '```mermaid',
+    '---',
+    'config:',
+    // Only the base theme takes theme variables.
+    '  theme: base',
+    '  flowchart:',
+    '    wrappingWidth: 480',
+    '  themeVariables:',
+    "    lineColor: '#8c959f'",
+    "    edgeLabelBackground: '#ffffff'",
+    '---',
+];
+// One palette for every diagram: solid fills for what is moving now, tints for the rest.
+const PALETTE = [
+    '    classDef case fill:#ffffff,stroke:#57606a,color:#24292f',
+    '    classDef idle fill:#f6f8fa,stroke:#d0d7de,color:#8c959f',
+    '    classDef run fill:#0969da,stroke:#0550ae,color:#ffffff',
+    '    classDef analyze fill:#8250df,stroke:#6639ba,color:#ffffff',
+    '    classDef off fill:#ffffff,stroke:#d0d7de,color:#57606a',
+    '    classDef busy fill:#e16f24,stroke:#bc4c00,color:#ffffff',
+    '    classDef full fill:#fff8c5,stroke:#d4a72c,color:#4d2d00',
+    '    classDef empty fill:#ffffff,stroke:#d0d7de,stroke-dasharray:4 3,color:#8c959f',
+    '    classDef kept fill:#d8f3f1,stroke:#1b7c83,color:#0b3d40',
+    '    classDef done fill:#dafbe1,stroke:#1a7f37,color:#116329',
+    '    classDef bad fill:#ffebe9,stroke:#cf222e,color:#a40e26',
+    '    classDef warn fill:#fff1e5,stroke:#e16f24,color:#953800',
+    '    classDef store fill:#ddf4ff,stroke:#54aeff,color:#0a3069',
+    '    classDef hub fill:#eaeef2,stroke:#8c959f,color:#24292f',
+];
+/** `click` lines for a diagram: only to an anchor or to a file that exists, relative to the page. */
+function clickable(t) {
+    const clicks = [];
+    return {
+        clicks,
+        click: (id, to, tip) => {
+            if (to && (to.startsWith('#') || existsSync(to))) {
+                const url = to.startsWith('#')
+                    ? to
+                    : encodeURI(relative(t.dir, to).split(sep).join('/'));
+                clicks.push(`    click ${id} href "${url}" "${tip}"`);
+            }
+        },
+    };
+}
+// Where every case is now: each step of its path, with how many cases are on it.
+function pathDiagram(t, counts) {
     const q = t.improvements;
-    const tries = phase === 'mem' ? t.config.memTries : t.config.tries;
-    const extra = (id) => {
-        if (id !== current) {
-            return '';
-        }
-        const now = ` · try ${w.attempt} of ${tries} · ${since(Date.now() - w.since)}`;
-        return w.step === 'parked'
-            ? `${now} · queue ${q.pending.length} of ${t.config.applyAt}${q.applying ? ' · applying' : ''}`
-            : now;
+    const at = (phase) => {
+        const mine = t.workers.filter((w) => w.case && (w.phase ?? 'nomem') === phase);
+        return {
+            run: mine.filter((w) => w.step !== 'analyze').length,
+            grade: mine.filter((w) => w.step === 'analyze').length,
+            wait: [...q.pending, ...q.inApply].filter((f) => f.phase === phase).length,
+        };
     };
-    const node = (id, text) => `    ${id}["${text}${extra(id)}"]`;
-    const out = [
-        '```mermaid',
-        'flowchart LR',
-        node('nr', 'no memory run'),
-        node('na', 'no memory analyze'),
-        node('np', 'no memory parked'),
-        node('mr', 'with memory run'),
-        node('ma', 'with memory analyze'),
-        node('mp', 'with memory parked'),
-        '    cd["completed"]',
-        '    df["difficult"]',
-        '    nr --> na',
-        '    na -->|"passed"| mr',
-        '    na -->|"failed, tries left"| np',
-        '    np -->|"applied"| nr',
-        '    na -->|"no tries left"| df',
-        '    mr --> ma',
-        '    ma -->|"cheaper"| cd',
-        '    ma -->|"failed, tries left"| mp',
-        '    mp -->|"applied"| mr',
-        '    ma -->|"no tries left"| df',
-        '    classDef run fill:#0969da,color:#fff',
-        '    classDef analyze fill:#8250df,color:#fff',
-        '    classDef parked fill:#9a6700,color:#fff',
-        '    classDef past fill:#d0d7de,color:#24292f',
-        '    classDef done fill:#1a7f37,color:#fff',
-        '    classDef bad fill:#cf222e,color:#fff',
-        '    class cd done',
-        '    class df bad',
-    ];
-    if (phase === 'mem') {
-        out.push('    class nr,na,np past');
+    const nomem = at('nomem');
+    const mem = at('mem');
+    const paint = {};
+    const step = (id, text, n, cls) => {
+        (paint[n > 0 ? cls : 'off'] ??= []).push(id);
+        return `${id}("${text} · ${n}")`;
+    };
+    const { clicks, click } = clickable(t);
+    const queue = anchor(`Improvement queue - ${q.pending.length} of ${t.config.applyAt} parked`);
+    click('NS', join(t.root, DATASET_DIR), 'the dataset');
+    click('NW', queue, 'the cases waiting for a fix');
+    click('MW', queue, 'the cases waiting for a fix');
+    click('CD', '#cases', 'every case');
+    if (counts.difficult > 0) {
+        click('DF', '#difficult-cases', 'the difficult cases');
+    }
+    if (counts.failed > 0) {
+        click('FL', '#failed-cases', 'the failed cases');
     }
-    out.push(`    class ${current} ${STEP_CLASS[w.step]}`, '```');
-    return out;
-}
-function overviewDiagram(counts) {
     return [
-        '```mermaid',
-        'flowchart LR',
-        `    Q["queued · ${counts.queued}"] --> N["no memory · ${counts.nomem}"]`,
-        `    N --> M["with memory · ${counts.mem}"]`,
-        `    M --> C["completed · ${counts.completed}"]`,
-        `    N --> D["difficult · ${counts.difficult}"]`,
-        '    M --> D',
-        `    Q -.-> S["stopped · ${counts.stopped}"]`,
-        ...(counts.failed ? [`    N -.-> F["failed · ${counts.failed}"]`, '    M -.-> F'] : []),
-        '    classDef done fill:#1a7f37,color:#fff',
-        '    classDef bad fill:#cf222e,color:#fff',
-        '    classDef live fill:#0969da,color:#fff',
-        '    classDef broke fill:#9a6700,color:#fff',
-        '    class C done',
-        '    class D bad',
-        '    class N,M live',
-        ...(counts.failed ? ['    class F broke'] : []),
+        'Where every case is right now. A case goes through two rounds, first **without memory**, then **with memory**. In each round it is run, then graded; a case that failed waits for a fix to the instructions and runs again.',
+        '',
+        ...DIAGRAM_HEAD,
+        // Edges end on the round boxes, never inside them, so each round keeps its own row.
+        'flowchart TB',
+        `    NS[("not started · ${counts.queued}")]`,
+        '    subgraph NOMEM["1 · without memory"]',
+        '        direction LR',
+        `        ${step('NR', 'running', nomem.run, 'run')} --> ${step('NA', 'grading', nomem.grade, 'analyze')}`,
+        `        NA -->|"failed, tries left"| ${step('NW', 'waiting for a fix', nomem.wait, 'full')}`,
+        '        NW -->|"fixed"| NR',
+        '    end',
+        '    subgraph MEM["2 · with memory"]',
+        '        direction LR',
+        `        ${step('MR', 'running', mem.run, 'run')} --> ${step('MA', 'grading', mem.grade, 'analyze')}`,
+        `        MA -->|"failed, tries left"| ${step('MW', 'waiting for a fix', mem.wait, 'full')}`,
+        '        MW -->|"fixed"| MR',
+        '    end',
+        '    NS --> NOMEM',
+        '    NOMEM -->|"passed"| MEM',
+        `    MEM -->|"passed"| CD("completed · ${counts.completed}")`,
+        `    NOMEM -->|"out of tries"| DF("difficult · ${counts.difficult}")`,
+        '    MEM -->|"out of tries"| DF',
+        ...(counts.stopped > 0
+            ? [`    ST("stopped part-way · ${counts.stopped}") -.->|"next start"| NOMEM`]
+            : []),
+        ...(counts.failed > 0
+            ? [
+                `    NOMEM -.->|"sandbox or provider broke"| FL("${lines(`failed · ${counts.failed}`, 'resumes at the next start')}")`,
+            ]
+            : []),
+        ...clicks,
+        ...PALETTE,
+        ...Object.entries(paint).map(([cls, ids]) => `    class ${ids.join(',')} ${cls}`),
+        '    class NS store',
+        '    class CD done',
+        '    class DF bad',
+        ...(counts.stopped > 0 ? ['    class ST idle'] : []),
+        ...(counts.failed > 0 ? ['    class FL warn'] : []),
+        '    style NOMEM fill:#ffffff,stroke:#d0d7de',
+        '    style MEM fill:#ffffff,stroke:#d0d7de',
         '```',
     ];
 }
-const LANE = {
-    idle: 'fill:#f6f8fa,stroke:#d0d7de',
-    parked: 'fill:#f6f8fa,stroke:#d0d7de',
-    run: 'fill:#ddf4ff,stroke:#0969da,stroke-width:2px',
-    analyze: 'fill:#fbefff,stroke:#8250df,stroke-width:2px',
+const STEP_WORD = {
+    idle: 'idle',
+    run: 'running',
+    analyze: 'grading',
+    parked: 'parked',
 };
-// A subgraph linked from outside drops its own direction; invisible links keep the slots in order.
+// Edges end on the box, so it keeps LR; the invisible chain keeps the slots in order.
 const inOrder = (prefix, n) => n > 1
     ? [`        ${Array.from({ length: n }, (_, i) => `${prefix}${i + 1}`).join(' ~~~ ')}`]
     : [];
 // A markdown label: real newlines, since some previews swallow `<br/>` before Mermaid sees it.
-const lines = (...parts) => `\`${parts.join('\n')}\``;
-// The whole machine right now: every worker, the queue filling toward an apply, the merge.
-// Each node links to what it is working on.
-function systemDiagram(t, counts) {
+const lines = (...parts) => `\`${parts.filter(Boolean).join('\n')}\``;
+// The page's own heading ids, so a box can link to the section listing it in full.
+const anchor = (heading) => `#${heading
+    .trim()
+    .toLowerCase()
+    .replace(/[^\w\s-]/g, '')
+    .replace(/\s/g, '-')}`;
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+// The whole machine right now: plain words first, then one box per moving part.
+// Each box links to what it is working on, or to the section that lists it.
+function systemDiagram(t, counts, last) {
     const q = t.improvements;
     const m = t.memories;
-    const lit = {
-        case: [],
-        run: [],
-        analyze: [],
-        off: [],
-        full: [],
-        empty: [],
-        busy: [],
-        kept: [],
-    };
-    const clicks = [];
-    const click = (id, to, tip) => {
-        if (to && (to.startsWith('#') || existsSync(to))) {
-            const url = to.startsWith('#')
-                ? to
-                : encodeURI(relative(t.dir, to).split(sep).join('/'));
-            clicks.push(`    click ${id} href "${url}" "${tip}"`);
-        }
+    const { applyAt, mergeEvery } = t.config;
+    const applying = q.applying;
+    const took = q.current ? since(Date.now() - q.current.since) : '';
+    const waiting = m.unmerged();
+    const merged = m.merges().filter((x) => x.ok);
+    const running = t.workers.filter((w) => w.case && w.step === 'run').length;
+    const grading = t.workers.filter((w) => w.case && w.step === 'analyze').length;
+    const rechecking = t.workers.filter((w) => w.case && w.recheck).length;
+    const rechecksQueued = t.rechecks.all().filter((r) => r.state === 'queued').length;
+    const paint = {};
+    const fill = (id, cls) => {
+        (paint[cls] ??= []).push(id);
     };
+    const { clicks, click } = clickable(t);
     const out = [
-        '```mermaid',
-        '---',
-        'config:',
-        '  flowchart:',
-        '    wrappingWidth: 480',
-        '---',
+        ...DIAGRAM_HEAD,
         'flowchart TB',
-        `    DS[("dataset · ${counts.queued} queued")] --> D["${lines('dispatcher', 'seats a case on a free worker', 'woken cases first')}"]`,
+        `    DS[("${lines('**cases**', `${counts.queued} not started`)}")]`,
+        `    DS -->|"next case"| WORKERS`,
         `    subgraph WORKERS["workers · ${t.busy()} of ${t.workers.length} busy"]`,
         '        direction LR',
     ];
     click('DS', join(t.root, DATASET_DIR), 'the dataset');
-    click('D', join(t.dir, 'events.jsonl'), 'every step, in order');
-    const lanes = [];
+    const paused = applying ? 'paused · fixes' : t.drained ? 'nothing left to start' : 'idle';
     for (const w of t.workers) {
-        const n = w.slot;
-        const step = w.case ? w.step : 'idle';
-        let label = idleWord(t);
-        if (w.case) {
-            const tries = w.phase === 'mem' ? t.config.memTries : t.config.tries;
-            label =
-                w.attempt === undefined
-                    ? lines(`**${safe(w.case.id, 48)}**`, 'starting')
-                    : lines(`**${safe(w.case.id, 48)}**`, `${PHASE_WORD[w.phase ?? 'nomem']} · try ${w.attempt} of ${tries} · ${step} ${since(Date.now() - w.since)}`);
-            click(`C${n}`, feedbackPath(t, w.case), 'the case: rubric, tries, decisions');
-            if (w.attempt !== undefined) {
-                const dir = t.attemptDir(w.case, w.phase ?? 'nomem', w.attempt);
-                const run = readJson(join(dir, 'run.json'));
-                if (run) {
-                    click(`R${n}`, run.report ?? run.dir, 'the run report');
-                }
-                else {
-                    click(`R${n}`, join(dir, 'run.log'), 'the run log, live');
-                }
-                if (existsSync(join(dir, 'analysis.md'))) {
-                    click(`A${n}`, join(dir, 'analysis.md'), 'the analysis');
-                }
-                else {
-                    click(`A${n}`, join(dir, 'analyze.log'), 'the analysis log, live');
-                }
-            }
-        }
-        out.push(`        subgraph W${n}["worker ${n}"]`, '            direction TB', `            C${n}["${label}"] --> R${n}["run"] --> A${n}["analyze"]`, '        end');
-        lit[w.case ? 'case' : 'empty'].push(`C${n}`);
-        lit[step === 'run' ? 'run' : 'off'].push(`R${n}`);
-        lit[step === 'analyze' ? 'analyze' : 'off'].push(`A${n}`);
-        lanes.push(`    style W${n} ${LANE[step]}`);
-    }
-    // Edges go to the box, not its nodes, so it keeps LR and the chain puts the lanes in slot order.
-    out.push(...inOrder('W', t.workers.length), '    end', '    D --> WORKERS', 
-    // Not a diamond: an edge to a box ends at the node's bounding box, short of a diamond's sides.
-    '    WORKERS --> V(["feedback done?"])', `    V -.->|"${lines('passed without memory:', 'again with memory')}"| WORKERS`, `    V -->|"${lines('failed, tries left:', 'park, free the worker')}"| Q`, `    V -->|"no tries left"| X["difficult · ${counts.difficult}"]`, `    V -->|"passed with memory"| CD["completed · ${counts.completed}"]`, `    subgraph Q["improvement queue · ${q.pending.length} of ${t.config.applyAt}"]`, '        direction LR');
-    click('X', '#difficult-cases', 'the difficult cases');
-    click('CD', '#cases', 'every case');
-    const slots = Math.max(t.config.applyAt, q.pending.length);
-    for (let i = 0; i < slots; i++) {
-        const f = q.pending[i];
-        out.push(f
-            ? `        Q${i + 1}["${lines(`**${safe(f.case, 40)}**`, `${PHASE_WORD[f.phase]} try ${f.attempt} · ${f.improvements.length} improvement(s)`)}"]`
-            : `        Q${i + 1}["empty"]`);
-        lit[f ? 'full' : 'empty'].push(`Q${i + 1}`);
-        if (f) {
-            const dir = t.attemptDir({ id: f.case, rev: f.caseRev }, f.phase, f.attempt);
-            click(`Q${i + 1}`, join(dir, 'analysis.md'), 'the analysis asking for these');
+        const id = `W${w.slot}`;
+        if (!w.case) {
+            out.push(`        ${id}("${lines(`**worker ${w.slot}**`, paused)}")`);
+            fill(id, 'idle');
+            continue;
         }
+        const tries = w.recheck
+            ? RECHECK_TRIES
+            : w.phase === 'mem'
+                ? t.config.memTries
+                : t.config.tries;
+        const started = w.attempt !== undefined;
+        const what = w.recheck
+            ? `recheck after ${w.recheck.apply}`
+            : PHASE_WORD[w.phase ?? 'nomem'];
+        out.push(`        ${id}("${lines(`**worker ${w.slot}** · ${started ? `${STEP_WORD[w.step]} ${since(Date.now() - w.since)}` : 'starting'}`, safe(w.case.id, 36), started ? `${what} · try ${w.attempt} of ${tries}` : '', started ? liveLabel(nowOf(t, w)) : '')}")`);
+        fill(id, w.step === 'run' ? 'run' : w.step === 'analyze' ? 'analyze' : 'case');
+        click(id, w.recheck ? w.recheck.dir : feedbackPath(t, w.case), w.recheck ? 'this recheck try' : 'the case: rubric, tries, decisions');
     }
-    out.push(...inOrder('Q', slots));
-    const last = q.applies().at(-1);
-    const applier = !q.applying
-        ? `idle${last ? ` · last ${last.name}` : ''}`
-        : q.inApply.length > 0
-            ? `applying ${q.inApply.length} request(s) · no run starts`
-            : 'waiting for runs · no run starts';
-    out.push('    end', 
-    // AP's own nodes link outside, so Mermaid cannot end an edge on the AP box itself.
-    '    Q -->|"full, or nothing left to start"| P1', `    subgraph AP["applier · ${applier}"]`, `        P1["wait for runs in flight · ${q.runs}"] --> P2["${lines('meta run /finetune-apply', 'then zen check')}"]`, `        P2 --> P3["${lines('applied.json', 'wake the batch')}"]`, '    end', `    P2 -->|"writes the next version"| S[("${lines(`system prose · v${t.system.version()}`, 'read by every new run')}")]`, '    P3 -->|"wake"| D');
-    const active = !q.applying ? undefined : q.runs > 0 ? 'P1' : 'P2';
-    for (const p of ['P1', 'P2', 'P3']) {
-        lit[p === active ? 'busy' : 'off'].push(p);
-    }
-    if (last) {
-        click('P2', applyPath(last.dir), q.applying ? 'this apply' : 'the last apply');
-        click('P3', join(last.dir, 'diff.patch'), 'what the last apply changed');
-    }
-    click('S', t.system.snapshotDir(t.system.version()), 'this version of the prose');
-    const waiting = m.unmerged();
-    const kept = Math.max(t.config.mergeEvery, waiting.length);
-    out.push('    CD -->|"keep its memory"| M', `    subgraph M["memory to merge · ${waiting.length} of ${t.config.mergeEvery}"]`, '        direction LR');
-    for (let i = 0; i < kept; i++) {
-        const s = waiting[i];
-        out.push(`        K${i + 1}["${s ? safe(s.case, 40) : 'empty'}"]`);
-        lit[s ? 'kept' : 'empty'].push(`K${i + 1}`);
-        if (s) {
-            click(`K${i + 1}`, s.dir, 'the kept memory');
-        }
+    const queued = q.pending
+        .slice(0, 8)
+        .map((f) => `${safe(f.case, 32)} · ${plural(f.improvements.length, 'fix', 'fixes')}`);
+    if (q.pending.length > 8) {
+        queued.push(`and ${q.pending.length - 8} more`);
+    }
+    const applier = applying
+        ? q.runs > 0
+            ? `waiting for ${plural(q.runs, 'run')} to finish`
+            : [
+                `${plural(q.inApply.length, 'case')} · ${took}`,
+                liveLabel(applierNow(t)) || (q.current?.step === 'check' ? 'zen check' : ''),
+            ]
+                .filter(Boolean)
+                .join('\n')
+        : `idle${last ? ` · last ${last.name}` : ''}`;
+    out.push(...inOrder('W', t.workers.length), '    end', '    WORKERS --> V(["graded"])', `    V -.->|"${lines('passed without memory:', 'again with memory')}"| WORKERS`, `    V -->|"out of tries"| X("difficult · ${counts.difficult}")`, `    V -->|"${lines('failed, tries left,', 'or a recheck failed')}"| Q`, `    V -->|"passed with memory"| CD`, '    subgraph LEARN["fixing the instructions"]', `        Q("${lines(`**waiting for a fix · ${q.pending.length} of ${applyAt}**`, ...(queued.length ? queued : ['empty']))}")`, `        Q -->|"${lines(`${applyAt} waiting, or`, 'nothing else to run')}"| P("${lines('**apply fixes**', 'an agent edits the instructions', 'and tidies what it touched', applier)}")`, `        P -->|"new version"| S[("${lines(`**instructions · v${t.system.version()}**`, 'every new run reads these')}")]`, '    end', ...(t.config.recheck > 0
+        ? [
+            `    S -.->|"${lines(`recheck ${t.config.recheck} cases that passed`, `${rechecksQueued} queued`)}"| WORKERS`,
+        ]
+        : []));
+    fill('Q', q.pending.length > 0 ? 'full' : 'empty');
+    fill('P', applying ? 'busy' : 'off');
+    click('Q', anchor(`Improvement queue - ${q.pending.length} of ${applyAt} parked`), 'every case waiting, with what it asks for');
+    const applied = applying && q.current?.dir ? q.current.dir : last?.dir;
+    if (applied) {
+        click('P', applyPath(applied), applying ? 'this apply' : 'the last apply');
+    }
+    click('S', t.system.snapshotDir(t.system.version()), 'this version of the instructions');
+    const kept = waiting.slice(0, 6).map((s) => safe(s.case, 32));
+    if (waiting.length > 6) {
+        kept.push(`and ${waiting.length - 6} more`);
+    }
+    out.push('    subgraph KEEP["keeping memory"]', `        CD("completed · ${counts.completed}") -->|"keep its memory"| M("${lines(`**memory to merge · ${waiting.length} of ${mergeEvery}**`, ...(kept.length ? kept : ['empty']))}")`, `        M -->|"${lines(`${mergeEvery} waiting, or`, 'the tuning ends')}"| MG[("${lines('**merged memory**', plural(merged.length, 'graph'))}")]`, '    end');
+    fill('M', waiting.length > 0 ? 'kept' : 'empty');
+    if (m.submissions().length > 0 || m.merges().length > 0) {
+        click('M', '#memory', 'every kept memory and merge');
     }
-    const merged = m.merges().filter((x) => x.ok);
     click('MG', merged.at(-1)?.dir, 'the latest merged graph');
-    out.push(...inOrder('K', kept), '    end', `    M -->|"full, or tuning ends"| MG[("merged graphs · ${merged.length}")]`, ...clicks, '    classDef case fill:#ffffff,stroke:#57606a,color:#24292f', '    classDef run fill:#0969da,stroke:#0550ae,color:#ffffff', '    classDef analyze fill:#8250df,stroke:#6639ba,color:#ffffff', '    classDef off fill:#ffffff,stroke:#d0d7de,color:#8c959f', '    classDef full fill:#d4a72c,stroke:#9a6700,color:#ffffff', '    classDef empty fill:#ffffff,stroke:#d0d7de,stroke-dasharray:4 3,color:#8c959f', '    classDef busy fill:#e16f24,stroke:#bc4c00,color:#ffffff', '    classDef kept fill:#1b7c83,stroke:#136061,color:#ffffff', '    classDef done fill:#1a7f37,stroke:#116329,color:#ffffff', '    classDef bad fill:#cf222e,stroke:#a40e26,color:#ffffff', '    classDef store fill:#ddf4ff,stroke:#54aeff,color:#0a3069', '    classDef hub fill:#eaeef2,stroke:#57606a,color:#24292f', ...Object.entries(lit)
-        .filter(([, ids]) => ids.length > 0)
-        .map(([cls, ids]) => `    class ${ids.join(',')} ${cls}`), '    class CD done', '    class X bad', '    class DS,S,MG store', '    class D,V hub', '    style WORKERS fill:#ffffff,stroke:#8c959f', ...lanes, `    style Q fill:#fff8c5,stroke:#d4a72c${q.pending.length >= t.config.applyAt ? ',stroke-width:3px' : ''}`, `    style AP ${q.applying ? 'fill:#fff1e5,stroke:#e16f24,stroke-width:3px' : 'fill:#f6f8fa,stroke:#d0d7de'}`, '    style M fill:#e6f6f5,stroke:#1b7c83', '```');
-    const running = lit.run.length;
-    const analyzing = lit.analyze.length;
-    const now = [
-        running > 0 && `- **Blue** - ${running} worker(s) running a case`,
-        analyzing > 0 && `- **Purple** - ${analyzing} worker(s) analyzing the run just finished`,
-        q.applying &&
-            '- **Orange** - fixes are being applied to the agent instructions; no new run starts until that is done',
-        q.pending.length > 0 &&
-            `- **Yellow** - ${q.pending.length} failed case(s) waiting for fixes; they are applied when ${t.config.applyAt} wait, or when no other case can run`,
-        waiting.length > 0 &&
-            `- **Teal** - memory from ${waiting.length} passed case(s) waiting to be merged; merged when ${t.config.mergeEvery} wait`,
-    ].filter((x) => typeof x === 'string');
+    if (counts.difficult > 0) {
+        click('X', '#difficult-cases', 'the difficult cases');
+    }
+    click('CD', '#cases', 'every case');
+    out.push(...clicks, ...PALETTE, ...Object.entries(paint).map(([cls, ids]) => `    class ${ids.join(',')} ${cls}`), '    class CD done', '    class X bad', '    class DS,S,MG store', '    class V hub', '    style WORKERS fill:#ffffff,stroke:#d0d7de', '    style LEARN fill:#fffdf5,stroke:#e6d9a8', '    style KEEP fill:#f5fbfa,stroke:#a8d8d3', ...(q.pending.length >= applyAt ? ['    style Q stroke-width:3px'] : []), '```');
+    const now = [];
+    const workers = t.workers.length;
+    if (applying) {
+        now.push(q.runs > 0
+            ? `- **About to write fixes into the instructions** (orange): waiting for the ${plural(q.runs, 'run')} in progress to finish, so none of them reads half-edited instructions. No new case starts meanwhile.`
+            : `- **Writing fixes into the instructions** (orange) for ${plural(q.inApply.length, 'case')} - running for ${took}. No case starts until it is done; then those cases run again on the new version, and ${plural(t.config.recheck, 'case')} that passed before are rechecked on it.`);
+    }
+    if (running + grading > 0) {
+        const doing = [
+            running > 0 ? `${running} running a case (blue)` : '',
+            grading > 0 ? `${grading} grading a finished run (purple)` : '',
+        ].filter(Boolean);
+        now.push(`- **${t.busy()} of ${workers} workers busy**: ${doing.join(', ')}${rechecking > 0 ? ` - ${rechecking} of them rechecking a case that passed before` : ''}.`);
+    }
+    if (rechecksQueued > 0) {
+        now.push(`- **${plural(rechecksQueued, 'recheck')} queued**: cases that passed, to run again on the latest instructions before any new case starts.`);
+    }
+    if (q.pending.length > 0) {
+        now.push(`- **${plural(q.pending.length, 'case')} waiting for a fix** (yellow). Their fixes are written once ${applyAt} are waiting, or when nothing else is left to run${applying ? ' - in the round after this one' : ''}.`);
+    }
+    if (counts.queued > 0) {
+        now.push(`- **${plural(counts.queued, 'case')} not started yet.**`);
+    }
+    if (waiting.length > 0) {
+        now.push(`- **${plural(waiting.length, 'finished case')} with memory to merge** (teal); memories are merged ${mergeEvery} at a time.`);
+    }
     return [
-        ...(now.length > 0 ? ['Now:', '', ...now] : ['Nothing is in progress right now.']),
+        ...(now.length > 0 ? ['**Right now**', '', ...now] : ['Nothing is running right now.']),
+        '',
+        '<details>',
+        '<summary>How this works</summary>',
+        '',
+        `1. A worker takes a case and runs the agents on it **without memory**; then another agent grades the run against the case's rubric.`,
+        `2. **Failed:** the grader suggests fixes to the agents' instructions. The case waits for a fix (yellow) and its worker takes another case.`,
+        `3. Once ${applyAt} cases are waiting, or nothing else is left to run, one agent writes their fixes into the instructions - an **apply** (orange) - and tidies up the files it touched: repeated rules merged, contradictions cut. No case starts while the instructions change; afterwards the waiting cases run again on the new version.`,
+        ...(t.config.recheck > 0
+            ? [
+                `4. After each apply, ${plural(t.config.recheck, 'case')} that passed before **run again** on the new version, as ordinary work - a recheck. One that fails ${RECHECK_TRIES} tries has regressed: its fixes wait for the next apply like any other.`,
+            ]
+            : []),
+        `${t.config.recheck > 0 ? 5 : 4}. **Passed:** the case runs again **with memory**. When that passes too, the case is completed and its memory is kept; kept memories are merged ${mergeEvery} at a time (teal).`,
+        `${t.config.recheck > 0 ? 6 : 5}. A case still failing after ${plural(t.config.tries, 'try', 'tries')} without memory, or ${t.config.memTries} with, is marked **difficult**.`,
+        '',
+        '</details>',
         '',
         'Click a box to open it.',
         '',
@@ -965,10 +1112,12 @@ function summarySection(spent, tuning, memory) {
     }
     return out;
 }
-export function writeStatus(t) {
+function slowStatus(t) {
     const here = t.dir;
+    const q = t.improvements;
     const cases = selection(t);
     const store = DatasetStore.open(t.root);
+    const byCase = new Map();
     const counts = {
         queued: 0,
         nomem: 0,
@@ -980,6 +1129,7 @@ export function writeStatus(t) {
     };
     const rows = [];
     const difficult = [];
+    const rubricProblems = [];
     const failed = [];
     let everything = {};
     const spent = {
@@ -988,6 +1138,24 @@ export function writeStatus(t) {
     };
     const tuning = { passed: 0, first: 0, before: blank(), after: blank() };
     const memory = { cases: 0, cheaper: 0, before: blank(), after: blank() };
+    const lastRun = (a) => {
+        if (!a) {
+            return '-';
+        }
+        const links = [
+            a.run ? link('run', here, a.run.dir) : '',
+            a.run?.report ? link('report', here, a.run.report) : '',
+            existsSync(join(a.dir, 'run.log')) ? link('run log', here, join(a.dir, 'run.log')) : '',
+            existsSync(join(a.dir, 'analysis.md'))
+                ? link('analysis', here, join(a.dir, 'analysis.md'))
+                : '',
+            existsSync(join(a.dir, 'analyze.log'))
+                ? link('analyze log', here, join(a.dir, 'analyze.log'))
+                : '',
+        ].filter(Boolean);
+        return `${PHASE_WORD[a.phase]} try ${a.attempt}: ${links.join(' · ') || '-'}`;
+    };
+    const stamp = (iso) => `${iso.slice(0, 19).replace('T', ' ')} UTC`;
     for (const c of cases) {
         const w = t.workers.find((x) => x.case?.id === c.id);
         const parked = t.improvements.pending.find((f) => f.case === c.id) ??
@@ -1015,6 +1183,7 @@ export function writeStatus(t) {
         const calls = nomem.map((a) => a.run?.turns).filter((n) => n !== undefined);
         const memCalls = mem.map((a) => a.run?.turns).filter((n) => n !== undefined);
         const caseBy = caseTokens(t, c);
+        byCase.set(`${c.id}@${c.rev}`, caseBy);
         everything = mergeStages(everything, caseBy);
         for (const a of attempts) {
             const f = runFlat(a.run);
@@ -1050,112 +1219,169 @@ export function writeStatus(t) {
             : '-';
         rows.push(`| ${link(c.id, here, feedbackPath(t, c))} | ${cell(c.class)} | ${c.rubric.length} | ${cell(stateOf(t, c))} | ${nomem.length} / ${mem.length} | ${cell(last?.feedback?.verdict)} ${rubricScore(last?.feedback)} | ${calls.length ? `${calls[0]} → ${calls.at(-1)}` : '-'} | ${memCalls.length ? memCalls.at(-1) : '-'} | ${effect} | ${inOut(caseBy.run)} | ${inOut(caseBy.analyze)} | ${attempts.at(-1)?.run ? `v${attempts.at(-1).run.system}` : '-'} |`);
         if (r?.state === 'difficult') {
-            difficult.push(`| ${link(c.id, here, feedbackPath(t, c))} | ${PHASE_WORD[r.phase]} | ${cell(r.reason)} | ${r.phase === 'nomem' ? nomem.length : mem.length} | ${cell(last?.feedback?.summary)} | ${last && existsSync(join(last.dir, 'analysis.md')) ? link('last analysis', here, join(last.dir, 'analysis.md')) : '-'} |`);
+            difficult.push(`| ${link(c.id, here, feedbackPath(t, c))} | ${PHASE_WORD[r.phase]} | ${cell(r.reason)} | ${r.phase === 'nomem' ? nomem.length : mem.length} | ${stamp(r.at)} | ${cell(lead(last?.feedback?.summary ?? ''))} | ${lastRun(attempts.at(-1))} |`);
+        }
+        const broken = Object.entries(last?.feedback?.rubric ?? {})
+            .filter(([, g]) => g === 'invalid')
+            .map(([id]) => id);
+        if (broken.length > 0) {
+            const why = (last?.feedback?.improvements ?? []).filter(forDataset);
+            rubricProblems.push(`| ${link(c.id, here, feedbackPath(t, c))} | ${broken.join(', ')} | ${cell(why.map((i) => i.change).join(' / '))} |`);
         }
         if (r?.state === 'failed') {
-            failed.push(`| ${link(c.id, here, feedbackPath(t, c))} | ${PHASE_WORD[r.phase]}, try ${(r.phase === 'nomem' ? nomem : mem).length || 1} | ${cell(r.reason)} | ${r.at.slice(11, 16)} |`);
+            failed.push(`| ${link(c.id, here, feedbackPath(t, c))} | ${PHASE_WORD[r.phase]}, try ${(r.phase === 'nomem' ? nomem : mem).length || 1} | ${cell(r.reason)} | ${stamp(r.at)} | ${lastRun(attempts.at(-1))} |`);
         }
     }
+    const later = [];
+    const applies = q.applies();
+    if (applies.length > 0) {
+        later.push('## Applies', '', 'Each apply links to its own page: every request, every decision, every file changed and why. Prose is the change in what every call reads, in bytes, summed over the agents.', '', '| Apply | Versions | At | Requests | Applied | Merged | Rejected | Deferred | Structural | Prose | Files changed | Tokens | Details |', '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |');
+        for (const a of [...applies].reverse()) {
+            const d = readJson(join(a.dir, 'decisions.json')) ?? {};
+            const tally = {};
+            for (const byImprovement of Object.values(d)) {
+                for (const x of Object.values(byImprovement)) {
+                    tally[x.decision ?? '?'] = (tally[x.decision ?? '?'] ?? 0) + 1;
+                }
+            }
+            const patch = join(a.dir, 'diff.patch');
+            const files = existsSync(patch)
+                ? (readFileSync(patch, 'utf8').match(/^diff --git /gm) ?? []).length
+                : 0;
+            const details = [
+                existsSync(join(a.dir, 'changes.md'))
+                    ? link('changes', here, join(a.dir, 'changes.md'))
+                    : '',
+                existsSync(patch) ? link('diff', here, patch) : '',
+                existsSync(join(a.dir, 'decisions.json'))
+                    ? link('decisions', here, join(a.dir, 'decisions.json'))
+                    : '',
+            ].filter(Boolean);
+            const versions = a.applied
+                ? a.applied.discarded
+                    ? `undone at v${a.applied.from}`
+                    : `v${a.applied.from} → v${a.applied.to}`
+                : existsSync(join(a.dir, 'failed.json'))
+                    ? 'failed'
+                    : 'in progress';
+            const prose = a.applied?.bytes
+                ? `${a.applied.bytes.after - a.applied.bytes.before > 0 ? '+' : ''}${a.applied.bytes.after - a.applied.bytes.before}`
+                : '-';
+            const what = a.applied?.kind === 'consolidate' || existsSync(join(a.dir, 'consolidate.json'))
+                ? `${link(a.name, here, applyPath(a.dir))} consolidation`
+                : link(a.name, here, applyPath(a.dir));
+            later.push(`| ${what} | ${versions} | ${a.applied?.at.slice(11, 16) ?? '-'} | ${a.inputs?.length ?? 0} | ${tally.applied ?? 0} | ${tally.merged ?? 0} | ${tally.rejected ?? 0} | ${tally.deferred ?? 0} | ${tally.structural ?? 0} | ${prose} | ${files} | ${inOut(applyTokens(a.dir))} | ${details.join(' · ') || (a.applied?.skipped ? 'nothing to change' : '-')} |`);
+        }
+        later.push('');
+    }
+    later.push(...recheckSection(t, here, () => true, 30));
+    const allStages = mergeStages(everything, t.rechecks.tokens(), {
+        apply: mergeModels(...applies.map((a) => applyTokens(a.dir))),
+    });
+    t.progress = { counts, total: cases.length, spent: allStages };
+    const rest = [...memorySection(t, here)];
+    rest.push('## Cases', '', '| Case | Class | Rubric | State | Tries without / with | Last verdict | LLM calls without memory | With memory | Memory effect | Run tokens | Analyze tokens | System |', '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |', ...rows, '');
+    if (difficult.length > 0) {
+        rest.push('## Difficult cases', '', '| Case | Phase | Reason | Tries | Difficult since | Last summary | Last run |', '| --- | --- | --- | --- | --- | --- | --- |', ...difficult, '');
+    }
+    if (rubricProblems.length > 0) {
+        rest.push('## Rubric problems', '', 'Lines the latest analysis graded `invalid`: they say how one implementation did it, not what a right answer is. No apply touches them - fix the case with `zen meta dataset`.', '', '| Case | Lines | What is wrong |', '| --- | --- | --- |', ...rubricProblems, '');
+    }
+    if (failed.length > 0) {
+        rest.push('## Failed cases', '', 'Something outside the prose broke - the sandbox, a provider, a key - so these taught nothing. They keep their tries and carry on from the step that failed at the next `zen meta finetune start`.', '', '| Case | Stopped at | Reason | Failed at | Last run |', '| --- | --- | --- | --- | --- |', ...failed, '');
+    }
+    return {
+        total: cases.length,
+        revision: store.manifest.revision,
+        counts,
+        summary: summarySection(spent, tuning, memory),
+        applies: applies.length,
+        lastApply: applies.at(-1),
+        byCase,
+        spent: allStages,
+        later,
+        rest,
+    };
+}
+const slowParts = new WeakMap();
+/** `live` reuses the parts read from every case and apply; only what moves by the second is read. */
+export function writeStatus(t, live = false) {
+    const here = t.dir;
+    let s = live ? slowParts.get(t) : undefined;
+    if (!s) {
+        s = slowStatus(t);
+        slowParts.set(t, s);
+    }
+    const counts = s.counts;
     const done = counts.completed + counts.difficult;
-    const bar = cases.length ? Math.round((done / cases.length) * 20) : 0;
+    const bar = s.total ? Math.round((done / s.total) * 20) : 0;
     const state = t.finished ? 'finished' : t.stopping ? 'stopping' : 'running';
     const q = t.improvements;
     const out = [
         `# Fine-tuning - ${basename(t.root)}`,
         '',
         `**${state}** · started ${new Date(t.startedAt).toISOString().slice(0, 16).replace('T', ' ')} · elapsed ${since(Date.now() - t.startedAt)} · updated ${new Date().toISOString().slice(11, 19)}`,
-        `system **v${t.system.version()}** (applies: ${q.applies().length}) · dataset rev **${store.manifest.revision}** · workers **${t.workers.filter((w) => w.case).length} / ${t.workers.length}** · apply at **${t.config.applyAt}** · tries ${t.config.tries} without memory, ${t.config.memTries} with`,
+        `system **v${t.system.version()}** (applies: ${s.applies}) · dataset rev **${s.revision}** · workers **${t.workers.filter((w) => w.case).length} / ${t.workers.length}** · apply at **${t.config.applyAt}** · tries ${t.config.tries} without memory, ${t.config.memTries} with`,
         '',
-        `\`${'█'.repeat(bar)}${'░'.repeat(20 - bar)}\` ${done} of ${cases.length} cases done - ${counts.completed} completed, ${counts.difficult} difficult${counts.failed ? ` · ${counts.failed} failed, they resume at the next start` : ''}`,
+        `\`${'█'.repeat(bar)}${'░'.repeat(20 - bar)}\` ${done} of ${s.total} cases done - ${counts.completed} completed, ${counts.difficult} difficult${counts.failed ? ` · ${counts.failed} failed, they resume at the next start` : ''}`,
         '',
-        ...summarySection(spent, tuning, memory),
+        ...s.summary,
         '## Overview',
         '',
-        ...overviewDiagram(counts),
+        ...pathDiagram(t, counts),
         '',
         '## System',
         '',
-        ...systemDiagram(t, counts),
+        ...systemDiagram(t, counts, s.lastApply),
         '',
         '## Workers',
         '',
-        ...t.workers.flatMap((w) => [
-            `### Worker ${w.slot}${w.case ? ` - ${link(w.case.id, here, feedbackPath(t, w.case))}` : ''}`,
-            '',
-            ...workerDiagram(t, w),
-            '',
-            ...(w.case ? tokenTable(caseTokens(t, w.case)) : []),
-        ]),
-        '| Worker | Case | Class | Phase | Try | Step | Since | Run | Analysis | Session |',
-        '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |',
+        '| Worker | Case | Class | Phase | Try | Step | Since | Run | Analysis | Session | Now |',
+        '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |',
     ];
     for (const w of t.workers) {
         if (!w.case) {
-            out.push(`| ${w.slot} | - | - | - | - | ${idleWord(t)} | ${since(Date.now() - w.since)} | - | - | - |`);
+            out.push(`| ${w.slot} | - | - | - | - | ${idleWord(t)} | - | - | - | - | - |`);
             continue;
         }
-        const dir = t.attemptDir(w.case, w.phase ?? 'nomem', w.attempt ?? 1);
+        const dir = t.workDir({ ...w, case: w.case });
         const run = readJson(join(dir, 'run.json'));
-        const session = existsSync(join(t.caseDir(w.case), 'session'))
-            ? readFileSync(join(t.caseDir(w.case), 'session'), 'utf8').trim()
-            : undefined;
-        out.push(`| ${w.slot} | ${link(w.case.id, here, feedbackPath(t, w.case))} | ${cell(w.case.class)} | ${PHASE_WORD[w.phase ?? 'nomem']} | ${w.attempt} / ${w.phase === 'mem' ? t.config.memTries : t.config.tries} | ${w.step} | ${since(Date.now() - w.since)} | ${run ? `${link('run', here, run.dir)}${run.report ? ` · ${link('report', here, run.report)}` : ''}` : '-'} | ${existsSync(join(dir, 'analysis.md')) ? link('analysis', here, join(dir, 'analysis.md')) : '-'} | ${session ? `\`zen meta resume ${basename(t.root)} ${session}\`` : '-'} |`);
+        const session = analyzeSession(dir);
+        const phase = w.recheck
+            ? `recheck after ${w.recheck.apply}`
+            : PHASE_WORD[w.phase ?? 'nomem'];
+        const tries = w.recheck
+            ? RECHECK_TRIES
+            : w.phase === 'mem'
+                ? t.config.memTries
+                : t.config.tries;
+        out.push(`| ${w.slot} | ${link(w.case.id, here, feedbackPath(t, w.case))} | ${cell(w.case.class)} | ${phase} | ${w.attempt} / ${tries} | ${w.step} | ${since(Date.now() - w.since)} | ${run ? `${link('run', here, run.dir)}${run.report ? ` · ${link('report', here, run.report)}` : ''}` : '-'} | ${existsSync(join(dir, 'analysis.md')) ? link('analysis', here, join(dir, 'analysis.md')) : '-'} | ${session ? `\`zen meta resume ${basename(t.root)} ${session}\`` : '-'} | ${liveCells(liveRow(t, w)?.recent)} |`);
+    }
+    for (const w of t.workers) {
+        const by = w.case
+            ? tokenTable(mergeStages(s.byCase.get(`${w.case.id}@${w.case.rev}`) ?? caseTokens(t, w.case), inFlight(liveRow(t, w))))
+            : [];
+        if (w.case && by.length > 0) {
+            out.push('', `### Worker ${w.slot} - ${link(w.case.id, here, feedbackPath(t, w.case))}`, '', ...by);
+        }
     }
     out.push('', `## Improvement queue - ${q.pending.length} of ${t.config.applyAt} parked`, '');
     out.push(q.applying
-        ? 'Applying now: no new run starts until it is done.'
+        ? `Applying now: no new run starts until it is done.${applierNow(t) ? ` Now: ${liveCell(applierNow(t))}` : ''}`
         : `A parked case gives its worker back, so another case runs meanwhile. The next apply comes when ${Math.max(0, t.config.applyAt - q.pending.length)} more park, or once nothing is running and no case is left to start; woken cases take a worker before new ones.`, '');
     if (q.pending.length > 0) {
         out.push('| Request | Case | Phase | Try | Improvements | Summary |', '| --- | --- | --- | --- | --- | --- |');
         for (const f of q.pending) {
-            out.push(`| ${cell(f.id)} | ${link(f.case, here, feedbackPath(t, { id: f.case }))} | ${PHASE_WORD[f.phase]} | ${f.attempt} | ${f.improvements.length} | ${cell(f.summary)} |`);
-        }
-        out.push('');
-    }
-    const applies = q.applies();
-    if (applies.length > 0) {
-        out.push('## Applies', '', 'Each apply links to its own page: every request, every decision, every file changed and why.', '', '| Apply | Versions | At | Requests | Applied | Merged | Rejected | Structural | Files changed | Tokens | Details |', '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |');
-        for (const a of [...applies].reverse()) {
-            const d = readJson(join(a.dir, 'decisions.json')) ?? {};
-            const tally = {};
-            for (const byImprovement of Object.values(d)) {
-                for (const x of Object.values(byImprovement)) {
-                    tally[x.decision ?? '?'] = (tally[x.decision ?? '?'] ?? 0) + 1;
-                }
-            }
-            const patch = join(a.dir, 'diff.patch');
-            const files = existsSync(patch)
-                ? (readFileSync(patch, 'utf8').match(/^diff --git /gm) ?? []).length
-                : 0;
-            const details = [
-                existsSync(join(a.dir, 'changes.md'))
-                    ? link('changes', here, join(a.dir, 'changes.md'))
-                    : '',
-                existsSync(patch) ? link('diff', here, patch) : '',
-                existsSync(join(a.dir, 'decisions.json'))
-                    ? link('decisions', here, join(a.dir, 'decisions.json'))
-                    : '',
-            ].filter(Boolean);
-            out.push(`| ${link(a.name, here, applyPath(a.dir))} | ${a.applied ? `v${a.applied.from} → v${a.applied.to}` : existsSync(join(a.dir, 'failed.json')) ? 'failed' : 'in progress'} | ${a.applied?.at.slice(11, 16) ?? '-'} | ${a.inputs?.length ?? 0} | ${tally.applied ?? 0} | ${tally.merged ?? 0} | ${tally.rejected ?? 0} | ${tally.structural ?? 0} | ${files} | ${inOut(envelopesIn(a.dir, 'apply'))} | ${details.join(' · ') || (a.applied?.skipped ? 'nothing to change' : '-')} |`);
+            out.push(`| ${cell(f.id)} | ${link(f.case, here, feedbackPath(t, { id: f.case }))} | ${PHASE_WORD[f.phase]} | ${f.attempt} | ${f.improvements.length} | ${cell(lead(f.summary))} |`);
         }
         out.push('');
     }
-    const allStages = mergeStages(everything, {
-        apply: mergeModels(...applies.map((a) => envelopesIn(a.dir, 'apply'))),
-    });
-    t.progress = { counts, total: cases.length, spent: allStages };
-    const tokenRows = tokenTable(allStages);
+    out.push(...s.later);
+    const tokenRows = tokenTable(mergeStages(s.spent, ...t.workers.map((w) => inFlight(liveRow(t, w))), inFlight(t.improvements.current?.dir ? applierRow(t) : undefined)));
     if (tokenRows.length > 0) {
-        out.push('## Tokens', '', 'Every try of every case so far, and every apply.', '', ...tokenRows);
-    }
-    out.push(...memorySection(t, here));
-    out.push('## Cases', '', '| Case | Class | Rubric | State | Tries without / with | Last verdict | LLM calls without memory | With memory | Memory effect | Run tokens | Analyze tokens | System |', '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |', ...rows, '');
-    if (difficult.length > 0) {
-        out.push('## Difficult cases', '', '| Case | Phase | Reason | Tries | Last summary | Details |', '| --- | --- | --- | --- | --- | --- |', ...difficult, '');
-    }
-    if (failed.length > 0) {
-        out.push('## Failed cases', '', 'Something outside the prose broke - the sandbox, a provider, a key - so these taught nothing. They keep their tries and carry on from the step that failed at the next `zen meta finetune start`.', '', '| Case | Stopped at | Reason | At |', '| --- | --- | --- | --- |', ...failed, '');
+        out.push('## Tokens', '', 'Every try of every case so far, every recheck, and every apply - the steps under way included.', '', ...tokenRows);
     }
+    out.push(...s.rest);
     out.push('## Recent events', '');
     for (const e of t.recent.slice(0, 20)) {
         const who = [
@@ -1165,120 +1391,7 @@ export function writeStatus(t) {
         ].filter(Boolean);
         out.push(`- ${e.at.slice(11, 19)} · ${[...who, e.what].join(' · ')}${e.detail ? ` - ${cell(e.detail)}` : ''}`);
     }
-    out.push(`- … everything in ${link('events.jsonl', here, join(t.dir, 'events.jsonl'))}`, '', '## Files', '', '- `cases/<id>/FEEDBACK.md` - one case: rubric, latest analysis, decisions, history', '- `cases/<id>/r<rev>/<NN>-<phase>/` - one try: `request.json`, `run.json`, `memory/`, `workspace/`, `feedback.json`, `analysis.md`, logs', '- `applies/<NNN>/APPLY.md` - one apply: requests, decisions, files changed with their diffs, zen check', '- `applies/<NNN>/` - `inputs.json`, `apply.log`, `check.log`, `changes.md`, `decisions.json`, `diff.patch`', '- `memories/` - `submissions.jsonl`, `merges.jsonl`, `submitted/<case>@r<rev>/`, `merged/mNN/`', '- `systems/` - `systems.jsonl` and a copy of `agents.yaml` + `agents/` per version', '- `events.jsonl` - every step, in order; `loop.json` - the settings', '- `journal.jsonl` - steps begun and not yet closed; a restart rolls back what a kill cut off', '- `STATUS.html`, `cases/<id>/FEEDBACK.html` - the same pages, rendered for a browser', '');
-    const md = `${out.join('\n')}\n`;
-    atomic(join(t.dir, 'STATUS.md'), md);
-    atomic(join(t.dir, 'STATUS.html'), markdownPage(`Fine-tuning - ${basename(t.root)}`, md, !t.finished));
-}
-// ---------------------------------------------------------------------------
-// STATUS.html, FEEDBACK.html - the same Markdown, rendered in the browser
-// ---------------------------------------------------------------------------
-const MARKED_URL = 'https://cdn.jsdelivr.net/npm/marked@14/lib/marked.esm.js';
-const PURIFY_URL = 'https://cdn.jsdelivr.net/npm/dompurify@3/dist/purify.es.mjs';
-// As in neo's inspect page: no byte of the payload can close the script element.
-const embed = (v) => JSON.stringify(v)
-    .replace(/</g, '\\u003c')
-    .replace(/>/g, '\\u003e')
-    .replace(/&/g, '\\u0026')
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029');
-export function markdownPage(title, md, live) {
-    return `<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-${live ? '<meta http-equiv="refresh" content="10">\n' : ''}<title>${title.replace(/[&<>"]/g, (ch) => `&#${ch.charCodeAt(0)};`)}</title>
-<style>
-body{font:14px/1.5 system-ui,sans-serif;margin:0;color:#24292f}
-main{margin-left:240px;padding:1em 2em;max-width:1600px}
-#toc{position:fixed;top:0;left:0;bottom:0;width:220px;overflow:auto;padding:1em 6px;box-sizing:border-box;border-right:1px solid #d0d7de;background:#f6f8fa;font-size:13px}
-#toc a{display:block;padding:2px 8px;border-radius:4px;color:#24292f;text-decoration:none;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
-#toc a.top{font-weight:600;margin-bottom:6px}
-#toc a.sub{padding-left:22px;color:#57606a}
-#toc a:hover{background:#eaeef2}
-#toc a.on{background:#ddf4ff;color:#0969da;font-weight:600}
-h1,h2,h3{scroll-margin-top:8px}
-@media (max-width:800px){#toc{display:none}main{margin-left:0}}
-table{border-collapse:collapse;margin:1em 0}th,td{border:1px solid #d0d7de;padding:4px 8px;vertical-align:top}
-th{background:#f6f8fa}code{background:#f6f8fa;padding:0 4px;border-radius:4px}
-pre{background:#f6f8fa;padding:8px;overflow:auto}pre.mermaid{background:none}
-a{color:#0969da}
-</style>
-</head>
-<body>
-<nav id="toc"></nav>
-<main id="doc">loading…</main>
-<script id="md" type="application/json">${embed(md)}</script>
-<script type="module">
-const md = JSON.parse(document.getElementById('md').textContent);
-const [{ marked }, { default: DOMPurify }, { default: mermaid }] = await Promise.all([
-    import(${embed(MARKED_URL)}),
-    import(${embed(PURIFY_URL)}),
-    import(${embed(MERMAID_URL)}),
-]);
-const doc = document.getElementById('doc');
-doc.innerHTML = DOMPurify.sanitize(marked.parse(md));
-// GitHub's slugs, so the diagrams' #anchors land as they do in the .md.
-for (const h of doc.querySelectorAll('h1, h2, h3, h4')) {
-    h.id = h.textContent.trim().toLowerCase().replace(/[^\\w\\s-]/g, '').replace(/\\s/g, '-');
-}
-const toc = document.getElementById('toc');
-const heads = [...doc.querySelectorAll('h1, h2, h3')];
-for (const h of heads) {
-    const a = document.createElement('a');
-    a.href = '#' + h.id;
-    a.textContent = h.textContent;
-    a.title = h.textContent;
-    a.className = h.tagName === 'H1' ? 'top' : h.tagName === 'H3' ? 'sub' : '';
-    toc.append(a);
-}
-for (const code of doc.querySelectorAll('code.language-mermaid')) {
-    const pre = document.createElement('pre');
-    pre.className = 'mermaid';
-    pre.textContent = code.textContent;
-    code.parentElement.replaceWith(pre);
-}
-mermaid.initialize({ startOnLoad: false, securityLevel: 'strict' });
-await mermaid.run({ querySelector: 'pre.mermaid' });
-// A page with an .html twin links to it; any other .md opens as the file it is.
-for (const a of doc.querySelectorAll('a')) {
-    for (const at of ['href', 'xlink:href']) {
-        const v = a.getAttribute(at);
-        if (v) {
-            a.setAttribute(at, v.replace(/(^|\\/)(STATUS|FEEDBACK)\\.md(?=#|$)/, '$1$2.html'));
-        }
-    }
-}
-// The live refresh would otherwise drop the reader back at the top every 10 s.
-const key = 'scroll:' + location.pathname;
-history.scrollRestoration = 'manual';
-addEventListener('beforeunload', () => sessionStorage.setItem(key, String(scrollY)));
-const kept = sessionStorage.getItem(key);
-if (kept !== null) {
-    scrollTo(0, Number(kept));
-} else if (location.hash) {
-    document.getElementById(decodeURIComponent(location.hash.slice(1)))?.scrollIntoView();
-}
-const mark = () => {
-    let current = heads[0];
-    for (const h of heads) {
-        if (h.getBoundingClientRect().top > 80) break;
-        current = h;
-    }
-    for (const a of toc.children) {
-        a.classList.toggle('on', a.hash === '#' + current?.id);
-    }
-    const on = toc.querySelector('a.on');
-    if (on && (on.offsetTop < toc.scrollTop || on.offsetTop + on.offsetHeight > toc.scrollTop + toc.clientHeight)) {
-        toc.scrollTop = on.offsetTop - toc.clientHeight / 2;
-    }
-};
-addEventListener('scroll', mark, { passive: true });
-mark();
-</script>
-</body>
-</html>
-`;
+    out.push(`- … everything in ${link('events.jsonl', here, join(t.dir, 'events.jsonl'))}`, '', '## Files', '', '- `cases/<id>/FEEDBACK.md` - one case: rubric, latest analysis, decisions, history', '- `cases/<id>/r<rev>/<NN>-<phase>/` - one try: `request.json`, `run.json`, `memory/`, `workspace/`, `brief.md`, `feedback.json`, `analysis.md`, logs', '- `applies/<NNN>/APPLY.md` - one apply: requests, decisions, files changed with their diffs, zen check', '- `applies/<NNN>/` - `inputs.json`, `brief.md`, `apply.log`, `check.log`, `changes.md`, `decisions.json`, `diff.patch`', '- `memories/` - `submissions.jsonl`, `merges.jsonl`, `submitted/<case>@r<rev>/`, `merged/mNN/`', '- `systems/` - `systems.jsonl` and a copy of `agents.yaml` + `agents/` per version', '- `events.jsonl` - every step, in order; `loop.json` - the settings', '- `journal.jsonl` - steps begun and not yet closed; a restart rolls back what a kill cut off', '- `view.json` - where `zen meta finetune start` or `serve` shows these pages live', '');
+    atomic(join(t.dir, 'STATUS.md'), `${out.join('\n')}\n`);
 }
 //# sourceMappingURL=report.js.map