@zenera/cli 1.1.25 → 1.1.26

package/dist/meta.js

@@ -0,0 +1,981 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { appendFileSync, closeSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, writeFileSync, } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { invokedAs } from "./args.js";
+import { paths, readJson, writeJson } from "./home.js";
+import { envOf } from "./keys.js";
+import { duration } from "./narrate.js";
+import { credentialError, cut, cyan, dim, note, pad, plain, red, styled, usageError, write, yellow, } from "./term.js";
+import { formatInline, formatMarkdown } from "./tui/markdown.js";
+import { boxWidth } from "./tui/wrap.js";
+export const PROMPT_DIR = '.github/prompts';
+const PROMPT_SUFFIX = '.prompt.md';
+// ---------------------------------------------------------------------------
+// The model
+// ---------------------------------------------------------------------------
+/** The variable a project's `.env` names it with — a zen ref, not a wire id. */
+export const MODEL_ENV = 'ZENERA_META_MODEL';
+/** Where the answer is looked for, best first. */
+export const ORDER = [
+    'flag',
+    'shell',
+    'env',
+    'store',
+    'project',
+    'default',
+];
+export function chooseModel(sources) {
+    const at = {
+        flag: sources.flag,
+        // `.env` only fills gaps, so an answer that survived it came from the shell
+        shell: sources.shell,
+        env: sources.shell ? undefined : sources.env,
+        store: sources.stored,
+        project: sources.project,
+        default: sources.fallback,
+    };
+    for (const from of ORDER) {
+        const ref = at[from]?.trim();
+        if (ref) {
+            return { ref, from };
+        }
+    }
+    return undefined;
+}
+export const SOURCE_LABELS = {
+    flag: '--model',
+    shell: `${MODEL_ENV} (shell)`,
+    env: `${MODEL_ENV} (.env)`,
+    store: 'zen meta model',
+    project: 'agents.yaml model:',
+    default: 'recommended',
+};
+// ---------------------------------------------------------------------------
+// What to run when nobody said
+//
+// A first `zen meta` should work on a machine that has a key and nothing else,
+// so the last resort is the best model the keys on hand can buy rather than an
+// error. Deep tier deliberately: this agent is pointed at the project itself,
+// and a cheap model reading a specification is a false economy.
+// ---------------------------------------------------------------------------
+/** First of each row is the default; the rest are what `--pick` offers beside it. */
+export const RECOMMENDED = {
+    openai: ['gpt-5.6-sol', 'gpt-5.6-terra'],
+    anthropic: ['claude-opus-5', 'claude-sonnet-5'],
+    vertex: ['gemini-3.8-flash', 'gemini-3.5-flash-lite'],
+    google: ['gemini-3.8-flash', 'gemini-3.5-flash-lite'],
+    openrouter: ['anthropic/claude-opus-5', 'openai/gpt-5.6-sol'],
+};
+/** Which provider is tried first when several are held. */
+const PREFERENCE = ['anthropic', 'openai', 'vertex', 'google', 'openrouter'];
+/** The recommended ref for the first provider with a key, or for `only`. */
+export function defaultRef(store, only) {
+    for (const provider of only ? [only] : PREFERENCE) {
+        const id = RECOMMENDED[provider]?.[0];
+        if (id && store.active(provider)) {
+            return `${provider}/${id}`;
+        }
+    }
+    return undefined;
+}
+const EMPTY = { version: 1 };
+export const readMeta = () => readJson(paths.meta(), EMPTY);
+export function writeMeta(file) {
+    writeJson(paths.meta(), file);
+}
+// ---------------------------------------------------------------------------
+// Refs
+// ---------------------------------------------------------------------------
+const PROVIDER_NAMES = new Set(['openai', 'anthropic', 'google', 'vertex', 'openrouter']);
+/**
+ * `vertex/gemini-3.8-flash` splits; `gpt-5.6-sol` does not. Only a known provider
+ * counts as a prefix, because `google/gemini-3.8-flash` is also a perfectly good
+ * bare id on an endpoint that speaks publisher names.
+ *
+ * The colon form is the library's own — `openai:gpt-5.6-sol`, and with an api
+ * selector `openai/responses:gpt-5.6-sol` — which is what arrives when the ref
+ * came from `agents.yaml`.
+ */
+export function splitRef(ref) {
+    const colon = ref.indexOf(':');
+    if (colon > 0) {
+        const head = ref.slice(0, colon).split('/')[0];
+        if (PROVIDER_NAMES.has(head)) {
+            return { provider: head, id: ref.slice(colon + 1) };
+        }
+    }
+    const slash = ref.indexOf('/');
+    if (slash < 0) {
+        return { id: ref };
+    }
+    const head = ref.slice(0, slash);
+    return PROVIDER_NAMES.has(head)
+        ? { provider: head, id: ref.slice(slash + 1) }
+        : { id: ref };
+}
+/**
+ * The provider a misspelt prefix was reaching for, if that is what it is.
+ *
+ * `vertes/gemini-3.8-flash` is shaped exactly like the OpenRouter id
+ * `meta-llama/llama-4`, so an unknown prefix cannot be an error on its own —
+ * only one close enough to a real provider name to be a slip of the hand.
+ */
+export function misspelledProvider(ref) {
+    const slash = ref.indexOf('/');
+    if (slash <= 0) {
+        return undefined;
+    }
+    const head = ref.slice(0, slash).toLowerCase();
+    if (PROVIDER_NAMES.has(head)) {
+        return undefined;
+    }
+    for (const name of PROVIDER_NAMES) {
+        // Two, so that a transposition — which Levenshtein counts twice — reads
+        // as the typo it is. No provider name is short enough for that to be loose.
+        if (distance(head, name) <= 2) {
+            return name;
+        }
+    }
+    return undefined;
+}
+/** Levenshtein, one row at a time. Both operands are a word long. */
+function distance(a, b) {
+    if (Math.abs(a.length - b.length) > 2) {
+        return 3;
+    }
+    let row = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        const next = [i];
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            next[j] = Math.min(next[j - 1] + 1, row[j] + 1, row[j - 1] + cost);
+        }
+        row = next;
+    }
+    return row[b.length];
+}
+// ---------------------------------------------------------------------------
+// Wiring
+// ---------------------------------------------------------------------------
+const TYPES = {
+    openai: 'openai',
+    anthropic: 'anthropic',
+    google: 'openai',
+    vertex: 'openai',
+    openrouter: 'openai',
+};
+const BASE_URLS = {
+    openai: 'https://api.openai.com/v1',
+    anthropic: 'https://api.anthropic.com',
+    google: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+    openrouter: 'https://openrouter.ai/api/v1',
+};
+/**
+ * Copilot offers its tools as OpenAI *custom* tools, which the completions API
+ * rejects outright — `400 Invalid value: 'custom'`. Only the responses API
+ * takes them, and only the reasoning models serve it, so the wire API follows
+ * the model rather than being a flag nobody would know to set. Older models are
+ * listed rather than newer ones, so each new generation works without a release.
+ */
+export function wireApi(provider, id) {
+    return provider === 'openai' && !/^(gpt-4|gpt-3\.5|chatgpt-)/.test(id)
+        ? 'responses'
+        : undefined;
+}
+/**
+ * Turns a zen key entry and a model id into copilot's environment.
+ *
+ * `COPILOT_PROVIDER_BASE_URL` is what activates BYOK at all, so every provider
+ * gets one — including OpenAI, whose url copilot would otherwise have reached
+ * through a GitHub account we are deliberately not using.
+ */
+export function wire(store, entry, id) {
+    const provider = entry.provider;
+    const env = {};
+    const secret = [];
+    const warnings = [];
+    env.COPILOT_PROVIDER_TYPE = TYPES[provider];
+    env.COPILOT_MODEL = id;
+    if (provider === 'vertex') {
+        const project = store.projectOf(entry)?.id;
+        if (!project) {
+            throw credentialError(`no GCP project on ${entry.provider}/${entry.name}`, 'set one: zen key add vertex --project <id>');
+        }
+        const location = entry.location?.trim() || 'global';
+        if (location === 'global') {
+            warnings.push('location `global` adds about ten seconds of cold start');
+        }
+        env.COPILOT_PROVIDER_BASE_URL = `https://aiplatform.googleapis.com/v1/projects/${project}/locations/${location}/endpoints/openapi`;
+        // Vertex speaks publisher names on the wire and knows nothing of zen's
+        // provider prefix; the bare id stays as the model *id* so copilot can
+        // still match its catalogue for token limits and tool support.
+        env.COPILOT_PROVIDER_WIRE_MODEL = id.includes('/') ? id : `google/${id}`;
+        env.COPILOT_PROVIDER_MODEL_ID = id.includes('/') ? id.slice(id.indexOf('/') + 1) : id;
+    }
+    else {
+        const url = BASE_URLS[provider];
+        if (!url) {
+            throw credentialError(`no BYOK endpoint known for ${provider}`);
+        }
+        env.COPILOT_PROVIDER_BASE_URL = url;
+    }
+    const api = wireApi(provider, id);
+    if (api) {
+        env.COPILOT_PROVIDER_WIRE_API = api;
+    }
+    if (entry.holds === 'file') {
+        // A Google access token is good for an hour and a session is not, so
+        // copilot is told how to mint one rather than handed one that will be
+        // stale by the time it matters.
+        env.COPILOT_PROVIDER_API_KEY_COMMAND = `${invokedAs('zen')} key token ${entry.provider}`;
+        env[envOf(entry)] = store.fileOf(entry);
+    }
+    else {
+        env.COPILOT_PROVIDER_API_KEY = store.reveal(entry);
+        secret.push('COPILOT_PROVIDER_API_KEY');
+    }
+    return { provider, model: env.COPILOT_PROVIDER_WIRE_MODEL ?? id, env, secret, warnings };
+}
+/** Values a `--dry-run` may print. A key is four characters and an apology. */
+export function masked(env, secret) {
+    return Object.entries(env)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, value]) => `${name}=${secret.includes(name) ? '••••' : value}`);
+}
+// ---------------------------------------------------------------------------
+// Stored prompts
+//
+// Copilot reads `AGENTS.md`, `.github/skills/` and `.github/agents/`, but it
+// has no notion of `.github/prompts/*.prompt.md` — the files an editor offers
+// as slash commands. Reading one and handing over its body is the whole of
+// `zen meta run`, and it is why that subcommand exists.
+// ---------------------------------------------------------------------------
+/** `/project-review`, `project-review`, `project-review.prompt.md` or a path. */
+export function promptPath(dir, name) {
+    const bare = name.replace(/^\//, '');
+    if (bare.includes('/') || bare.endsWith('.md')) {
+        return `${dir}/${bare}`;
+    }
+    return `${dir}/${PROMPT_DIR}/${bare}${PROMPT_SUFFIX}`;
+}
+/**
+ * Frontmatter is the editor's business — `mode`, `tools`, `description` — and
+ * none of it means anything to copilot, so only the body is sent. `description`
+ * is kept for the one line of narration that says which prompt is running.
+ */
+export function readPrompt(path, name, text) {
+    let body = text;
+    let description;
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+    if (match) {
+        body = text.slice(match[0].length);
+        const found = /^description:\s*(.+)$/m.exec(match[1]);
+        description = found?.[1].trim().replace(/^['"]|['"]$/g, '');
+    }
+    return { name, path, description, body: body.trim() };
+}
+export async function loadPrompt(dir, name) {
+    const path = promptPath(dir, name);
+    if (!existsSync(path)) {
+        const known = await listPrompts(dir);
+        throw usageError(`no prompt named ${name.replace(/^\//, '')}`, known.length > 0
+            ? `try: ${known.map((p) => `/${p}`).join(', ')}`
+            : `put one in ${PROMPT_DIR}/`);
+    }
+    return readPrompt(path, name.replace(/^\//, ''), await readFile(path, 'utf8'));
+}
+export async function listPrompts(dir) {
+    const { readdir } = await import('node:fs/promises');
+    try {
+        const names = await readdir(`${dir}/${PROMPT_DIR}`);
+        return names
+            .filter((n) => n.endsWith(PROMPT_SUFFIX))
+            .map((n) => n.slice(0, -PROMPT_SUFFIX.length))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * A `copilot` already installed is used as it is; otherwise `npx` fetches one.
+ * Note that finding the name on `PATH` is not the same as finding the CLI —
+ * an editor may have put a shim there that installs it on first run — so this
+ * only decides how to launch, never whether it will work.
+ */
+export function locate(has = (cmd) => onPath(cmd)) {
+    return has('copilot')
+        ? { command: 'copilot', args: [], from: 'path' }
+        : { command: 'npx', args: ['--yes', '@github/copilot'], from: 'npx' };
+}
+function onPath(cmd) {
+    const dirs = (process.env.PATH ?? '').split(':').filter(Boolean);
+    return dirs.some((d) => existsSync(`${d}/${cmd}`));
+}
+export const terminalSink = {
+    answer: (text) => write(text),
+    narrate: (line) => note(line),
+    warn: (line) => note(red(line)),
+};
+/** Rows of narration the window keeps on screen. */
+export const WINDOW_ROWS = 8;
+const BOX = { tl: '╭', tr: '╮', bl: '╰', br: '╯', h: '─', v: '│' };
+/** How often the border is redrawn — the wave's frame, not the clock's. */
+export const FRAME_MS = 80;
+// Dimmest first, crest last. Written as escapes rather than `styleText` because
+// a named colour has no ramp, which is also why `styled()` has to be asked.
+const WAVE = [
+    '\u001b[0;38;5;24m',
+    '\u001b[0;38;5;31m',
+    '\u001b[0;38;5;38m',
+    '\u001b[0;38;5;45m',
+    '\u001b[0;38;5;51m',
+    '\u001b[1;38;5;159m',
+    '\u001b[1;38;5;231m',
+];
+const RESET = '\u001b[0m';
+/** Cells each tone of the tail covers, so the crest reads as a band, not a dot. */
+const WAVE_TAIL = 2;
+/** Cells the crest travels per frame — a lap of a wide window in a few seconds. */
+export const WAVE_STEP = 3;
+/**
+ * How brightly one cell of the border is lit, given where the crest has got to.
+ *
+ * `position` counts clockwise from the top left corner, so one index walks the
+ * whole ring and the wave rounds the corners without a seam. Everything the
+ * tail has passed sits at the dimmest tone, which is the border's resting
+ * colour: the ring is always drawn, only the crest moves.
+ */
+export function toneAt(position, head, span) {
+    const behind = (((head - position) % span) + span) % span;
+    const step = Math.floor(behind / WAVE_TAIL);
+    return step < WAVE.length ? WAVE.length - 1 - step : 0;
+}
+/**
+ * A run of border cells, coloured by the wave and emitting an escape only where
+ * the tone changes — a frame of the whole ring is a handful of them.
+ *
+ * `from` is the ring position of the first cell and `step` which way round the
+ * ring the cells run, because the bottom rule is printed left to right while
+ * the ring travels it right to left.
+ */
+function lit(cells, from, step, head, span) {
+    let out = '';
+    let tone = -1;
+    for (let i = 0; i < cells.length; i++) {
+        const next = toneAt(from + i * step, head, span);
+        if (next !== tone) {
+            out += WAVE[next];
+            tone = next;
+        }
+        out += cells[i];
+    }
+    return `${out}${RESET}`;
+}
+/**
+ * The bottom rule as cells, with the status label set into it near the left.
+ *
+ * Waiting belongs to the frame rather than to the narration: a row of its own
+ * costs a step of what the agent is doing every time, and it settles just
+ * under the last line, which is where the eye already is. Near the left, where
+ * reading starts, and not so near that it displaces the corner.
+ */
+export function footerCells(label, width) {
+    const room = width - 6;
+    const text = label && room > 0 ? [...label].slice(0, room) : [];
+    const cells = text.length > 0 ? [BOX.bl, BOX.h, ' ', ...text, ' '] : [BOX.bl];
+    while (cells.length < width - 1) {
+        cells.push(BOX.h);
+    }
+    return [...cells, BOX.br];
+}
+/**
+ * Narration held to a fixed number of rows that rewrite themselves in place.
+ *
+ * A long run is hundreds of tool calls, and printing each as its own line
+ * scrolls the question, the model line and every warning off the top of the
+ * screen — by the end the terminal holds a transcript nobody asked for and the
+ * answer is somewhere in the middle of it. Only the last few steps say what it
+ * is doing now, which is the only thing narration is for; the rest is in the
+ * session copilot recorded.
+ *
+ * Warnings are not narration: they leave the window and stay on the screen.
+ *
+ * Without a terminal there is nothing to rewrite over, so every line is its
+ * own — which is what a CI log wants anyway.
+ */
+export function windowSink(rows = WINDOW_ROWS) {
+    if (!process.stderr.isTTY) {
+        return terminalSink;
+    }
+    const kept = [];
+    const colour = styled();
+    let label = '';
+    let head = 0;
+    let painted = 0;
+    // The frame must stay under the viewport: a block taller than the screen
+    // scrolls its own top away, and then the cursor-up erase falls short and
+    // strands a copy of every repaint. The two border rows count towards it.
+    const height = () => Math.max(1, Math.min(rows, (process.stderr.rows ?? 24) - 4));
+    const columns = () => Math.max(20, (process.stderr.columns ?? 80) - 1);
+    const innerOf = () => columns() - 4;
+    const erase = () => {
+        if (painted > 0) {
+            process.stderr.write(`\u001b[${painted}A\u001b[0J`);
+            painted = 0;
+        }
+    };
+    /** The whole frame, border lit by the wave, every row exactly one row. */
+    const frameOf = (show, inner) => {
+        const width = inner + 4;
+        // Clockwise from the top left: across the top, down the right, back
+        // along the bottom, up the left. One ring, so one index addresses it.
+        const span = 2 * width + 2 * show.length;
+        const top = [BOX.tl, ...Array(width - 2).fill(BOX.h), BOX.tr];
+        const bottom = footerCells(label, width);
+        const edge = (position) => colour ? lit([BOX.v], position, 1, head, span) : cyan(BOX.v);
+        return [
+            colour ? lit(top, 0, 1, head, span) : cyan(top.join('')),
+            ...show.map((line, r) => `${edge(span - 1 - r)} ${pad(cut(line, inner), inner)} ${edge(width + r)}`),
+            colour
+                ? lit(bottom, 2 * width + show.length - 1, -1, head, span)
+                : cyan(bottom.join('')),
+        ];
+    };
+    const paint = () => {
+        const show = kept.slice(-height());
+        if (show.length === 0 && label === '') {
+            erase();
+            return;
+        }
+        // The wave wants a frame to run round before there is anything to say.
+        const lines = frameOf(show.length > 0 ? show : [''], innerOf());
+        if (painted === lines.length) {
+            // Erasing before a repaint is what flickers; overwriting in place
+            // does not, and at frame rate the whole border has to be redrawn.
+            process.stderr.write(`\u001b[${painted}A${lines.map((l) => `\r${l}\u001b[0K\n`).join('')}`);
+            return;
+        }
+        erase();
+        process.stderr.write(lines.map((l) => `${l}\n`).join(''));
+        painted = lines.length;
+    };
+    return {
+        answer: (text) => {
+            erase();
+            write(text);
+        },
+        narrate: (line) => {
+            kept.push(...line.split('\n'));
+            if (kept.length > height() * 4) {
+                kept.splice(0, kept.length - height());
+            }
+            paint();
+        },
+        warn: (line) => {
+            erase();
+            note(red(line));
+            paint();
+        },
+        status: (line) => {
+            label = line;
+            head += WAVE_STEP;
+            paint();
+        },
+        close: erase,
+    };
+}
+/**
+ * The answer in the same box `zen run` draws it in: bounded width, rounded
+ * rule, formatted with full markdown styling (bold, italics, code, lists, quotes, tables).
+ *
+ * Redirected output gets the text and nothing else — `zen meta run ... > out.md`
+ * is meant to produce a file you can read, not one with a border down its side.
+ */
+export function answerBox(text, columns = process.stdout.columns ?? 80) {
+    if (!process.stdout.isTTY) {
+        return text.split('\n');
+    }
+    const outer = boxWidth(text, columns);
+    const inner = outer - 4;
+    const body = formatMarkdown(text, inner);
+    const rule = BOX.h.repeat(outer - 2);
+    return [
+        '',
+        dim(`${BOX.tl}${rule}${BOX.tr}`),
+        ...body.map((l) => `${dim(BOX.v)} ${pad(l, inner)} ${dim(BOX.v)}`),
+        dim(`${BOX.bl}${rule}${BOX.br}`),
+        '',
+    ];
+}
+/** `<project>/.tmp/logs/meta.<when>.log`, opened for append. */
+export function openLog(dir, now = new Date()) {
+    const two = (n) => String(n).padStart(2, '0');
+    const stamp = `${now.getFullYear()}${two(now.getMonth() + 1)}${two(now.getDate())}` +
+        `${two(now.getHours())}${two(now.getMinutes())}${two(now.getSeconds())}`;
+    const folder = `${dir}/.tmp/logs`;
+    mkdirSync(folder, { recursive: true });
+    const path = `${folder}/meta.${stamp}.log`;
+    const answerPath = `${folder}/meta.${stamp}.md`;
+    const file = createWriteStream(path, { flags: 'a' });
+    return {
+        path,
+        answerPath,
+        line: (text) => {
+            file.write(`${plain(text)}\n`);
+        },
+        saveAnswer: (text) => {
+            writeFileSync(answerPath, text.endsWith('\n') ? text : `${text}\n`);
+        },
+        close: () => {
+            file.end();
+        },
+    };
+}
+const sessionLog = (dir) => `${dir}/.tmp/logs/meta.sessions`;
+/** The single-id file older versions wrote. */
+const legacySession = (dir) => `${dir}/.tmp/logs/meta.session`;
+export function recordSession(dir, id, state) {
+    mkdirSync(`${dir}/.tmp/logs`, { recursive: true });
+    appendFileSync(sessionLog(dir), `${new Date().toISOString()}\t${id}\t${state}\n`);
+}
+/**
+ * The newest session that did not finish, else the newest of all. A quick
+ * question asked after a long run stopped must not stand in for it.
+ */
+export function lastSession(dir) {
+    let text;
+    try {
+        text = readFileSync(sessionLog(dir), 'utf8');
+    }
+    catch {
+        try {
+            return readFileSync(legacySession(dir), 'utf8').trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const latest = new Map();
+    for (const line of text.split('\n')) {
+        const [, id, state] = line.split('\t');
+        if (id && state) {
+            latest.delete(id);
+            latest.set(id, state);
+        }
+    }
+    const newestFirst = [...latest].reverse();
+    return (newestFirst.find(([, state]) => state !== 'done') ?? newestFirst[0])?.[0];
+}
+/** Everything the sink is told, kept by the log too — and the detail only there. */
+function tee(sink, log) {
+    return {
+        answer: (text) => sink.answer(text),
+        narrate: (line) => {
+            log.line(line);
+            sink.narrate(line);
+        },
+        detail: (line) => log.line(line),
+        warn: (line) => {
+            log.line(line);
+            sink.warn(line);
+        },
+        status: (line) => sink.status?.(line),
+        close: () => sink.close?.(),
+    };
+}
+/**
+ * Folds one event into the outcome and says what, if anything, to show for it.
+ *
+ * `assistant.message` carries both the running commentary and the final word;
+ * what separates them is `toolRequests`, so the last message that asked for no
+ * tool is the answer and the rest are narration.
+ */
+export function absorb(event, out, sink, width) {
+    const data = (event.data ?? {});
+    switch (event.type) {
+        case 'assistant.message': {
+            const content = String(data.content ?? '').trim();
+            const requests = Array.isArray(data.toolRequests) ? data.toolRequests : [];
+            if (requests.length === 0) {
+                out.answer = content;
+            }
+            else if (content) {
+                sink.narrate(cut(formatInline(content.replace(/\s+/g, ' ')), width));
+            }
+            break;
+        }
+        case 'tool.execution_start': {
+            const args = (data.arguments ?? {});
+            const what = String(args.command ?? args.description ?? data.toolName ?? '').trim();
+            // Step-by-step belongs in the log: on screen it is a wall of `$`
+            // saying less than the one line of commentary above it.
+            sink.detail?.(`$ ${what.replace(/\s+/g, ' ')}`);
+            break;
+        }
+        case 'tool.execution_complete': {
+            if (data.success === false) {
+                sink.detail?.(`  ${String(data.toolName ?? 'the tool')} failed`);
+            }
+            break;
+        }
+        case 'session.tools_updated': {
+            if (data.model) {
+                sink.detail?.(`model ${String(data.model)}`);
+            }
+            break;
+        }
+        case 'session.error': {
+            sink.warn(String(data.message ?? 'the session failed'));
+            break;
+        }
+        case 'model.call_failure': {
+            const status = data.statusCode ? ` (${String(data.statusCode)})` : '';
+            sink.warn(`${cut(String(data.errorMessage ?? 'the model call failed'), width)}${status}`);
+            break;
+        }
+        case 'result': {
+            out.exitCode = Number(event.exitCode ?? 0);
+            out.sessionId = event.sessionId;
+            out.usage = event.usage;
+            break;
+        }
+        default:
+            break;
+    }
+    out.events.push(event);
+}
+export async function launch(opts) {
+    const shown = opts.sink ?? windowSink();
+    const sink = opts.log ? tee(shown, opts.log) : shown;
+    const width = opts.width ?? Math.max(40, (process.stderr.columns ?? 100) - 4);
+    const start = opts.spawn ?? nodeSpawn;
+    const out = { answer: '', exitCode: 0, events: [] };
+    const child = start(opts.binary.command, [...opts.binary.args, ...opts.args], {
+        cwd: opts.cwd,
+        env: { ...process.env, ...opts.env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: false,
+    });
+    const stop = (signal) => () => {
+        child.kill(signal);
+    };
+    const onInt = stop('SIGINT');
+    const onTerm = stop('SIGTERM');
+    process.on('SIGINT', onInt);
+    process.on('SIGTERM', onTerm);
+    // The first model call says nothing for as long as it takes, and silence
+    // after the model line is indistinguishable from a hang.
+    const began = Date.now();
+    const beat = setInterval(() => {
+        const extra = opts.status?.();
+        sink.status?.(`working: ${duration(Date.now() - began)}${extra ? ` · ${extra}` : ''}`);
+    }, FRAME_MS);
+    beat.unref();
+    child.stderr?.on('data', (chunk) => {
+        const text = chunk.toString().trimEnd();
+        if (text) {
+            sink.narrate(dim(text));
+        }
+    });
+    try {
+        const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+        for await (const line of lines) {
+            if (!line.trim()) {
+                continue;
+            }
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                // Not ours to interpret, but losing it is worse than showing it.
+                sink.narrate(line);
+                continue;
+            }
+            absorb(event, out, sink, width);
+        }
+        const code = await new Promise((resolve) => {
+            child.on('close', (value, signal) => resolve(value ?? (signal ? 1 : 0)));
+        });
+        if (out.exitCode === 0 && code !== 0) {
+            out.exitCode = code;
+        }
+    }
+    finally {
+        clearInterval(beat);
+        process.off('SIGINT', onInt);
+        process.off('SIGTERM', onTerm);
+        // The answer is written by the caller, so the window has to be gone first.
+        sink.close?.();
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Resuming
+//
+// Copilot retries a failed model call itself, five times over about a minute,
+// and has no setting to change that. A run that outlasts it is still a session
+// on disk, so the retry happens one level up: wait, then resume that session.
+// ---------------------------------------------------------------------------
+/** Resumes after copilot's own retries run out; `--retries` overrides. */
+export const DEFAULT_RESUMES = 5;
+/** The first wait; it doubles per resume, up to `RESUME_MAX_MS`. */
+const RESUME_INITIAL_MS = 30_000;
+const RESUME_MAX_MS = 300_000;
+/** What the resumed session is told, since `-p` has to say something. */
+export const RESUME_PROMPT = 'The previous model call failed. Continue the task from where you stopped.';
+export function resumeDelayMs(attempt) {
+    return Math.min(RESUME_INITIAL_MS * 2 ** attempt, RESUME_MAX_MS);
+}
+/**
+ * Why the run is worth resuming, or undefined when waiting cannot help.
+ *
+ * Only a refusal that time can cure counts: a rate limit, the provider's own
+ * failure, a connection that timed out. A 400 or a bad key fails the same way
+ * however often it is sent - except the one below.
+ */
+export function transient(out) {
+    if (out.exitCode === 0 || !out.sessionId) {
+        return undefined;
+    }
+    const at = out.events.findLastIndex((e) => e.type === 'session.error');
+    const data = out.events[at]?.data;
+    if (!data) {
+        return undefined;
+    }
+    const status = Number(data.statusCode ?? 0);
+    if (data.errorType === 'rate_limit' || status === 429) {
+        return 'rate-limited (429)';
+    }
+    if (status === 408 || status >= 500) {
+        return `the provider failed (${status})`;
+    }
+    if (/timed out|connection error|ECONNRESET|ETIMEDOUT|EAI_AGAIN|socket hang up/i.test(String(data.message ?? ''))) {
+        return 'the connection failed';
+    }
+    if (status === 400 && injected(out.events.slice(0, at))) {
+        return 'refused a tool call copilot made itself (400)';
+    }
+    return undefined;
+}
+/**
+ * Whether the turn that failed began with a tool call copilot wrote, not the
+ * model. When a background command finishes, copilot adds a `read_bash` of its
+ * own; Gemini 3 rejects any tool call in the current turn that lacks its thought
+ * signature, so that request is a 400 every time. A new user message - the
+ * resume - starts a turn that no longer holds it.
+ */
+function injected(before) {
+    for (let i = before.length - 1; i >= 0; i--) {
+        const event = before[i];
+        if (event.type === 'system.notification') {
+            return true;
+        }
+        if (event.type === 'user.message') {
+            return false;
+        }
+        if (event.type === 'assistant.message') {
+            if (event.data?.model) {
+                return false;
+            }
+            const requests = event.data?.toolRequests;
+            if (Array.isArray(requests) && requests.length > 0) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/** An OTel time: `[seconds, nanoseconds]` in this exporter; epoch ms either way. */
+function epochMs(t) {
+    if (Array.isArray(t) && typeof t[0] === 'number') {
+        return t[0] * 1000 + Number(t[1] ?? 0) / 1e6;
+    }
+    if (typeof t === 'number') {
+        return t;
+    }
+    return typeof t === 'string' ? Date.parse(t) : undefined;
+}
+/**
+ * One line of the span file, as a model call - anything else is undefined.
+ * Only counts are read off it: whatever else a span may carry, none of it
+ * reaches the ledger.
+ */
+export function readSpan(line) {
+    let span;
+    try {
+        span = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    const attrs = (span.attributes ?? {});
+    if (span.type !== 'span' || attrs['gen_ai.operation.name'] !== 'chat') {
+        return undefined;
+    }
+    const num = (key) => Number(attrs[key] ?? 0) || 0;
+    const start = epochMs(span.startTime) ?? 0;
+    const end = epochMs(span.endTime) ?? start;
+    // Copilot counts reasoning beside the output; zen counts it inside.
+    const reasoning = num('gen_ai.usage.reasoning.output_tokens');
+    const cacheWrite = num('gen_ai.usage.cache_creation.input_tokens') ||
+        num('gen_ai.usage.cache_creation_input_tokens');
+    return {
+        model: String(attrs['gen_ai.response.model'] ?? attrs['gen_ai.request.model'] ?? '?'),
+        usage: {
+            inputTokens: num('gen_ai.usage.input_tokens'),
+            cachedInputTokens: num('gen_ai.usage.cache_read.input_tokens') ||
+                num('gen_ai.usage.cache_read_input_tokens'),
+            outputTokens: num('gen_ai.usage.output_tokens') + reasoning,
+            reasoningTokens: reasoning,
+        },
+        ...(cacheWrite ? { cacheWriteTokens: cacheWrite } : {}),
+        startedAt: new Date(start).toISOString(),
+        durationMs: Math.max(0, Math.round(end - start)),
+        session: typeof attrs['gen_ai.conversation.id'] === 'string'
+            ? attrs['gen_ai.conversation.id']
+            : undefined,
+        traceId: typeof span.traceId === 'string' ? span.traceId : undefined,
+        spanId: typeof span.spanId === 'string' ? span.spanId : undefined,
+    };
+}
+/** Whole lines out of a stream read in chunks; the unfinished tail is carried. */
+export function splitLines(carry, chunk) {
+    const parts = `${carry}${chunk}`.split('\n');
+    const rest = parts.pop() ?? '';
+    return { lines: parts.filter((l) => l.trim()), carry: rest };
+}
+/** Reads a span file as it grows. `stop()` reads what is left, once. */
+export function tailSpans(path, onCall, everyMs = 1000) {
+    let offset = 0;
+    let carry = '';
+    const poll = () => {
+        let fd;
+        try {
+            const size = statSync(path).size;
+            if (size <= offset) {
+                return;
+            }
+            fd = openSync(path, 'r');
+            const buf = Buffer.alloc(size - offset);
+            readSync(fd, buf, 0, buf.length, offset);
+            offset = size;
+            const split = splitLines(carry, buf.toString('utf8'));
+            carry = split.carry;
+            for (const line of split.lines) {
+                const call = readSpan(line);
+                if (call) {
+                    onCall(call);
+                }
+            }
+        }
+        catch {
+            // Not there yet: copilot creates it at the first span.
+        }
+        finally {
+            if (fd !== undefined) {
+                closeSync(fd);
+            }
+        }
+    };
+    const timer = setInterval(poll, everyMs);
+    timer.unref();
+    return {
+        stop: () => {
+            clearInterval(timer);
+            poll();
+        },
+    };
+}
+/** Calls and tokens so far, in the one line the status row and the summary share. */
+export class Tally {
+    calls = 0;
+    usage = {
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0,
+        reasoningTokens: 0,
+    };
+    add(call) {
+        this.calls += 1;
+        this.usage = {
+            inputTokens: this.usage.inputTokens + call.usage.inputTokens,
+            cachedInputTokens: this.usage.cachedInputTokens + call.usage.cachedInputTokens,
+            outputTokens: this.usage.outputTokens + call.usage.outputTokens,
+            reasoningTokens: this.usage.reasoningTokens + call.usage.reasoningTokens,
+        };
+    }
+    toString() {
+        const u = this.usage;
+        const cached = u.cachedInputTokens ? ` (${compact(u.cachedInputTokens)} cached)` : '';
+        return (`${this.calls} call${this.calls === 1 ? '' : 's'} · ${compact(u.inputTokens)} in${cached}` +
+            ` · ${compact(u.outputTokens)} out`);
+    }
+}
+/** 950, 12.3k, 1.8M. */
+export function compact(n) {
+    if (n < 1000) {
+        return String(n);
+    }
+    if (n < 1e6) {
+        return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+    }
+    return `${(n / 1e6).toFixed(n < 1e7 ? 2 : 1)}M`;
+}
+/**
+ * Copilot's own per-model totals from the last `session.shutdown` in a session's
+ * events - cumulative over every resume of it. Reasoning folded into output,
+ * as everywhere in zen.
+ */
+export function shutdownModels(events) {
+    const line = events
+        .split('\n')
+        .reverse()
+        .find((l) => l.includes('"session.shutdown"'));
+    if (!line) {
+        return undefined;
+    }
+    let metrics;
+    try {
+        metrics = JSON.parse(line).data?.modelMetrics ?? {};
+    }
+    catch {
+        return undefined;
+    }
+    return Object.entries(metrics).map(([model, m]) => {
+        const u = m.usage ?? {};
+        const reasoning = Number(u.reasoningTokens ?? 0);
+        return {
+            model,
+            calls: Number(m.requests?.count ?? 0),
+            usage: {
+                inputTokens: Number(u.inputTokens ?? 0),
+                cachedInputTokens: Number(u.cacheReadTokens ?? 0),
+                outputTokens: Number(u.outputTokens ?? 0) + reasoning,
+                reasoningTokens: reasoning,
+            },
+        };
+    });
+}
+export function sessionTotals(sessionId) {
+    const home = process.env.COPILOT_HOME ?? join(homedir(), '.copilot');
+    try {
+        return shutdownModels(readFileSync(join(home, 'session-state', sessionId, 'events.jsonl'), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Non-fatal, said once, because a competing file is a silent override. */
+export function providersWarning() {
+    const configured = process.env.COPILOT_PROVIDERS_CONFIG;
+    const path = configured ?? `${process.env.HOME ?? ''}/.copilot/providers.json`;
+    return existsSync(path)
+        ? yellow(`${path} may override the provider zen just wired`)
+        : undefined;
+}
+//# sourceMappingURL=meta.js.map