@zenera/cli 1.1.24 → 1.1.26

package/dist/meta/finetune/tuning.js

@@ -0,0 +1,308 @@
+import { spawn } from 'node:child_process';
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { CliError, EXIT } from "../host.js";
+import { forget, remember } from "./children.js";
+import { Improvements } from "./improvements.js";
+import { Journal } from "./journal.js";
+import { Memories } from "./memories.js";
+import { Rechecks } from "./recheck.js";
+import { writeStatus } from "./report.js";
+import { SystemVersions } from "./system.js";
+// ---------------------------------------------------------------------------
+// One tuning, in progress
+//
+// Everything the workers and the applier share: where things go, the settings,
+// how `zen` is run, and what each worker is doing right now. Each case's own
+// progress is not held here - it is on disk, one folder per attempt.
+// ---------------------------------------------------------------------------
+export const FINETUNE_DIR = 'finetune';
+/** Where a tuning was kept before it moved to {@link FINETUNE_DIR}. */
+export const LEGACY_FINETUNE_DIR = '.finetune';
+export const DEFAULTS = {
+    workers: 4,
+    applyAt: 4,
+    tries: 4,
+    memTries: 3,
+    mergeEvery: 3,
+    seed: 1,
+    recheck: 3,
+    budget: 1500,
+    maxGrowth: 50,
+    skillCap: 12_000,
+    maxSkills: 10,
+};
+export class Stopped extends Error {
+    constructor() {
+        super('stopped');
+    }
+}
+const pad = (n) => String(n).padStart(2, '0');
+/** Failed cases in a row, with nothing going through between, that stop the loop. */
+export const FAILURES_IN_A_ROW = 3;
+export class Tuning {
+    root;
+    dir;
+    config;
+    zen;
+    tickMs;
+    workers;
+    claimed = new Set();
+    startedAt = Date.now();
+    recent = [];
+    system;
+    journal;
+    improvements;
+    rechecks;
+    memories;
+    stopping = false;
+    finished = false;
+    fatal;
+    /** woken cases waiting for a worker: they go before any new case */
+    resuming = 0;
+    /** every case of the selection has been started */
+    drained = false;
+    /** cases started by this process: a failed one is not taken twice in one start */
+    tried = new Set();
+    /** `--more`: cases of any kind this start may take; not kept in loop.json */
+    more;
+    /** cases failed since the last step that went through */
+    failures = 0;
+    /** what the last status page counted */
+    progress;
+    /** called with every live snapshot */
+    watchers = new Set();
+    /** the latest live snapshot */
+    live;
+    /** the latest step failures, newest first */
+    errors = [];
+    constructor(root, config, zen, tickMs = 1000) {
+        this.root = root;
+        this.dir = join(root, FINETUNE_DIR);
+        this.config = config;
+        this.zen = zen;
+        this.tickMs = tickMs;
+        this.workers = Array.from({ length: config.workers }, (_, slot) => ({
+            slot: slot + 1,
+            step: 'idle',
+            since: Date.now(),
+        }));
+        this.system = new SystemVersions(root, join(this.dir, 'systems'));
+        this.journal = new Journal(join(this.dir, 'journal.jsonl'));
+        this.improvements = new Improvements(this);
+        this.rechecks = new Rechecks(this);
+        this.memories = new Memories(this);
+    }
+    get stopFile() {
+        return join(this.dir, 'stop');
+    }
+    async tick() {
+        await sleep(this.tickMs);
+        if (!this.stopping && existsSync(this.stopFile)) {
+            this.stop('stop requested');
+        }
+    }
+    stop(why) {
+        if (!this.stopping) {
+            this.stopping = true;
+            this.event({ what: 'stopping', detail: why });
+        }
+    }
+    /** Between steps: a stop takes effect here, never in the middle of one. */
+    checkStopping() {
+        if (this.stopping) {
+            throw new Stopped();
+        }
+    }
+    caseDir(c) {
+        return join(this.dir, 'cases', c.id, `r${c.rev}`);
+    }
+    /** Where `retry` puts a case's earlier rounds: `r<rev>.<round>`. */
+    roundsDir(c) {
+        return join(this.dir, 'cases', c.id, 'rounds');
+    }
+    /** 1 for a case never retried at this revision. */
+    round(c) {
+        try {
+            return (readdirSync(this.roundsDir(c)).filter((n) => n.startsWith(`r${c.rev}.`)).length + 1);
+        }
+        catch {
+            return 1;
+        }
+    }
+    /** A step went through: the sandbox and the providers are up. */
+    succeeded() {
+        this.failures = 0;
+    }
+    /** A case failed for a reason outside the prose. Enough in a row means nothing will go through. */
+    failed(why) {
+        this.failures++;
+        if (this.failures >= FAILURES_IN_A_ROW && !this.stopping) {
+            this.fatal = new CliError(`${this.failures} cases failed in a row - the last: ${why}`, EXIT.failed, 'fix what broke (the sandbox, a provider, a key), then start again: failed cases carry on where they stopped');
+            this.stop(`${this.failures} cases failed in a row`);
+        }
+    }
+    /** No run goes through without the container engine: stop at the first sign, not the third. */
+    sandboxDown(why) {
+        this.fatal ??= new CliError(`the sandbox failed: ${why}`, EXIT.sandbox, 'see what the engine says: zen sandbox status - fix it, then start again: failed cases carry on where they stopped');
+        this.stop('the sandbox failed');
+    }
+    attemptDir(c, phase, attempt) {
+        return join(this.caseDir(c), `${pad(attempt)}-${phase}`);
+    }
+    /** The folder of the try a worker is on: the case's own, or a recheck's. */
+    workDir(w) {
+        return w.recheck?.dir ?? this.attemptDir(w.case, w.phase ?? 'nomem', w.attempt ?? 1);
+    }
+    /** What the loop knows of a try, which a feedback file is never trusted for. */
+    known(c, phase, attempt) {
+        const round = this.round(c);
+        return { case: c.id, caseRev: c.rev, ...(round > 1 ? { round } : {}), phase, attempt };
+    }
+    freeWorker() {
+        return this.workers.find((w) => !w.case);
+    }
+    busy() {
+        return this.workers.filter((w) => w.case).length;
+    }
+    /** Puts a case on a free worker, waiting for one; a woken case goes before a new one. */
+    async seat(s, woken) {
+        if (woken) {
+            this.resuming++;
+        }
+        try {
+            for (;;) {
+                const w = this.freeWorker();
+                if (w && (woken || this.resuming === 0)) {
+                    Object.assign(w, {
+                        case: s.case,
+                        phase: undefined,
+                        attempt: undefined,
+                        recheck: undefined,
+                        step: 'idle',
+                        since: Date.now(),
+                    });
+                    s.worker = w;
+                    return;
+                }
+                this.checkStopping();
+                await this.tick();
+            }
+        }
+        finally {
+            if (woken) {
+                this.resuming--;
+            }
+        }
+    }
+    /** Gives the case's worker back, for another case to use. */
+    unseat(s) {
+        if (!s.worker) {
+            return;
+        }
+        Object.assign(s.worker, {
+            case: undefined,
+            phase: undefined,
+            attempt: undefined,
+            recheck: undefined,
+            step: 'idle',
+            since: Date.now(),
+        });
+        s.worker = undefined;
+    }
+    /** A case moved to another step on its worker. */
+    at(s, phase, attempt, step) {
+        const w = s.worker;
+        s.phase = phase;
+        Object.assign(w, { case: s.case, phase, attempt, step, since: Date.now() });
+        this.event({
+            what: step,
+            worker: w.slot,
+            case: s.case.id,
+            rev: s.case.rev,
+            phase,
+            attempt,
+        });
+    }
+    /** A step ended: the worker is between steps until the next `at`, and the event says how it went. */
+    ended(s, e) {
+        if (s.worker) {
+            Object.assign(s.worker, { step: 'idle', since: Date.now() });
+        }
+        this.event({ worker: s.worker?.slot, case: s.case.id, rev: s.case.rev, ...e });
+    }
+    /** A step failed: kept for the live view, and in events.jsonl with its log. */
+    error(where, message, log) {
+        this.errors.unshift({
+            at: new Date().toISOString(),
+            where,
+            message,
+            ...(log ? { log } : {}),
+        });
+        this.errors.length = Math.min(this.errors.length, 20);
+        this.event({ what: 'error', detail: `${where}: ${message}${log ? ` - see ${log}` : ''}` });
+    }
+    event(e) {
+        const row = { at: new Date().toISOString(), ...e };
+        mkdirSync(this.dir, { recursive: true });
+        appendFileSync(join(this.dir, 'events.jsonl'), `${JSON.stringify(row)}\n`);
+        this.recent.unshift(row);
+        this.recent.length = Math.min(this.recent.length, 50);
+        this.report();
+    }
+    /** `live`: only what moves by the second is read again; the rest comes from the last full report. */
+    report(live = false) {
+        try {
+            writeStatus(this, live);
+        }
+        catch {
+            // A status page that failed to render must not stop the tuning.
+        }
+    }
+}
+/** The real `zen`: this same binary, in its own process group so Ctrl-C reaches only us. */
+export function spawnZen(root, children) {
+    return (args, log) => new Promise((resolve) => {
+        mkdirSync(dirname(log), { recursive: true });
+        const fd = openSync(log, 'a');
+        const child = spawn(process.execPath, [process.argv[1], ...args], {
+            cwd: root,
+            stdio: ['ignore', 'pipe', fd],
+            detached: true,
+        });
+        children.add(child);
+        const dir = join(root, FINETUNE_DIR);
+        if (child.pid !== undefined) {
+            remember(dir, child.pid, process.argv[1]);
+        }
+        let stdout = '';
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString('utf8');
+        });
+        let finished = false;
+        const done = (code) => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            children.delete(child);
+            if (child.pid !== undefined) {
+                forget(dir, child.pid);
+            }
+            closeSync(fd);
+            resolve({ code, stdout });
+        };
+        child.on('error', () => done(1));
+        child.on('close', (code) => done(code ?? 1));
+    });
+}
+export function readJson(file) {
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=tuning.js.map

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

@@ -0,0 +1,66 @@
+export interface Tokens {
+    calls: number;
+    input: number;
+    cached: number;
+    output: number;
+    reasoning: number;
+}
+export type ByModel = Record<string, Tokens>;
+export type Stage = 'run' | 'analyze' | 'apply';
+export declare const STAGES: Stage[];
+export type ByStage = Partial<Record<Stage, ByModel>>;
+export declare function mergeModels(...all: (ByModel | undefined)[]): ByModel;
+export declare function mergeStages(...all: (ByStage | undefined)[]): ByStage;
+export declare function total(by: ByModel | undefined): Tokens;
+/** Input plus output, the input counting cached tokens. */
+export declare function spent(by: ByModel | undefined): number;
+/** `vertex/gemini-3.8-flash` and `gemini-3.8-flash` are one model in a table. */
+export declare const modelName: (m: string | undefined) => string;
+export interface ModelMetrics extends Tokens {
+    /** the largest input of a single call */
+    peak: number;
+    /** time spent waiting on this model */
+    ms: number;
+}
+export interface RunMetrics {
+    models: Record<string, ModelMetrics>;
+    /** summed over every lane, so parallel branches can exceed the wall clock */
+    llmMs: number;
+    toolMs: number;
+    toolCalls: number;
+    toolErrors: number;
+    memory: {
+        recall: number;
+        load: number;
+        grep: number;
+        commit: number;
+        forget: number;
+    };
+    forks: number;
+    branches: number;
+    compactions: number;
+    handoffs: number;
+    /** skills loaded, preloads included, in the order first loaded */
+    skills: string[];
+    /** the first error a sandbox tool got from the container engine, not from a command */
+    sandbox?: string;
+}
+/**
+ * One walk of a run's `state.json`, branches included. Nested records repeat a
+ * node, so nodes are counted by id. A node is stamped when the work behind it
+ * finished, so the gap to the node before it in the same lane is that work -
+ * the same timing as the Stats tab of report.html.
+ */
+export declare function runMetrics(runDir: string): RunMetrics | undefined;
+/** The token part of a run's metrics, per model. */
+export declare function tokensOf(m: RunMetrics): ByModel;
+export declare function runTokens(runDir: string): ByModel | undefined;
+/** One `zen meta run --json` envelope: `{ model, tokens: { calls, inputTokens, … } }`. */
+export declare function envelopeTokens(file: string): ByModel | undefined;
+/** Every envelope in `dir` named `<stem>.json` or `<stem>-<n>.json` - retries keep their own. */
+export declare function envelopesIn(dir: string, stem: string): ByModel | undefined;
+/** An apply's own envelopes, and - for applies from before rechecks - its guard's runs: `guard/<attempt>/<case>/<try>/`. */
+export declare function applyTokens(dir: string): ByModel | undefined;
+/** 1234 → 1.2k, 2184341 → 2.2M. */
+export declare function short(n: number): string;
+//# sourceMappingURL=usage.d.ts.map

package/dist/meta/finetune/usage.js

@@ -0,0 +1,260 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+export const STAGES = ['run', 'analyze', 'apply'];
+const zero = () => ({ calls: 0, input: 0, cached: 0, output: 0, reasoning: 0 });
+function addTo(into, model, t) {
+    const m = (into[model] ??= zero());
+    m.calls += t.calls;
+    m.input += t.input;
+    m.cached += t.cached;
+    m.output += t.output;
+    m.reasoning += t.reasoning;
+}
+export function mergeModels(...all) {
+    const out = {};
+    for (const by of all) {
+        for (const [model, t] of Object.entries(by ?? {})) {
+            addTo(out, model, t);
+        }
+    }
+    return out;
+}
+export function mergeStages(...all) {
+    const out = {};
+    for (const stage of STAGES) {
+        const parts = all.map((s) => s?.[stage]).filter((p) => !!p);
+        if (parts.length > 0) {
+            out[stage] = mergeModels(...parts);
+        }
+    }
+    return out;
+}
+export function total(by) {
+    const sum = {};
+    for (const t of Object.values(by ?? {})) {
+        addTo(sum, 'all', t);
+    }
+    return sum.all ?? zero();
+}
+/** Input plus output, the input counting cached tokens. */
+export function spent(by) {
+    const s = total(by);
+    return s.input + s.output;
+}
+const fromUsage = (u, calls) => ({
+    calls,
+    input: u.inputTokens ?? 0,
+    cached: u.cachedInputTokens ?? 0,
+    output: u.outputTokens ?? 0,
+    reasoning: u.reasoningTokens ?? 0,
+});
+/** `vertex/gemini-3.8-flash` and `gemini-3.8-flash` are one model in a table. */
+export const modelName = (m) => m ? m.replace(/^[^/:]+[/:]/, '') : '?';
+/** `SandboxError`s the engine causes; a path outside the workspace is the model's own doing. */
+const SANDBOX_DOWN = /could not (create|start) container|the sandbox container \S+ stopped|could not (write|start) the job|is not installed, or not on PATH|exceeded num_locks|cannot connect to podman/i;
+const cache = new Map();
+/**
+ * One walk of a run's `state.json`, branches included. Nested records repeat a
+ * node, so nodes are counted by id. A node is stamped when the work behind it
+ * finished, so the gap to the node before it in the same lane is that work -
+ * the same timing as the Stats tab of report.html.
+ */
+export function runMetrics(runDir) {
+    const file = join(runDir, 'state.json');
+    if (!existsSync(file)) {
+        return undefined;
+    }
+    const st = statSync(file);
+    const key = `${st.mtimeMs}:${st.size}`;
+    const hit = cache.get(file);
+    if (hit?.key === key) {
+        return hit.metrics;
+    }
+    let root;
+    try {
+        root = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    const m = {
+        models: {},
+        llmMs: 0,
+        toolMs: 0,
+        toolCalls: 0,
+        toolErrors: 0,
+        memory: { recall: 0, load: 0, grep: 0, commit: 0, forget: 0 },
+        forks: 0,
+        branches: 0,
+        compactions: 0,
+        handoffs: 0,
+        skills: [],
+    };
+    const seen = new Set();
+    const count = (o, ms) => {
+        switch (o.type) {
+            case 'llm_call':
+            case 'compaction': {
+                if (!o.usage) {
+                    return;
+                }
+                const model = o.type === 'compaction' ? 'summarizer' : modelName(o.model);
+                const t = fromUsage(o.usage, 1);
+                const into = (m.models[model] ??= { ...zero(), peak: 0, ms: 0 });
+                into.calls += 1;
+                into.input += t.input;
+                into.cached += t.cached;
+                into.output += t.output;
+                into.reasoning += t.reasoning;
+                into.peak = Math.max(into.peak, t.input);
+                into.ms += ms;
+                m.llmMs += ms;
+                if (o.type === 'compaction') {
+                    m.compactions++;
+                }
+                return;
+            }
+            case 'tool_result': {
+                m.toolCalls++;
+                m.toolErrors += o.isError ? 1 : 0;
+                m.toolMs += typeof o.durationMs === 'number' ? o.durationMs : ms;
+                const said = o.result?.preview;
+                if (!m.sandbox && typeof said === 'string' && SANDBOX_DOWN.test(said)) {
+                    m.sandbox = /"error":\s*"([^"]+)/.exec(said)?.[1] ?? said;
+                }
+                return;
+            }
+            case 'memory_recall':
+                m.memory.recall++;
+                return;
+            case 'memory_op': {
+                const op = o.op;
+                if (op in m.memory) {
+                    m.memory[op]++;
+                }
+                return;
+            }
+            case 'fork':
+                m.forks++;
+                m.branches += Array.isArray(o.branches) ? o.branches.length : 0;
+                return;
+            case 'handoff':
+                m.handoffs++;
+                return;
+            case 'load_skills':
+                for (const s of Array.isArray(o.skills) ? o.skills : []) {
+                    const name = s?.name;
+                    if (typeof name === 'string' && !m.skills.includes(name)) {
+                        m.skills.push(name);
+                    }
+                }
+                return;
+        }
+    };
+    // A branch lane starts where its parent lane was when the fork began.
+    const walk = (v, lanePrev) => {
+        if (Array.isArray(v)) {
+            let prev = lanePrev;
+            for (const item of v) {
+                const o = item;
+                const ts = o && typeof o.ts === 'string' ? Date.parse(o.ts) : NaN;
+                if (o &&
+                    typeof o.type === 'string' &&
+                    typeof o.id === 'string' &&
+                    !seen.has(o.id)) {
+                    seen.add(o.id);
+                    count(o, prev !== undefined && !Number.isNaN(ts) ? Math.max(0, ts - prev) : 0);
+                }
+                walk(item, prev);
+                if (!Number.isNaN(ts)) {
+                    prev = ts;
+                }
+            }
+        }
+        else if (v && typeof v === 'object') {
+            for (const x of Object.values(v)) {
+                walk(x, lanePrev);
+            }
+        }
+    };
+    walk(root, undefined);
+    cache.set(file, { key, metrics: m });
+    return m;
+}
+/** The token part of a run's metrics, per model. */
+export function tokensOf(m) {
+    return Object.fromEntries(Object.entries(m.models).map(([model, { calls, input, cached, output, reasoning }]) => [
+        model,
+        { calls, input, cached, output, reasoning },
+    ]));
+}
+export function runTokens(runDir) {
+    const m = runMetrics(runDir);
+    return m ? tokensOf(m) : undefined;
+}
+/** One `zen meta run --json` envelope: `{ model, tokens: { calls, inputTokens, … } }`. */
+export function envelopeTokens(file) {
+    if (!existsSync(file)) {
+        return undefined;
+    }
+    let env;
+    try {
+        env = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    if (!env.tokens) {
+        return undefined;
+    }
+    return { [modelName(env.model)]: fromUsage(env.tokens, env.tokens.calls ?? 0) };
+}
+/** Every envelope in `dir` named `<stem>.json` or `<stem>-<n>.json` - retries keep their own. */
+export function envelopesIn(dir, stem) {
+    let names = [];
+    try {
+        names = readdirSync(dir).filter((n) => new RegExp(`^${stem}(-\\d+)?\\.json$`).test(n));
+    }
+    catch {
+        return undefined;
+    }
+    const parts = names.map((n) => envelopeTokens(join(dir, n))).filter((p) => !!p);
+    return parts.length > 0 ? mergeModels(...parts) : undefined;
+}
+/** An apply's own envelopes, and - for applies from before rechecks - its guard's runs: `guard/<attempt>/<case>/<try>/`. */
+export function applyTokens(dir) {
+    const parts = [envelopesIn(dir, 'apply')];
+    const under = (d) => {
+        try {
+            return readdirSync(d, { withFileTypes: true })
+                .filter((e) => e.isDirectory())
+                .map((e) => join(d, e.name));
+        }
+        catch {
+            return [];
+        }
+    };
+    for (const tryDir of under(join(dir, 'guard')).flatMap(under).flatMap(under)) {
+        parts.push(envelopesIn(tryDir, 'analyze'));
+        try {
+            const run = JSON.parse(readFileSync(join(tryDir, 'run.json'), 'utf8'));
+            parts.push(run.tokens);
+        }
+        catch {
+            // A void run wrote none.
+        }
+    }
+    const found = parts.filter((p) => !!p);
+    return found.length > 0 ? mergeModels(...found) : undefined;
+}
+/** 1234 → 1.2k, 2184341 → 2.2M. */
+export function short(n) {
+    if (n >= 1_000_000) {
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    }
+    if (n >= 1000) {
+        return `${Math.round(n / 1000)}k`;
+    }
+    return String(n);
+}
+//# sourceMappingURL=usage.js.map

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

@@ -0,0 +1,9 @@
+export interface Viewing {
+    url: string;
+    close(): Promise<void>;
+}
+/** The address another live process serves the tuning on, if one does. */
+export declare function liveView(projectDir: string): string | undefined;
+/** Serves the project, opening at STATUS.md, until `close`. */
+export declare function startView(projectDir: string): Promise<Viewing>;
+//# sourceMappingURL=view.d.ts.map

package/dist/meta/finetune/view.js

@@ -0,0 +1,27 @@
+import { liveHolder, ownLock } from '@zenera/neo';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { FINETUNE_DIR } from "./tuning.js";
+const lockFile = (projectDir) => join(projectDir, FINETUNE_DIR, 'view.json');
+/** The address another live process serves the tuning on, if one does. */
+export function liveView(projectDir) {
+    return liveHolder(lockFile(projectDir))?.url;
+}
+/** Serves the project, opening at STATUS.md, until `close`. */
+export async function startView(projectDir) {
+    const { serveView } = await import('@zenera/view');
+    const server = await serveView({ root: projectDir, start: `/${FINETUNE_DIR}/STATUS.md` });
+    const file = lockFile(projectDir);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, `${JSON.stringify(ownLock({ url: server.url }), null, 2)}\n`);
+    return {
+        url: server.url,
+        close: async () => {
+            if (liveHolder(file)?.pid === process.pid) {
+                rmSync(file, { force: true });
+            }
+            await server.close();
+        },
+    };
+}
+//# sourceMappingURL=view.js.map

package/dist/meta/host.d.ts

@@ -0,0 +1,15 @@
+export { invokedAs, parse } from '../args.ts';
+export type { EventLine } from '../eventlog.ts';
+export { paths, readJson, writeJson } from '../home.ts';
+export { envOf, type KeyEntry, type KeyStore, type Provider } from '../keys.ts';
+export { PROVIDER_NAMES, splitRef } from '../modelref.ts';
+export { duration } from '../narrate.ts';
+export { copyTree, SHARED_RULES, TEMPLATES } from '../scaffold.ts';
+export { bold, CliError, confirm, credentialError, cut, cyan, dim, EXIT, green, invalidError, json, note, pad, plain, red, styled, table, usageError, write, writeAll, yellow, } from '../term.ts';
+export { safe } from '../trace.ts';
+export { formatInline, formatMarkdown } from '../tui/markdown.ts';
+export { resolveTheme, type Theme } from '../tui/theme.ts';
+export { boxWidth } from '../tui/wrap.ts';
+export { META_PROMPT_ENV, META_SESSION_ENV } from '../usage.ts';
+export { validateProject, type Report as ProjectReport } from '../validate.ts';
+//# sourceMappingURL=host.d.ts.map