@zenera/cli 1.1.23 → 1.1.25

package/dist/meta/finetune/train.js

@@ -0,0 +1,391 @@
+import { randomUUID } from 'node:crypto';
+import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { hostname } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { EXIT } from "../host.js";
+import { sessionKept } from "../tokens.js";
+import { batchInput } from "./dataset/export.js";
+import { DatasetStore } from "./dataset/store.js";
+import { errorIn, sizeOf, StepError } from "./failure.js";
+import { readFeedback } from "./feedback.js";
+import { caseTokens, writeFeedback } from "./report.js";
+import { readJson } from "./tuning.js";
+import { envelopesIn, runMetrics, spent, tokensOf, } from "./usage.js";
+// ---------------------------------------------------------------------------
+// One case, start to finish
+//
+// `train` is the whole method: tries without memory until the case passes,
+// then tries with the memory that passing run wrote. Every step leaves its
+// result in the attempt's folder and is skipped when that result is already
+// there, so calling `train` again after a stop carries on where it was.
+// ---------------------------------------------------------------------------
+export async function train(t, s, c) {
+    let passed;
+    for (let attempt = 1; attempt <= t.config.tries; attempt++) {
+        const { run, feedback } = await tryOnce(t, s, c, 'nomem', attempt);
+        if (feedback.done) {
+            passed = run;
+            break;
+        }
+        if (attempt < t.config.tries) {
+            await t.improvements.apply(feedback, s);
+        }
+    }
+    if (!passed) {
+        return markDifficult(t, c, 'nomem', 'wrong');
+    }
+    let cheaper = false;
+    for (let attempt = 1; attempt <= t.config.memTries; attempt++) {
+        const { run, feedback } = await tryOnce(t, s, c, 'mem', attempt, passed.memory);
+        if (feedback.done) {
+            cheaper = true;
+            t.memories.submit(c, attempt, run);
+            break;
+        }
+        if (attempt < t.config.memTries) {
+            await t.improvements.apply(feedback, s);
+        }
+    }
+    if (!cheaper) {
+        return markDifficult(t, c, 'mem', 'memory');
+    }
+    markCompleted(t, c);
+}
+/** A run its analysis finds void is set aside and run again: it says nothing about the prose. */
+async function tryOnce(t, s, c, phase, attempt, memory) {
+    for (let voids = 1;; voids++) {
+        const run = await zenRun(t, s, c, phase, attempt, memory);
+        const feedback = await analyze(t, s, c, phase, attempt, run);
+        if (feedback.verdict !== 'void') {
+            return { run, feedback };
+        }
+        const dir = t.attemptDir(c, phase, attempt);
+        let n = 1;
+        while (existsSync(`${dir}.void-${n}`)) {
+            n++;
+        }
+        renameSync(dir, `${dir}.void-${n}`);
+        t.event({
+            what: 'set aside',
+            worker: s.worker?.slot,
+            case: c.id,
+            phase,
+            attempt,
+            detail: `void, kept in ${basename(dir)}.void-${n} - running the try again`,
+        });
+        if (voids >= VOIDS) {
+            throw new VoidRun(`${VOIDS} analyses in a row found the run void - the last: ${feedback.infra}`, join(`${dir}.void-${n}`, 'analysis.md'));
+        }
+        t.checkStopping();
+    }
+}
+export class VoidRun extends StepError {
+}
+/** The container engine failed: every run after this one would fail the same way. */
+export class SandboxDown extends StepError {
+}
+/** Killed for memory, or nothing to show for it: the run says nothing about the prose. */
+const VOIDS = 3;
+async function zenRun(t, s, c, phase, attempt, memory) {
+    const dir = t.attemptDir(c, phase, attempt);
+    const file = join(dir, 'run.json');
+    for (let tries = 1; !existsSync(file); tries++) {
+        if (tries > VOIDS) {
+            throw new VoidRun(`${VOIDS} runs in a row were void`, join(dir, 'run.log'));
+        }
+        await t.improvements.notApplying();
+        t.at(s, phase, attempt, 'run');
+        t.improvements.runs++;
+        const began = Date.now();
+        try {
+            const why = await t.journal.step({ kind: 'run', dir }, () => runOnce(t, c, dir, memory));
+            const ran = why ? undefined : readJson(file);
+            t.ended(s, {
+                what: why ? 'void' : 'ran',
+                phase,
+                attempt,
+                result: why ?? (ran?.failed ? `failed: ${ran.failed}` : `${ran?.turns ?? '?'} turns`),
+                took: Date.now() - began,
+                tokens: spent(ran?.tokens),
+            });
+        }
+        finally {
+            t.improvements.runs--;
+        }
+    }
+    return readJson(file);
+}
+/** One `zen run`. Writes run.json, or says why the run was void. */
+async function runOnce(t, c, dir, memory) {
+    mkdirSync(dir, { recursive: true });
+    const mem = join(dir, 'memory');
+    rmSync(mem, { recursive: true, force: true });
+    if (memory && existsSync(memory)) {
+        cpSync(memory, mem, { recursive: true, filter: (src) => basename(src) !== '.lock' });
+    }
+    // Else `zen run` roots the agent's files at its cwd: the project, shared by every run.
+    const workspace = join(dir, 'workspace');
+    rmSync(workspace, { recursive: true, force: true });
+    mkdirSync(workspace, { recursive: true });
+    const request = join(dir, 'request.json');
+    const envelope = join(dir, 'envelope.json');
+    const events = join(dir, 'events.jsonl');
+    rmSync(envelope, { force: true });
+    rmSync(events, { force: true });
+    writeFileSync(request, `${JSON.stringify({ input: batchInput([c], t.root, request).batch[0].input }, null, 2)}\n`);
+    const log = join(dir, 'run.log');
+    const from = existsSync(log) ? statSync(log).size : 0;
+    const said = () => existsSync(log) ? readFileSync(log).subarray(from).toString('utf8') : '';
+    const res = await t.zen([
+        'run',
+        '--plain',
+        '--new',
+        '--yes',
+        '--json',
+        // A try is never continued: its containers would only hold podman's locks.
+        '--disposable',
+        '--input',
+        request,
+        '--memory',
+        mem,
+        '--workspace',
+        workspace,
+        '--out',
+        envelope,
+        '--events',
+        events,
+    ], log);
+    if (res.code === EXIT.sandbox) {
+        throw new SandboxDown(/error\s+(.+)/.exec(said())?.[1]?.trim() ?? 'the sandbox is not ready', log);
+    }
+    const out = readJson(envelope);
+    let runDir = out?.run?.dir;
+    let failed;
+    if (!runDir) {
+        // A failed run throws before the envelope; its directory is in the hint.
+        const text = said();
+        const report = /report: (\S+report\.html)/.exec(text)?.[1];
+        if (!report) {
+            return 'no run directory';
+        }
+        runDir = dirname(report);
+        failed = /error\s+(.+)/.exec(text)?.[1]?.trim() ?? 'the run failed';
+    }
+    const graph = join(runDir, 'graph.mmd');
+    if (existsSync(graph) && /exit code 137/.test(readFileSync(graph, 'utf8'))) {
+        return 'a command was killed for memory (exit 137)';
+    }
+    const meta = readJson(join(runDir, 'meta.json'));
+    const metrics = runMetrics(runDir);
+    if (metrics?.sandbox) {
+        throw new SandboxDown(metrics.sandbox, join(runDir, 'graph.mmd'));
+    }
+    const run = {
+        dir: runDir,
+        memory: mem,
+        workspace,
+        system: t.system.version(),
+        ...(existsSync(join(runDir, 'report.html')) ? { report: join(runDir, 'report.html') } : {}),
+        ...(existsSync(graph) ? { graph } : {}),
+        ...(failed || meta?.error ? { failed: failed ?? meta?.error } : {}),
+        ...(meta?.turns !== undefined ? { turns: meta.turns } : {}),
+        ...(meta?.usage ? { usage: meta.usage } : {}),
+        ...(metrics ? { tokens: tokensOf(metrics), metrics } : {}),
+        ...(meta?.durationMs !== undefined ? { durationMs: meta.durationMs } : {}),
+    };
+    writeFileSync(join(dir, 'run.json'), `${JSON.stringify(run, null, 2)}\n`);
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// zen meta run /analyze
+// ---------------------------------------------------------------------------
+/** The case keeps one analyze session per revision, so each analysis remembers the last. */
+export function sessionOf(t, c) {
+    const file = join(t.caseDir(c), 'session');
+    return existsSync(file) ? readFileSync(file, 'utf8').trim() || undefined : undefined;
+}
+async function analyze(t, s, c, phase, attempt, run) {
+    const dir = t.attemptDir(c, phase, attempt);
+    const file = join(dir, 'feedback.json');
+    const known = t.known(c, phase, attempt);
+    const kept = readFeedback(file, known);
+    let feedback;
+    if ('feedback' in kept) {
+        feedback = kept.feedback;
+    }
+    else {
+        t.checkStopping();
+        t.at(s, phase, attempt, 'analyze');
+        const began = Date.now();
+        feedback = await t.journal.step({ kind: 'analyze', dir }, () => analyzeOnce(t, s, c, phase, attempt, run, file));
+        const graded = Object.values(feedback.rubric);
+        t.ended(s, {
+            what: 'analyzed',
+            phase,
+            attempt,
+            result: feedback.verdict === 'void'
+                ? `void: ${feedback.infra}`
+                : `${feedback.verdict}${graded.length ? ` ${graded.filter((g) => g === 'pass').length}/${graded.length}` : ''}${feedback.done ? ', done' : ''}`,
+            took: Date.now() - began,
+            tokens: spent(envelopesIn(dir, 'analyze')),
+        });
+        // Only a try that went all the way through says the sandbox and the providers are up:
+        // a run can pass on one provider while the analysis fails on another.
+        if (feedback.verdict !== 'void') {
+            t.succeeded();
+        }
+    }
+    writeFeedback(t, c);
+    return feedback;
+}
+async function analyzeOnce(t, s, c, phase, attempt, run, file) {
+    const dir = dirname(file);
+    const known = t.known(c, phase, attempt);
+    let session = sessionOf(t, c);
+    if (!session) {
+        session = randomUUID();
+        mkdirSync(t.caseDir(c), { recursive: true });
+        writeFileSync(join(t.caseDir(c), 'session'), `${session}\n`);
+    }
+    const hash = t.system.hash();
+    const applies = t.improvements.started;
+    const events = join(dir, 'analyze.events.jsonl');
+    rmSync(events, { force: true });
+    const continuing = () => [
+        'meta',
+        'run',
+        '--no-refresh',
+        '--json',
+        '--events',
+        events,
+        ...(sessionKept(session) ? ['--resume', session] : ['--session-id', session]),
+    ];
+    const log = join(dir, 'analyze.log');
+    const from = sizeOf(log);
+    const res = await t.zen([
+        ...continuing(),
+        '/analyze',
+        run.dir,
+        `case=${c.id}`,
+        `rev=${c.rev}`,
+        `phase=${phase}`,
+        `attempt=${attempt}`,
+        `feedback=${file}`,
+    ], log);
+    keepAnalysis(dir, res.stdout);
+    // `zen meta run` starts a new session when the meta model changed since this one; follow it.
+    const started = sessionIn(res.stdout);
+    if (started && started !== session) {
+        session = started;
+        writeFileSync(join(t.caseDir(c), 'session'), `${session}\n`);
+    }
+    const rubricIds = c.rubric.map((r) => r.id);
+    let read = readFeedback(file, known, rubricIds);
+    // An agent that exited on an error would only meet it again; one that wrote a bad file can fix it.
+    if (!('feedback' in read) && res.code === 0) {
+        const again = await t.zen([
+            ...continuing(),
+            `The feedback file ${file} is ${read.problem}. Write it again exactly as section 7 of the zen-analyze-run skill describes, then stop.`,
+        ], log);
+        keepAnalysis(dir, again.stdout, false);
+        read = readFeedback(file, known, rubricIds);
+    }
+    // Any apply that overlapped this analysis owns the change; undoing it would gut the apply.
+    const overlapped = t.improvements.applying || t.improvements.started !== applies;
+    if (t.system.hash() !== hash && !overlapped) {
+        t.system.restore(t.system.version());
+        t.event({
+            what: 'analyze edited the system - undone',
+            worker: s.worker?.slot,
+            case: c.id,
+            phase,
+            attempt,
+        });
+    }
+    if (!('feedback' in read)) {
+        const e = errorIn(log, from);
+        throw new StepError(`analysis wrote no usable feedback (${read.problem})${e.message ? `: ${e.message}` : ''}`, e.log);
+    }
+    note(t, c, read.feedback, run, session);
+    return read.feedback;
+}
+function sessionIn(stdout) {
+    try {
+        const id = JSON.parse(stdout).sessionId;
+        return typeof id === 'string' && id ? id : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The meta agent's answer is the human report: kept as analysis.md beside the feedback. A retry keeps its own envelope, so its tokens are counted too. */
+function keepAnalysis(dir, stdout, replace = true) {
+    let envelope;
+    try {
+        envelope = JSON.parse(stdout);
+    }
+    catch {
+        return;
+    }
+    writeFileSync(join(dir, replace ? 'analyze.json' : 'analyze-2.json'), stdout);
+    if (envelope.answerFile &&
+        existsSync(envelope.answerFile) &&
+        (replace || !existsSync(join(dir, 'analysis.md')))) {
+        copyFileSync(envelope.answerFile, join(dir, 'analysis.md'));
+    }
+}
+function note(t, c, f, run, session) {
+    const ids = new Set(c.rubric.map((r) => r.id));
+    const rubric = Object.fromEntries(Object.entries(f.rubric).filter(([id]) => ids.has(id)));
+    DatasetStore.open(t.root).note(c.id, {
+        type: 'note',
+        at: new Date().toISOString(),
+        kind: 'graded',
+        caseRev: c.rev,
+        run: run.dir,
+        verdict: f.verdict,
+        ...(Object.keys(rubric).length > 0 ? { rubric } : {}),
+        text: f.verdict === 'void' ? `void: ${f.infra}` : f.summary || f.verdict,
+        by: { session, prompt: 'analyze', host: hostname() },
+    });
+}
+// ---------------------------------------------------------------------------
+// The end of a case
+// ---------------------------------------------------------------------------
+function finish(t, c, result) {
+    const full = {
+        ...result,
+        caseRev: c.rev,
+        at: new Date().toISOString(),
+        tokens: caseTokens(t, c),
+    };
+    mkdirSync(t.caseDir(c), { recursive: true });
+    writeFileSync(join(t.caseDir(c), 'result.json'), `${JSON.stringify(full, null, 2)}\n`);
+    t.event({
+        what: result.state,
+        case: c.id,
+        rev: c.rev,
+        phase: result.phase,
+        detail: result.reason,
+    });
+    writeFeedback(t, c);
+}
+export function markCompleted(t, c) {
+    finish(t, c, { state: 'completed', phase: 'mem' });
+}
+export function markDifficult(t, c, phase, reason) {
+    finish(t, c, { state: 'difficult', phase, reason });
+    DatasetStore.open(t.root).note(c.id, {
+        type: 'note',
+        at: new Date().toISOString(),
+        kind: 'difficult',
+        caseRev: c.rev,
+        text: `${phase === 'nomem' ? 'without memory' : 'with memory'}: ${reason}`,
+        by: { prompt: 'finetune', host: hostname() },
+    });
+}
+/** Something outside the prose broke. The case keeps its tries and runs again at the next start. */
+export function markFailed(t, c, phase, reason) {
+    finish(t, c, { state: 'failed', phase, reason });
+}
+//# sourceMappingURL=train.js.map

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

@@ -0,0 +1,16 @@
+import type { Theme } from '../host.ts';
+import type { Snapshot } from './live.ts';
+import type { Tuning } from './tuning.ts';
+export interface Part {
+    text: string;
+    color?: string;
+    bold?: boolean;
+}
+export type Line = Part[];
+/** The overview: under way, tokens, log - as many log rows as the height leaves. */
+export declare function mainLines(s: Snapshot, selected: number, width: number, height: number, theme: Theme): Line[];
+/** One step's agent, line by line as it works. */
+export declare function followLines(s: Snapshot, key: string, width: number, height: number, theme: Theme): Line[];
+/** Draws the tuning until the returned function is called. */
+export declare function watch(t: Tuning, interrupt: () => void): Promise<() => void>;
+//# sourceMappingURL=tui.d.ts.map

package/dist/meta/finetune/tui.js

@@ -0,0 +1,291 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, render, Text, useInput, useWindowSize } from 'ink';
+import React, { useEffect, useState } from 'react';
+import { resolveTheme } from "../host.js";
+import { since } from "./report.js";
+import { short } from "./usage.js";
+const BAR = 20;
+const fit = (text, width) => text.length > width ? `${text.slice(0, Math.max(0, width - 1))}…` : text.padEnd(width);
+const clock = (iso) => {
+    const d = new Date(iso);
+    return Number.isNaN(d.getTime()) ? '        ' : d.toTimeString().slice(0, 8);
+};
+const seconds = (ms) => ms === undefined
+    ? ''
+    : ms < 60_000
+        ? `${(ms / 1000).toFixed(ms < 10_000 ? 1 : 0)}s`
+        : since(ms);
+function footer(width, keys, theme) {
+    return [
+        [{ text: '─'.repeat(Math.max(0, width)), color: theme.chrome.color }],
+        [{ text: keys, color: theme.chrome.color }],
+    ];
+}
+function keysFor(s, following) {
+    if (s.state === 'stopping') {
+        return 'stopping: the steps under way finish first · ctrl-c again kills them';
+    }
+    if (s.state !== 'running') {
+        return s.state;
+    }
+    return following
+        ? 'esc back · s stop · ctrl-c stop, twice kills'
+        : 'up/down choose · enter follow · s stop · ctrl-c stop, twice kills';
+}
+function header(s, theme) {
+    const c = s.counts;
+    const n = (k) => c[k] ?? 0;
+    const done = n('completed') + n('difficult');
+    const filled = s.total ? Math.round((done / s.total) * BAR) : 0;
+    const quiet = theme.chrome.color;
+    const tally = [
+        { text: '█'.repeat(filled), color: theme.accent },
+        { text: '░'.repeat(BAR - filled), color: quiet },
+        { text: ` ${done} of ${s.total} done` },
+    ];
+    const add = (text, color) => {
+        tally.push({ text: ` · ${text}`, color });
+    };
+    if (n('completed')) {
+        add(`${n('completed')} completed`);
+    }
+    if (n('difficult')) {
+        add(`${n('difficult')} difficult`, theme.warn);
+    }
+    if (n('failed')) {
+        add(`${n('failed')} failed`, theme.line.error.color);
+    }
+    if (s.parked) {
+        add(`${s.parked} parked, apply at ${s.applyAt}`);
+    }
+    return [
+        [
+            { text: `Fine-tuning ${s.project}`, bold: true },
+            {
+                text: ` · ${s.state} · ${since(s.elapsedMs)} · system v${s.system} · ${s.workers.busy} of ${s.workers.all} workers busy`,
+                color: quiet,
+            },
+        ],
+        tally,
+    ];
+}
+const STAGE_HUE = {
+    dark: { run: 'green', analyze: 'magentaBright', apply: 'blueBright' },
+    light: { run: 'green', analyze: 'magenta', apply: 'blue' },
+};
+/** One hue per stage in every section: run/ran, analyze/analyzed, apply/applied. */
+function hue(word, theme) {
+    const stage = /^(run|ran)\b/.test(word)
+        ? 'run'
+        : word.startsWith('analy')
+            ? 'analyze'
+            : word.startsWith('appl')
+                ? 'apply'
+                : undefined;
+    return stage && STAGE_HUE[theme.appearance][stage];
+}
+/** worker, task, action, elapsed, tokens, model, latest - split around the action cell. */
+function nowCells(cells, width) {
+    const [who = '', what = '', step = '', elapsed = '', tokens = '', model = '', last = ''] = cells;
+    return [
+        `${fit(who, 9)} ${fit(what, 26)} `,
+        fit(step, 8),
+        ` ${fit(elapsed, 7)} ${fit(tokens, 6)} ${fit(model, width >= 110 ? 22 : 16)} ${last}`,
+    ];
+}
+const nowRow = (r) => [
+    r.who,
+    r.what,
+    r.step,
+    since(r.sinceMs),
+    r.act?.calls ? short(r.act.input + r.act.output) : '',
+    r.act?.model ?? '',
+    r.act?.last ?? '',
+];
+/** case, result, took, tokens after the action: the result takes what the others leave. */
+const logCells = (cells, width) => {
+    const [where, result, took, tokens] = cells;
+    return `${fit(where, 31)} ${fit(result, Math.max(10, width - 75))} ${fit(took, 7)} ${tokens}`;
+};
+/** The overview: under way, tokens, log - as many log rows as the height leaves. */
+export function mainLines(s, selected, width, height, theme) {
+    const quiet = theme.chrome.color;
+    const out = [...header(s, theme)];
+    if (s.now.length > 0) {
+        out.push([], [{ text: 'In progress', bold: true }]);
+        out.push([
+            {
+                text: `  ${nowCells(['worker', 'task', 'action', 'elapsed', 'tokens', 'model', 'latest'], width).join('')}`,
+                color: quiet,
+            },
+        ]);
+        s.now.forEach((r, i) => {
+            const [before, step, after] = nowCells(nowRow(r), width);
+            out.push([
+                i === selected ? { text: '> ', color: theme.accent, bold: true } : { text: '  ' },
+                { text: before },
+                { text: step, color: hue(r.step, theme) },
+                { text: after },
+            ]);
+        });
+    }
+    if (s.tokens.length > 0) {
+        out.push([], [{ text: 'Tokens so far', bold: true }]);
+        out.push([
+            {
+                text: `${fit('stage', 8)} ${fit('model', 26)} ${'calls'.padStart(6)} ${'in'.padStart(7)} ${'out'.padStart(7)}`,
+                color: quiet,
+            },
+        ]);
+        for (const r of s.tokens) {
+            out.push([
+                { text: fit(r.stage, 8), color: hue(r.stage, theme) },
+                {
+                    text: ` ${fit(r.model, 26)} ${String(r.calls).padStart(6)} ${short(r.input).padStart(7)} ${short(r.output).padStart(7)}`,
+                },
+            ]);
+        }
+    }
+    if (s.errors.length > 0) {
+        const red = theme.line.error.color;
+        out.push([], [{ text: 'Errors', bold: true, color: red }]);
+        for (const e of s.errors) {
+            out.push([
+                { text: `${clock(e.at)} `, color: quiet },
+                { text: `${fit(e.where, 28)} ` },
+                { text: e.message, color: red },
+            ]);
+            if (e.log) {
+                out.push([{ text: `${' '.repeat(9)}log ${e.log}`, color: quiet }]);
+            }
+        }
+    }
+    const room = height - out.length - 2 - 3;
+    if (s.log.length > 0 && room > 0) {
+        out.push([], [{ text: 'Log', bold: true }]);
+        out.push([
+            {
+                text: `${fit('time', 8)} ${fit('action', 18)} ${logCells(['case', 'result', 'took', 'tokens'], width)}`,
+                color: quiet,
+            },
+        ]);
+        for (const r of s.log.slice(0, room)) {
+            out.push([
+                { text: `${clock(r.at)} `, color: quiet },
+                { text: fit(r.action, 18), color: hue(r.action, theme) },
+                {
+                    text: ` ${logCells([r.case, r.result, seconds(r.took), r.tokens ? short(r.tokens) : ''], width)}`,
+                },
+            ]);
+        }
+    }
+    return [...out, ...footer(width, keysFor(s, false), theme)];
+}
+function activity(e, theme) {
+    const at = { text: `${clock(e.t)}  `, color: theme.chrome.color };
+    switch (e.type) {
+        case 'llm':
+            return [
+                at,
+                {
+                    text: `model  ${e.model}  ${short(e.in)} in, ${short(e.out)} out${e.ms ? `, ${seconds(e.ms)}` : ''}`,
+                    color: theme.chrome.color,
+                },
+            ];
+        case 'tool':
+            return e.phase === 'start'
+                ? [at, { text: `tool   ${e.name}  `, color: theme.accent }, { text: e.subject }]
+                : [
+                    at,
+                    {
+                        text: `       ${e.ok ? 'done' : 'failed'} ${e.name}${e.ms ? ` ${seconds(e.ms)}` : ''}`,
+                        color: e.ok ? theme.chrome.color : theme.line.error.color,
+                    },
+                ];
+        case 'say':
+            return [at, { text: 'says   ', color: theme.accent }, { text: e.text }];
+    }
+}
+/** One step's agent, line by line as it works. */
+export function followLines(s, key, width, height, theme) {
+    const r = s.now.find((x) => x.key === key);
+    const out = [];
+    if (!r) {
+        out.push([{ text: 'Nothing is under way there now.', bold: true }]);
+    }
+    else {
+        out.push([
+            { text: `Following ${r.who}`, bold: true },
+            {
+                text: ` · ${r.what} · ${r.step} · ${since(r.sinceMs)}${r.act?.model ? ` · ${r.act.model}` : ''}${r.act?.calls ? ` · ${short(r.act.input + r.act.output)} tokens in ${r.act.calls} calls` : ''}`,
+                color: theme.chrome.color,
+            },
+        ]);
+        out.push([]);
+        const lines = r.act?.lines ?? [];
+        if (lines.length === 0) {
+            out.push([{ text: 'nothing yet', color: theme.chrome.color }]);
+        }
+        for (const e of lines.slice(-Math.max(1, height - out.length - 3))) {
+            out.push(activity(e, theme));
+        }
+    }
+    return [...out, ...footer(width, keysFor(s, true), theme)];
+}
+function Live({ t, theme, interrupt, }) {
+    const [snap, setSnap] = useState();
+    const [selected, setSelected] = useState(0);
+    const [follow, setFollow] = useState();
+    const { columns, rows } = useWindowSize();
+    useEffect(() => {
+        t.watchers.add(setSnap);
+        return () => {
+            t.watchers.delete(setSnap);
+        };
+    }, [t]);
+    const count = snap?.now.length ?? 0;
+    const at = Math.min(selected, Math.max(0, count - 1));
+    useInput((input, key) => {
+        if ((key.ctrl && input === 'c') || input === 's') {
+            interrupt();
+            return;
+        }
+        if (follow) {
+            if (key.escape) {
+                setFollow(undefined);
+            }
+            return;
+        }
+        if (key.upArrow) {
+            setSelected(Math.max(0, at - 1));
+        }
+        else if (key.downArrow) {
+            setSelected(Math.min(count - 1, at + 1));
+        }
+        else if (key.return && snap?.now[at]) {
+            setFollow(snap.now[at].key);
+        }
+    });
+    if (!snap) {
+        return _jsx(Text, { color: theme.chrome.color, children: "starting" });
+    }
+    const height = Math.max(8, rows - 1);
+    const all = follow
+        ? followLines(snap, follow, columns, height, theme)
+        : mainLines(snap, at, columns, height, theme);
+    // Too short a terminal loses rows from the middle, never the keys at the bottom.
+    const lines = all.length > height ? [...all.slice(0, height - 2), ...all.slice(-2)] : all;
+    return (_jsx(Box, { flexDirection: "column", children: lines.map((parts, i) => (_jsx(Text, { wrap: "truncate-end", children: parts.length === 0
+                ? ' '
+                : parts.map((p, j) => (_jsx(Text, { color: p.color, bold: p.bold, children: p.text }, j))) }, i))) }));
+}
+/** Draws the tuning until the returned function is called. */
+export async function watch(t, interrupt) {
+    const theme = await resolveTheme();
+    const instance = render(_jsx(Live, { t: t, theme: theme, interrupt: interrupt }), {
+        stdout: process.stderr,
+        exitOnCtrlC: false,
+    });
+    return () => instance.unmount();
+}
+//# sourceMappingURL=tui.js.map