@zenera/cli 1.1.24 → 1.1.25

package/dist/tui/models.js

@@ -0,0 +1,389 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// ---------------------------------------------------------------------------
+// zen models browse
+//
+// The catalog as something to walk rather than something to grep: providers,
+// then what one of them serves, then one model in full — with a key to ask it
+// a real question and a key to take it.
+//
+// Drawn on STDERR, like the banner and every other piece of narration, so the
+// one thing that reaches stdout is the ref picked at the end. That is what
+// makes `ref=$(zen models browse)` work the way `zen models pick` does: the
+// person sees the interface, the shell sees the answer.
+//
+// Nothing here knows how to list or probe a model. Both arrive as callbacks
+// from commands/models.ts, which already owns credentials and the catalog, so
+// this file is layout and keys and nothing else.
+// ---------------------------------------------------------------------------
+import { Box, render, Text, useApp, useInput, useStdout } from 'ink';
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import { byGroup, isPartner, matches, } from "../catalog.js";
+import { ago } from "../term.js";
+import { resolveTheme } from "./theme.js";
+import { clip, scrollTop, wrap } from "./wrap.js";
+const ROLES = ['chat', 'embedding', 'image', 'audio'];
+const message = (err) => (err instanceof Error ? err.message : String(err));
+const thousands = (n) => n === undefined ? '' : n >= 1000 ? `${Math.round(n / 1000)}k` : String(n);
+const ms = (n) => (n < 1000 ? `${n}ms` : `${(n / 1000).toFixed(1)}s`);
+function freshness(origin, fetchedAt) {
+    switch (origin) {
+        case 'curated':
+            return 'built-in list';
+        case 'stale':
+            return `stale, ${ago(fetchedAt)}`;
+        case 'live':
+            return 'fetched now';
+        default:
+            return `cached ${ago(fetchedAt)}`;
+    }
+}
+function said(verdict, theme) {
+    if (verdict === undefined) {
+        return undefined;
+    }
+    if (verdict === 'asking') {
+        return { text: '… asking', color: theme.warn };
+    }
+    switch (verdict.state) {
+        case 'live':
+            return {
+                text: `✓ answers ${verdict.ms === undefined ? '' : ms(verdict.ms)}`.trim(),
+                color: theme.code.color,
+            };
+        case 'blocked':
+            return { text: '! blocked', color: theme.warn };
+        case 'dead':
+            return { text: '✗ refused', color: theme.line.error.color };
+        default:
+            return { text: '? no answer', color: theme.chrome.color };
+    }
+}
+/** One row, never wrapped: a wrapped row is a row the frame did not budget for. */
+function Row({ children, ...style }) {
+    return (_jsx(Text, { wrap: "truncate-end", ...style, children: children }));
+}
+function Keys({ theme, text }) {
+    return _jsx(Row, { color: theme.chrome.color, children: text });
+}
+function Browser({ options, theme, onPick }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [size, setSize] = useState({ columns: stdout.columns || 80, rows: stdout.rows || 24 });
+    useEffect(() => {
+        const resized = () => setSize({ columns: stdout.columns || 80, rows: stdout.rows || 24 });
+        stdout.on('resize', resized);
+        return () => {
+            stdout.off('resize', resized);
+        };
+    }, [stdout]);
+    const start = options.providers.findIndex((p) => p.provider === options.initial);
+    const [screen, setScreen] = useState(start >= 0 ? 'models' : 'providers');
+    const [at, setAt] = useState(Math.max(0, start));
+    const [catalogs, setCatalogs] = useState(new Map());
+    const [loading, setLoading] = useState();
+    const [failure, setFailure] = useState();
+    const [query, setQuery] = useState('');
+    const [typing, setTyping] = useState(false);
+    const [role, setRole] = useState(0);
+    const [selected, setSelected] = useState(0);
+    const [verdicts, setVerdicts] = useState(new Map());
+    const [closing, setClosing] = useState(false);
+    const top = useRef(0);
+    const provider = options.providers[at].provider;
+    const catalog = catalogs.get(provider);
+    const load = (p, refresh) => {
+        setLoading(p);
+        setFailure(undefined);
+        options.load(p, refresh).then((cat) => {
+            setCatalogs((prev) => new Map(prev).set(p, cat));
+            setLoading((now) => (now === p ? undefined : now));
+        }, (err) => {
+            setFailure(message(err));
+            setLoading((now) => (now === p ? undefined : now));
+        });
+    };
+    useEffect(() => {
+        if (start >= 0) {
+            load(provider, false);
+        }
+        // Once, for `zen models browse <provider>`; every later open is a key.
+    }, []);
+    useEffect(() => {
+        if (closing) {
+            exit();
+        }
+    }, [closing, exit]);
+    // Only the roles this listing actually has: cycling through `audio` on a
+    // provider with no audio models is a keypress spent on an empty screen.
+    const present = useMemo(() => [
+        undefined,
+        ...ROLES.filter((r) => catalog?.entries.some((e) => e.roles.includes(r))),
+    ], [catalog]);
+    const only = present[role % present.length];
+    const rows = useMemo(() => (catalog?.entries ?? [])
+        .filter((e) => matches(e, query, { roles: only ? [only] : [] }))
+        .sort(byGroup), [catalog, query, only]);
+    const index = Math.min(selected, Math.max(0, rows.length - 1));
+    const current = rows[index];
+    const open = (next) => {
+        const p = options.providers[next].provider;
+        setAt(next);
+        setScreen('models');
+        setQuery('');
+        setTyping(false);
+        setRole(0);
+        setSelected(0);
+        top.current = 0;
+        if (!catalogs.has(p)) {
+            load(p, false);
+        }
+    };
+    const ask = (entry) => {
+        if (verdicts.get(entry.ref) === 'asking') {
+            return;
+        }
+        setVerdicts((prev) => new Map(prev).set(entry.ref, 'asking'));
+        options.test(entry).then((v) => setVerdicts((prev) => new Map(prev).set(entry.ref, v)), (err) => setVerdicts((prev) => new Map(prev).set(entry.ref, { state: 'unknown', detail: message(err) })));
+    };
+    const pick = (entry) => {
+        onPick(entry);
+        setClosing(true);
+    };
+    // Everything but the list is a fixed number of rows, and the list gets
+    // what is left. A row is kept in hand: a frame as tall as the viewport is
+    // the one Ink cannot erase (see tui/app.tsx).
+    const problem = catalog?.problem;
+    const chrome = 6 + (problem ? 1 : 0);
+    const height = Math.max(3, size.rows - 1 - chrome);
+    top.current = scrollTop(index, top.current, height, rows.length);
+    useInput((input, key) => {
+        if (closing) {
+            return;
+        }
+        const quit = () => setClosing(true);
+        if (screen === 'providers') {
+            const n = options.providers.length;
+            if (key.upArrow || input === 'k') {
+                setAt((i) => (i + n - 1) % n);
+            }
+            else if (key.downArrow || input === 'j') {
+                setAt((i) => (i + 1) % n);
+            }
+            else if (key.return || key.rightArrow || input === 'l') {
+                open(at);
+            }
+            else if (key.escape || input === 'q') {
+                quit();
+            }
+            return;
+        }
+        if (screen === 'detail') {
+            if (!current) {
+                setScreen('models');
+            }
+            else if (input === 't') {
+                ask(current);
+            }
+            else if (key.return || input === 'p') {
+                pick(current);
+            }
+            else if (key.escape || key.leftArrow || input === 'h') {
+                setScreen('models');
+            }
+            else if (input === 'q') {
+                quit();
+            }
+            return;
+        }
+        const move = (by) => setSelected(Math.max(0, Math.min(rows.length - 1, index + by)));
+        if (key.upArrow) {
+            return move(-1);
+        }
+        if (key.downArrow) {
+            return move(1);
+        }
+        if (key.pageUp) {
+            return move(-height);
+        }
+        if (key.pageDown) {
+            return move(height);
+        }
+        if (typing) {
+            if (key.return) {
+                setTyping(false);
+            }
+            else if (key.escape) {
+                setQuery('');
+                setTyping(false);
+            }
+            else if (key.backspace || key.delete) {
+                setQuery((q) => q.slice(0, -1));
+                setSelected(0);
+            }
+            else if (input && !key.ctrl && !key.meta && !key.tab) {
+                // Fast typing or a paste can arrive as one chunk with the Enter
+                // inside it: keep the text, honour the Enter, drop the rest.
+                const [text = '', ...after] = input.split(/[\r\n]/);
+                setQuery((q) => q + text.replace(/[\u0000-\u001f\u007f]/g, ''));
+                setSelected(0);
+                if (after.length > 0) {
+                    setTyping(false);
+                }
+            }
+            return;
+        }
+        if (input === 'k') {
+            move(-1);
+        }
+        else if (input === 'j') {
+            move(1);
+        }
+        else if (key.home || input === 'g') {
+            setSelected(0);
+        }
+        else if (key.end || input === 'G') {
+            setSelected(Math.max(0, rows.length - 1));
+        }
+        else if (input.startsWith('/')) {
+            // A pasted `/gpt-5` arrives as one chunk, not as a slash and then
+            // the rest.
+            setTyping(true);
+            setQuery(input.slice(1));
+            setSelected(0);
+        }
+        else if (key.tab) {
+            setRole((r) => (r + 1) % present.length);
+            setSelected(0);
+        }
+        else if ((key.return || key.rightArrow || input === 'l') && current) {
+            setScreen('detail');
+        }
+        else if (input === 't' && current) {
+            ask(current);
+        }
+        else if (input === 'p' && current) {
+            pick(current);
+        }
+        else if (input === 'r') {
+            load(provider, true);
+        }
+        else if (key.escape && query) {
+            setQuery('');
+            setSelected(0);
+        }
+        else if (key.escape || key.leftArrow || input === 'h') {
+            setScreen('providers');
+        }
+        else if (input === 'q') {
+            quit();
+        }
+    });
+    if (closing) {
+        // An empty frame erases the last one, so the shell is left as it was
+        // found rather than with a stale picture of a list on it.
+        return null;
+    }
+    const width = Math.max(20, size.columns - 1);
+    if (screen === 'providers') {
+        const nameW = Math.max(...options.providers.map((p) => p.provider.length)) + 2;
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Row, { bold: true, color: theme.accent, children: "Providers" }), _jsx(Text, { children: " " }), options.providers.map((p, i) => {
+                    const here = i === at;
+                    const cat = catalogs.get(p.provider);
+                    const count = cat?.entries.length ?? p.models;
+                    const fresh = cat
+                        ? freshness(cat.origin, cat.fetchedAt)
+                        : freshness(p.origin, p.fetchedAt);
+                    return (_jsxs(Row, { children: [_jsxs(Text, { color: here ? theme.accent : undefined, bold: here, children: [here ? '› ' : '  ', p.provider.padEnd(nameW)] }), p.credential ? (_jsx(Text, { color: theme.code.color, children: p.credential.padEnd(15) })) : (_jsx(Text, { color: theme.line.error.color, children: 'no credential'.padEnd(15) })), _jsxs(Text, { color: theme.chrome.color, children: [`${count} model${count === 1 ? '' : 's'}`.padEnd(13), p.credential ? fresh : `zen key add ${p.provider}`] })] }, p.provider));
+                }), _jsx(Text, { children: " " }), _jsx(Keys, { theme: theme, text: "\u2191\u2193 move \u00B7 enter open \u00B7 q quit" })] }));
+    }
+    if (screen === 'detail' && current) {
+        return (_jsx(Detail, { entry: current, catalog: catalog, verdict: verdicts.get(current.ref), theme: theme, width: width, rows: size.rows - 1 }));
+    }
+    const header = catalog
+        ? `${provider} · ${catalog.entries.length} models · ${freshness(catalog.origin, catalog.fetchedAt)}`
+        : provider;
+    const idW = Math.min(44, Math.max(8, ...rows.map((e) => e.id.length))) + 2;
+    const shown = rows.slice(top.current, top.current + height);
+    const filter = typing ? `/${query}▌` : query ? `/${query}` : '';
+    let body;
+    if (failure) {
+        body = _jsx(Row, { color: theme.line.error.color, children: failure });
+    }
+    else if (loading === provider || !catalog) {
+        body = _jsxs(Row, { color: theme.warn, children: ["listing ", provider, " \u2026"] });
+    }
+    else if (rows.length === 0) {
+        body = (_jsx(Row, { color: theme.chrome.color, children: query ? `nothing matches "${query}"` : 'nothing listed' }));
+    }
+    else {
+        body = (_jsx(_Fragment, { children: shown.map((e, i) => {
+                const here = top.current + i === index;
+                const v = said(verdicts.get(e.ref), theme);
+                return (_jsxs(Row, { children: [_jsxs(Text, { color: here ? theme.accent : undefined, bold: here, children: [here ? '› ' : '  ', clip(e.id, idW - 2).padEnd(idW)] }), e.publisher ? (_jsx(Text, { color: isPartner(e) ? theme.warn : theme.code.color, children: clip(e.publisher, 11).padEnd(12) })) : null, _jsxs(Text, { color: theme.chrome.color, children: [e.roles.join('+').padEnd(16), thousands(e.contextLength).padStart(6), (e.pricing?.free ? '  free' : '').padEnd(7)] }), v ? _jsx(Text, { color: v.color, children: v.text }) : null] }, e.ref));
+            }) }));
+    }
+    const preview = current ? [current.name, current.description].filter(Boolean).join(' — ') : '';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Row, { children: [_jsx(Text, { bold: true, color: theme.accent, children: header }), _jsxs(Text, { color: theme.chrome.color, children: ['   role: ', only ?? 'all', filter ? '   ' : ''] }), _jsx(Text, { color: theme.code.color, children: filter })] }), problem ? (_jsxs(Row, { color: theme.warn, children: ["could not be listed: ", problem.detail ?? 'no reason given'] })) : null, _jsx(Text, { children: " " }), _jsx(Box, { flexDirection: "column", height: height, children: body }), _jsx(Row, { color: theme.chrome.color, children: clip(preview, width) || ' ' }), _jsx(Row, { color: theme.chrome.color, children: rows.length === 0
+                    ? ' '
+                    : `${index + 1} of ${rows.length}${rows.length < (catalog?.entries.length ?? 0) ? ` (${catalog.entries.length} in all)` : ''}` }), _jsx(Keys, { theme: theme, text: typing
+                    ? 'type to filter · enter keep · esc clear · ↑↓ move'
+                    : '↑↓ · / filter · tab role · ⏎ more · t test · p pick · r reload · esc back' })] }));
+}
+function Detail({ entry, catalog, verdict, theme, width, rows }) {
+    const facts = [];
+    const add = (label, value) => {
+        if (value) {
+            facts.push([label, value]);
+        }
+    };
+    add('name', entry.name);
+    add('roles', entry.roles.join(', '));
+    add('context', entry.contextLength ? `${entry.contextLength.toLocaleString()} tokens` : undefined);
+    add('max output', entry.maxOutputTokens ? `${entry.maxOutputTokens.toLocaleString()} tokens` : undefined);
+    add('dimensions', entry.dimensions ? String(entry.dimensions) : undefined);
+    add('input', entry.modalities?.input?.join(', '));
+    add('output', entry.modalities?.output?.join(', '));
+    add('supports', Object.entries(entry.supports ?? {})
+        .filter(([, on]) => on)
+        .map(([k]) => k)
+        .join(', '));
+    add('pricing', entry.pricing?.free
+        ? 'free'
+        : entry.pricing?.prompt
+            ? `$${entry.pricing.prompt}/token in, $${entry.pricing.completion ?? '?'}/token out`
+            : undefined);
+    add('released', entry.created);
+    add('source', entry.source === 'live' && catalog
+        ? `${entry.provider}, ${freshness(catalog.origin, catalog.fetchedAt)}`
+        : 'built-in list');
+    const v = said(verdict, theme);
+    const reason = verdict && verdict !== 'asking'
+        ? [
+            verdict.dimensions ? `${verdict.dimensions} dims` : '',
+            verdict.state === 'live' ? '' : (verdict.detail ?? ''),
+            verdict.fix ? `fix: ${verdict.fix}` : '',
+        ]
+            .filter(Boolean)
+            .join(' · ')
+        : '';
+    // Header, blank, facts, the verdict row, blank, keys — the description has
+    // whatever is left, and is cut rather than allowed to push the keys off.
+    const room = Math.max(0, rows - facts.length - 6);
+    const about = entry.description ? wrap(entry.description, width - 2).slice(0, room) : [];
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Row, { bold: true, color: theme.accent, children: entry.ref }), _jsx(Text, { children: " " }), facts.map(([label, value]) => (_jsxs(Row, { children: [_jsx(Text, { color: theme.chrome.color, children: `  ${label.padEnd(12)}` }), _jsx(Text, { children: value })] }, label))), _jsxs(Row, { children: [_jsxs(Text, { color: theme.chrome.color, children: ['  ', 'asked'.padEnd(12)] }), v ? (_jsx(Text, { color: v.color, children: v.text })) : (_jsx(Text, { color: theme.chrome.color, children: "not yet \u2014 t to ask it one question" })), reason ? _jsx(Text, { color: v?.color, children: `  ${reason}` }) : null] }), about.length > 0 ? _jsx(Text, { children: " " }) : null, about.map((line, i) => (_jsx(Row, { color: theme.chrome.color, children: `  ${line}` }, i))), _jsx(Text, { children: " " }), _jsx(Keys, { theme: theme, text: "t test \u00B7 p pick (prints the ref) \u00B7 esc back \u00B7 q quit" })] }));
+}
+/**
+ * Runs the browser until the person picks a model or leaves. Resolves to the
+ * picked entry, or undefined when nothing was picked.
+ */
+export async function browse(options) {
+    // Asked before Ink takes the terminal, as tui/app.tsx does.
+    const theme = await resolveTheme(options.theme);
+    let chosen;
+    const instance = render(_jsx(Browser, { options: options, theme: theme, onPick: (entry) => {
+            chosen = entry;
+        } }), { stdout: process.stderr });
+    await instance.waitUntilExit();
+    return chosen;
+}
+//# sourceMappingURL=models.js.map

package/dist/tui/wrap.d.ts

@@ -15,6 +15,11 @@ export declare function windowOf(text: string, width: number, rows: number): str
 export declare function clip(text: string, width: number): string;
 /** Word wrap. Every returned row is at most `width` columns wide. */
 export declare function wrap(text: string, width: number): string[];
+/**
+ * The first row of a scrolled list, moved as little as possible so that row
+ * `selected` is inside a window of `height` rows over `count` of them.
+ */
+export declare function scrollTop(selected: number, top: number, height: number, count: number): number;
 /** The three footer rows, its margin, the prompt, and a row in hand. */
 export declare const CHROME_ROWS = 7;
 /**

package/dist/tui/wrap.js

@@ -74,6 +74,18 @@ export function wrap(text, width) {
     }
     return out;
 }
+/**
+ * The first row of a scrolled list, moved as little as possible so that row
+ * `selected` is inside a window of `height` rows over `count` of them.
+ */
+export function scrollTop(selected, top, height, count) {
+    const h = Math.max(1, height);
+    let first = Math.min(top, selected);
+    if (selected >= first + h) {
+        first = selected - h + 1;
+    }
+    return Math.max(0, Math.min(first, count - h));
+}
 // ---------------------------------------------------------------------------
 // Dividing the frame
 //

package/dist/usage.d.ts

@@ -0,0 +1,78 @@
+import type { ModelUsage, TokenUsage } from '@zenera/neo';
+/** Set by `zen meta` for everything its agent runs, so all of it lands in one ledger. */
+export declare const LEDGER_ENV = "ZENERA_USAGE_LEDGER";
+/** The meta session whose agent started this process, if one did. */
+export declare const META_SESSION_ENV = "ZENERA_META_SESSION";
+/** The stored prompt that meta session was started with, if any. */
+export declare const META_PROMPT_ENV = "ZENERA_META_PROMPT";
+/**
+ * Where this project's usage goes: the variable when set, else the fine-tuning's
+ * own ledger when the project is being tuned. Elsewhere nothing is recorded.
+ */
+export declare function ledgerPath(projectDir: string): string | undefined;
+interface RowBase {
+    /** when the thing ended */
+    ts: string;
+}
+export interface MetaCallRow extends RowBase {
+    kind: 'meta.call';
+    session?: string;
+    model: string;
+    usage: TokenUsage;
+    cacheWriteTokens?: number;
+    startedAt: string;
+    durationMs: number;
+    traceId?: string;
+    spanId?: string;
+}
+export interface MetaSessionRow extends RowBase {
+    kind: 'meta.session';
+    session: string;
+    /** copilot's own totals for the whole session so far - cumulative across resumes */
+    models: ModelUsage[];
+    exitCode: number;
+    resumes: number;
+    startedAt: string;
+    durationMs: number;
+}
+export interface RunRow extends RowBase {
+    kind: 'run';
+    runDir?: string;
+    session?: string;
+    batchDir?: string;
+    item?: string;
+    ok: boolean;
+    error?: string;
+    stopReason?: string;
+    durationMs?: number;
+    models: ModelUsage[];
+}
+export interface BatchRow extends RowBase {
+    kind: 'batch';
+    batchDir: string;
+    input: string;
+    items: number;
+    ok: number;
+    failed: number;
+    concurrency: number;
+    memory: string;
+    startedAt: string;
+    durationMs: number;
+    models: ModelUsage[];
+}
+export interface AskRow extends RowBase {
+    kind: 'ask';
+    runDir: string;
+    node: string;
+    nodeAgent: string;
+    nodeModel: string;
+    model: string;
+    usage?: TokenUsage;
+    startedAt: string;
+    durationMs: number;
+}
+export type UsageRow = MetaCallRow | MetaSessionRow | RunRow | BatchRow | AskRow;
+/** Appends one row. Never throws: losing a line of accounting must not fail a run. */
+export declare function appendUsage(projectDir: string, row: UsageRow): void;
+export {};
+//# sourceMappingURL=usage.d.ts.map

package/dist/usage.js

@@ -0,0 +1,51 @@
+import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { warn } from "./term.js";
+// ---------------------------------------------------------------------------
+// The usage ledger
+//
+// One JSON line per thing that spent tokens: a meta agent call, a run, a batch,
+// an `inspect ask`. Append-only, so several processes - the meta agent, the
+// batch it started, the ask it is grading with - can write to one file at once.
+// Reports are folded out of it later; nothing here aggregates.
+// ---------------------------------------------------------------------------
+/** Set by `zen meta` for everything its agent runs, so all of it lands in one ledger. */
+export const LEDGER_ENV = 'ZENERA_USAGE_LEDGER';
+/** The meta session whose agent started this process, if one did. */
+export const META_SESSION_ENV = 'ZENERA_META_SESSION';
+/** The stored prompt that meta session was started with, if any. */
+export const META_PROMPT_ENV = 'ZENERA_META_PROMPT';
+/**
+ * Where this project's usage goes: the variable when set, else the fine-tuning's
+ * own ledger when the project is being tuned. Elsewhere nothing is recorded.
+ */
+export function ledgerPath(projectDir) {
+    const set = process.env[LEDGER_ENV]?.trim();
+    if (set) {
+        return set;
+    }
+    return existsSync(join(projectDir, 'finetune'))
+        ? join(projectDir, 'finetune', 'usage', 'ledger.jsonl')
+        : undefined;
+}
+let warned = false;
+/** Appends one row. Never throws: losing a line of accounting must not fail a run. */
+export function appendUsage(projectDir, row) {
+    const path = ledgerPath(projectDir);
+    if (!path) {
+        return;
+    }
+    const meta = process.env[META_SESSION_ENV]?.trim();
+    const line = { v: 1, ...row, project: projectDir, pid: process.pid, ...(meta ? { meta } : {}) };
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        appendFileSync(path, `${JSON.stringify(line)}\n`);
+    }
+    catch (err) {
+        if (!warned) {
+            warned = true;
+            warn(`could not record usage in ${path} - ${err.message}`);
+        }
+    }
+}
+//# sourceMappingURL=usage.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zenera/cli",
-    "version": "1.1.24",
+    "version": "1.1.25",
     "description": "Command-line front end for @zenera/neo: agentic projects you can run, share and commit.",
     "keywords": [
         "agents",
@@ -52,11 +52,12 @@
         "@google/genai": "^2.18.0",
         "@inkjs/ui": "^2.0.0",
         "@openrouter/sdk": "^1.2.80",
-        "@zenera/neo": "^1.1.24",
+        "@zenera/neo": "^1.1.25",
         "google-auth-library": "^10.0.0",
         "ink": "^7.1.1",
         "openai": "^6.0.0",
         "react": "^19.2.8",
+        "yaml": "^2.9.0",
         "yauzl": "^3.4.0",
         "yazl": "^3.3.1"
     },