@zenera/cli 1.1.24 → 1.1.26

package/dist/meta/relay.js

@@ -0,0 +1,123 @@
+import { vertexEndpoint } from '@zenera/neo';
+import { GoogleAuth } from 'google-auth-library';
+import { timingSafeEqual } from 'node:crypto';
+import { createServer } from 'node:http';
+import { Readable } from 'node:stream';
+const VERTEX_VERSION = 'vertex-2023-10-16';
+export async function startVertexRelay(spec) {
+    const auth = new GoogleAuth({
+        keyFile: spec.keyFile,
+        scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+    });
+    const at = vertexEndpoint({
+        project: spec.project,
+        location: spec.location,
+        token: async () => {
+            const token = await auth.getAccessToken();
+            if (!token) {
+                throw new Error(`${spec.keyFile} minted no access token`);
+            }
+            return token;
+        },
+    });
+    return startRelay({ key: spec.key, base: at.base, token: at.token });
+}
+export async function startRelay(spec) {
+    const server = createServer((req, res) => {
+        relay(spec, req, res).catch((err) => {
+            fail(res, 502, 'api_error', `relay to vertex: ${err.message}`);
+        });
+    });
+    await new Promise((done, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', done);
+    });
+    const { port } = server.address();
+    return {
+        url: `http://127.0.0.1:${port}`,
+        close: () => new Promise((done) => {
+            server.closeAllConnections();
+            server.close(() => done());
+        }),
+    };
+}
+async function relay(spec, req, res) {
+    if (!authorized(spec.key, req)) {
+        fail(res, 401, 'authentication_error', 'not this session’s relay key');
+        return;
+    }
+    const path = new URL(req.url ?? '/', 'http://relay').pathname;
+    const counting = path === '/v1/messages/count_tokens';
+    if (req.method !== 'POST' || (path !== '/v1/messages' && !counting)) {
+        fail(res, 404, 'not_found_error', `vertex serves no ${req.method} ${path} for Claude`);
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(await readBody(req));
+    }
+    catch {
+        fail(res, 400, 'invalid_request_error', 'the body is not JSON');
+        return;
+    }
+    const { model, ...rest } = parsed;
+    if (!model) {
+        fail(res, 400, 'invalid_request_error', 'no model in the body');
+        return;
+    }
+    const url = counting
+        ? `${spec.base}/publishers/anthropic/models/count-tokens:rawPredict`
+        : `${spec.base}/publishers/anthropic/models/${encodeURIComponent(model)}:${rest.stream ? 'streamRawPredict' : 'rawPredict'}`;
+    const body = counting ? parsed : { ...rest, anthropic_version: VERTEX_VERSION };
+    const abort = new AbortController();
+    res.on('close', () => {
+        if (!res.writableFinished) {
+            abort.abort();
+        }
+    });
+    const beta = req.headers['anthropic-beta'];
+    const upstream = await fetch(url, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${await spec.token()}`,
+            'content-type': 'application/json',
+            ...(typeof beta === 'string' ? { 'anthropic-beta': beta } : {}),
+        },
+        body: JSON.stringify(body),
+        signal: abort.signal,
+    });
+    res.writeHead(upstream.status, {
+        'content-type': upstream.headers.get('content-type') ?? 'application/json',
+    });
+    if (!upstream.body) {
+        res.end();
+        return;
+    }
+    Readable.fromWeb(upstream.body)
+        .on('error', () => res.destroy())
+        .pipe(res);
+}
+function authorized(key, req) {
+    const header = req.headers['x-api-key'] ?? req.headers.authorization?.replace(/^Bearer /i, '');
+    const given = Buffer.from(typeof header === 'string' ? header : '');
+    const wanted = Buffer.from(key);
+    return given.length === wanted.length && timingSafeEqual(given, wanted);
+}
+function readBody(req) {
+    return new Promise((done, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => done(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+/** Anthropic's error shape, so copilot reports it as it would a direct call. */
+function fail(res, code, type, message) {
+    if (res.headersSent) {
+        res.destroy();
+        return;
+    }
+    res.writeHead(code, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ type: 'error', error: { type, message } }));
+}
+//# sourceMappingURL=relay.js.map

package/dist/meta/tokens.d.ts

@@ -0,0 +1,52 @@
+import type { ModelUsage, TokenUsage } from '@zenera/neo';
+export interface MetaCall {
+    model: string;
+    usage: TokenUsage;
+    cacheWriteTokens?: number;
+    startedAt: string;
+    durationMs: number;
+    session?: string;
+    traceId?: string;
+    spanId?: string;
+}
+/**
+ * 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 declare function readSpan(line: string): MetaCall | undefined;
+/** Whole lines out of a stream read in chunks; the unfinished tail is carried. */
+export declare function splitLines(carry: string, chunk: string): {
+    lines: string[];
+    carry: string;
+};
+/** Reads a span file as it grows. `stop()` reads what is left, once. */
+export declare function tailSpans(path: string, onCall: (call: MetaCall) => void, everyMs?: number): {
+    stop: () => void;
+};
+/** Calls and tokens so far, in the one line the status row and the summary share. */
+export declare class Tally {
+    calls: number;
+    usage: TokenUsage;
+    add(call: MetaCall): void;
+    toString(): string;
+}
+/** 950, 12.3k, 1.8M. */
+export declare function compact(n: number): string;
+/**
+ * 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 declare function shutdownModels(events: string): ModelUsage[] | undefined;
+export declare function sessionTotals(sessionId: string): ModelUsage[] | undefined;
+/** Whether this machine holds the session, which is what `--resume` needs. */
+export declare function sessionKept(sessionId: string): boolean;
+/**
+ * The model a session's history was written by: its last answer's, else the one it started on.
+ * A failed resume on another model writes no answer, so it never becomes the session's model.
+ */
+export declare function sessionModel(sessionId: string): string | undefined;
+/** `google/gemini-3.8-flash` and `gemini-3.8-flash` are one model to copilot. */
+export declare const sameModel: (a: string, b: string) => boolean;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/meta/tokens.js

@@ -0,0 +1,226 @@
+import { closeSync, existsSync, openSync, readFileSync, readSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** 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;
+    }
+}
+/** Whether this machine holds the session, which is what `--resume` needs. */
+export function sessionKept(sessionId) {
+    const home = process.env.COPILOT_HOME ?? join(homedir(), '.copilot');
+    return existsSync(join(home, 'session-state', sessionId));
+}
+/**
+ * The model a session's history was written by: its last answer's, else the one it started on.
+ * A failed resume on another model writes no answer, so it never becomes the session's model.
+ */
+export function sessionModel(sessionId) {
+    const home = process.env.COPILOT_HOME ?? join(homedir(), '.copilot');
+    let text;
+    try {
+        text = readFileSync(join(home, 'session-state', sessionId, 'events.jsonl'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    let started;
+    const lines = text.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line.includes('"assistant.message"') && !line.includes('"session.start"')) {
+            continue;
+        }
+        try {
+            const event = JSON.parse(line);
+            if (event.type === 'assistant.message' && typeof event.data?.model === 'string') {
+                return event.data.model;
+            }
+            if (event.type === 'session.start' && typeof event.data?.selectedModel === 'string') {
+                started = event.data.selectedModel;
+            }
+        }
+        catch {
+            // A line cut by a crash says nothing.
+        }
+    }
+    return started;
+}
+/** `google/gemini-3.8-flash` and `gemini-3.8-flash` are one model to copilot. */
+export const sameModel = (a, b) => a.replace(/^.*\//, '').toLowerCase() === b.replace(/^.*\//, '').toLowerCase();
+//# sourceMappingURL=tokens.js.map

package/dist/meta/window.d.ts

@@ -0,0 +1,61 @@
+export interface Sink {
+    answer(text: string): void;
+    narrate(line: string): void;
+    warn(line: string): void;
+    /** Kept by the log, never shown: the step-by-step nobody reads while it runs. */
+    detail?(line: string): void;
+    /** A transient last row, replaced each time and never kept. '' removes it. */
+    status?(line: string): void;
+    /** Called once when the run ends, so a repainting sink can clear itself. */
+    close?(): void;
+}
+export declare const terminalSink: Sink;
+/** Rows of narration the window keeps on screen. */
+export declare const WINDOW_ROWS = 8;
+/** How often the border is redrawn — the wave's frame, not the clock's. */
+export declare const FRAME_MS = 80;
+/** Cells the crest travels per frame — a lap of a wide window in a few seconds. */
+export declare 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 declare function toneAt(position: number, head: number, span: number): number;
+/**
+ * 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 declare function footerCells(label: string, width: number): string[];
+/**
+ * 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 declare function windowSink(rows?: number): Sink;
+/**
+ * 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 declare function answerBox(text: string, columns?: number): string[];
+//# sourceMappingURL=window.d.ts.map

package/dist/meta/window.js

@@ -0,0 +1,198 @@
+import { boxWidth, cut, cyan, dim, formatMarkdown, note, pad, red, styled, write } from "./host.js";
+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}`),
+        '',
+    ];
+}
+//# sourceMappingURL=window.js.map