@zenera/cli 1.1.11 → 1.1.12

package/dist/engine.js

@@ -1,4 +1,4 @@
-import { AgentRunner, FileMemoryStore, FilePayloadStore, SANDBOX_MOUNT, SKILLS_MOUNT, assertState, buildRunReport, exaTools, lastText, loadProject, readProjectConfig, renderReportHtml, sandboxTools, turns, workspaceTools, } from '@zenera/neo';
+import { AgentRunner, FilePayloadStore, SANDBOX_MOUNT, SKILLS_MOUNT, Workspace, assertState, buildRunReport, exaTools, lastText, loadProject, readProjectConfig, renderReportHtml, sandboxTools, turns, workspaceTools, } from '@zenera/neo';
 import { existsSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
@@ -27,7 +27,6 @@ export async function open(opts) {
     const meta = await readSessionMeta(opts.session);
     const workspace = resolve(meta.workspace);
     const payloads = new FilePayloadStore({ dir: opts.session.blobs, id: 'file' });
-    const memory = [new FileMemoryStore({ dir: opts.session.memory, id: 'file' })];
     // The config is read before the project is loaded because the sandbox is
     // configured by it and the tools have to exist before selectors can be
     // resolved against them. They are always registered, whether or not anyone
@@ -35,6 +34,7 @@ export async function open(opts) {
     // fails to load with "unknown tool", which would be a lie.
     let sandbox;
     let project;
+    let files;
     try {
         const { root, config } = readProjectConfig(opts.project.dir);
         // Assets and the skill catalog are mounted for both, under one name.
@@ -49,17 +49,21 @@ export async function open(opts) {
             keys: opts.keys,
             mounts,
         });
+        const workspaceOptions = {
+            root: workspace,
+            readOnly: opts.readOnly,
+            mount: sandbox.spec.workdir ?? SANDBOX_MOUNT,
+            mounts,
+        };
+        // The same view the file tools have, so a path the agent just wrote
+        // resolves the same way when it asks memory to keep a copy.
+        files = new Workspace(workspaceOptions);
         project = await loadProject(opts.project.dir, {
             tools: [
                 // Both groups are pointed at one directory, so both are told the
                 // one name for it: whatever `run_command` prints a path as,
                 // `read_file` accepts.
-                ...workspaceTools({
-                    root: workspace,
-                    readOnly: opts.readOnly,
-                    mount: sandbox.spec.workdir ?? SANDBOX_MOUNT,
-                    mounts,
-                }),
+                ...workspaceTools(workspaceOptions),
                 ...sandboxTools(sandbox.pool),
                 // Registered whether or not a key exists: the credential is
                 // read when a tool is called, so a project that names `exa:*`
@@ -69,7 +73,7 @@ export async function open(opts) {
             ],
             skillsAt: SKILLS_MOUNT,
             payloads,
-            memory,
+            resolveFile: (path) => files.within(path),
         });
     }
     catch (err) {
@@ -105,6 +109,7 @@ export async function open(opts) {
         lock,
         close: async () => {
             await teardown(sandbox.pool);
+            project.close();
             lock.release();
         },
     };

package/dist/main.js

@@ -151,5 +151,14 @@ async function usage(name) {
     write(`  -C, --directory <d> ${dim('Act as if run in <d>.')}`);
     write(`\n${dim(`Start with ${cyan(`${NAME} init`)}, then ${cyan(`${NAME} run`)}.`)}`);
 }
+// `zen memory ls | head` closes the pipe while we are still writing to it, and
+// an unhandled EPIPE turns that ordinary shell idiom into a stack trace. The
+// reader having left is not our error, so we stop quietly.
+process.stdout.on('error', (err) => {
+    if (err.code !== 'EPIPE') {
+        throw err;
+    }
+    process.exit(0);
+});
 process.exitCode = await main(process.argv.slice(2));
 //# sourceMappingURL=main.js.map

package/dist/podman.js

@@ -2,7 +2,7 @@ import { runProcess, SandboxError } from '@zenera/neo';
 import { readdirSync, statSync } from 'node:fs';
 import { homedir, platform } from 'node:os';
 import { join } from 'node:path';
-import { CliError, confirm, dim, EXIT, isInteractive, note } from "./term.js";
+import { CliError, confirm, dim, EXIT, isInteractive, note, progress } from "./term.js";
 const DEFAULT_MACHINE_CPUS = 2;
 const DEFAULT_MACHINE_MEMORY = 2048;
 /** Starting a virtual machine and pulling an image are both slow on purpose. */
@@ -73,7 +73,7 @@ async function preflight(opts) {
         const present = await call(['image', 'exists', opts.image], 30_000);
         if (present.code !== 0) {
             note(dim(`pulling ${opts.image} — this happens once`));
-            const pulled = await stream(engine, ['pull', opts.image], run);
+            const pulled = await stream(engine, ['pull', opts.image], run, 'pulling');
             if (pulled.code !== 0) {
                 throw sandboxError(`could not pull ${opts.image}`, first(pulled) || 'check the image name and your network');
             }
@@ -99,7 +99,7 @@ async function install(engine, opts, run) {
         throw sandboxError('podman is not installed', how);
     }
     note(dim('installing podman — this takes a few minutes'));
-    const done = await stream('brew', ['install', 'podman'], run);
+    const done = await stream('brew', ['install', 'podman'], run, 'installing podman');
     if (done.code !== 0) {
         throw sandboxError('could not install podman', first(done) || how);
     }
@@ -127,7 +127,7 @@ async function machine(engine, call, opts, run) {
         const cpus = String(opts.cpus ?? DEFAULT_MACHINE_CPUS);
         const memory = String(opts.memory ?? DEFAULT_MACHINE_MEMORY);
         note(dim(`initialising the podman machine (${cpus} cpus, ${memory} MiB) — once per host`));
-        const created = await stream(engine, ['machine', 'init', '--cpus', cpus, '--memory', memory], run);
+        const created = await stream(engine, ['machine', 'init', '--cpus', cpus, '--memory', memory], run, 'initialising the machine');
         if (created.code !== 0) {
             throw sandboxError('could not create the podman machine', first(created));
         }
@@ -143,7 +143,7 @@ async function machine(engine, call, opts, run) {
         args.push(chosen.Name);
     }
     note(dim('starting the podman machine'));
-    const started = await stream(engine, args, run, SLOW_MS);
+    const started = await stream(engine, args, run, 'starting the machine', SLOW_MS);
     if (started.code !== 0 && !/already running/i.test(started.stderr)) {
         throw sandboxError('could not start the podman machine', first(started));
     }
@@ -197,8 +197,8 @@ async function build(engine, spec, run, force = false) {
     }
     note(dim(`${force ? 'rebuilding' : 'building'} the sandbox image from ${spec.dockerfile}`));
     note(dim('  the agent runs its commands inside a container, so the image is needed first'));
-    note(dim('  this takes a few minutes; later runs reuse it until the Dockerfile changes'));
-    const built = await stream(engine, ['build', '--tag', spec.tag, '--file', spec.dockerfile, spec.context], run, BUILD_MS);
+    note(dim('  this takes a few minutes; later runs reuse it'));
+    const built = await stream(engine, ['build', '--tag', spec.tag, '--file', spec.dockerfile, spec.context], run, 'building the sandbox image', BUILD_MS);
     if (built.code !== 0) {
         throw new BuildError(`could not build ${spec.dockerfile}`, EXIT.sandbox, last(built) || 'run the build by hand to see what the engine says');
     }
@@ -384,13 +384,20 @@ function children(dir) {
     }
 }
 // ---------------------------------------------------------------------------
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const FRAME_MS = 100;
 /**
  * Long steps print as they go. A five-minute pull with no output is
  * indistinguishable from a hang, and the one thing worse than waiting is not
  * knowing whether you are waiting.
+ *
+ * The engine's own output is buffered until it exits, so while the step runs
+ * the only honest thing to show is that it is still running: a spinner and a
+ * clock, both of which have to move without any event to move them. Off
+ * without a terminal — a CI log wants one line per fact, not ten a second.
  */
-async function stream(bin, args, run, timeoutMs = SLOW_MS) {
-    const res = await run(bin, args, { timeoutMs });
+async function stream(bin, args, run, label, timeoutMs = SLOW_MS) {
+    const res = await ticking(label, run(bin, args, { timeoutMs }));
     for (const line of res.stderr.split('\n').slice(-3)) {
         if (line.trim()) {
             note(dim(`  ${line.trim()}`));
@@ -398,6 +405,33 @@ async function stream(bin, args, run, timeoutMs = SLOW_MS) {
     }
     return res;
 }
+async function ticking(label, work) {
+    if (!process.stderr.isTTY) {
+        return work;
+    }
+    const bar = progress();
+    const startedAt = Date.now();
+    let frame = 0;
+    const timer = setInterval(() => {
+        const spin = SPINNER[frame++ % SPINNER.length];
+        bar.update(dim(`  ${spin} ${label}  ${elapsed(Date.now() - startedAt)}`));
+    }, FRAME_MS);
+    timer.unref();
+    try {
+        return await work;
+    }
+    finally {
+        clearInterval(timer);
+        bar.done();
+    }
+}
+function elapsed(ms) {
+    const total = Math.floor(ms / 1000);
+    const seconds = total % 60;
+    return total < 60
+        ? `${seconds}s`
+        : `${Math.floor(total / 60)}m ${String(seconds).padStart(2, '0')}s`;
+}
 function first(res) {
     return (res.stderr.trim() || res.stdout.trim()).split('\n')[0] ?? '';
 }

package/dist/projects.js

@@ -1,5 +1,5 @@
-import { ASSETS_MOUNT, assetsDir, skillDirs, skillMounts, SKILLS_MOUNT, } from '@zenera/neo';
-import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync } from 'node:fs';
+import { ASSETS_MOUNT, assetsDir, FILES_DIR, MEMORY_MOUNT, memoryDir, skillDirs, skillMounts, SKILLS_MOUNT, } from '@zenera/neo';
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 import { paths, readJson, writeJson } from "./home.js";
 import { isStamp } from "./ids.js";
@@ -47,6 +47,14 @@ export function projectMounts(root, config) {
     for (const dir of skillMounts(skillDirs(root, config), SKILLS_MOUNT)) {
         mounts.push({ host: realpathSync(dir.path), at: dir.at, readOnly: true });
     }
+    const memory = memoryDir(root, config);
+    if (memory) {
+        // Created here because the mount is decided before the project is
+        // loaded, and podman would refuse a source that does not exist yet.
+        const files = join(memory, FILES_DIR);
+        mkdirSync(files, { recursive: true });
+        mounts.push({ host: realpathSync(files), at: MEMORY_MOUNT, readOnly: true });
+    }
     return mounts;
 }
 // ---------------------------------------------------------------------------

package/dist/scaffold.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from 'node:fs';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 // ---------------------------------------------------------------------------
@@ -22,6 +22,12 @@ import { fileURLToPath } from 'node:url';
 // What is there is deliberately close to empty: a template full of
 // commented-out options is a template nobody reads and everybody deletes. The
 // one agent works as written, and every other knob is in `docs/`.
+//
+// `SPECIFICATION.md` is the exception, and is written out in full. It states
+// what the project that was just scaffolded is for and what it may do, and it
+// is *true as written* — so the first thing anyone sees is a specification
+// standing next to the files that implement it, which is the shape every
+// change to the project is then made in.
 // ---------------------------------------------------------------------------
 const TEMPLATES = fileURLToPath(new URL('../templates', import.meta.url));
 /** The suffix on a file with `{{...}}` in it, dropped when the file lands. */
@@ -42,6 +48,11 @@ function ownVersion() {
  * it — which is how an optional block leaves nothing behind. Anywhere else it
  * takes a word. A name nothing supplies throws, so a typo in a template is a
  * failing test rather than a `{{provider}}` sitting in somebody's agents.yaml.
+ *
+ * Only the value is trimmed at the end, never the start, so a fragment that has
+ * to be a paragraph of its own carries its own blank line as its first line.
+ * That way the template needs no blank line around the placeholder, and dropping
+ * the fragment leaves the surrounding paragraphs exactly as they were.
  */
 function render(text, vars) {
     const value = (name) => {
@@ -123,6 +134,10 @@ function copyTree(from, dir, rel, opts) {
             ? render(readFileSync(source, 'utf8'), opts.vars ?? {})
             : readFileSync(source);
         writeFileSync(join(dir, child), body);
+        // The bytes are copied, not the file, so a script arrives unrunnable.
+        if (child.endsWith('.sh')) {
+            chmodSync(join(dir, child), 0o755);
+        }
         written.push(child);
     }
     return written;
@@ -176,7 +191,13 @@ export function scaffold(opts) {
         keep: true,
         vars: {
             model: modelSection(opts.model, opts.modelOptions),
+            modelRef: opts.model,
             exa: opts.web ? part('exa.yaml') : '',
+            // The same capability stated three times, because the grant, the
+            // specification of it and the instruction to use it are read by
+            // different readers — and a tool nothing says to use is not one.
+            web: opts.web ? part('exa.spec.md') : '',
+            webPrompt: opts.web ? part('exa.prompt.md') : '',
             version: ownVersion(),
         },
     });

package/dist/tui/app.js

@@ -35,9 +35,9 @@ function Row({ line }) {
     const style = useTheme().line[line.kind];
     return (_jsxs(Box, { flexDirection: "row", marginTop: line.kind === 'you' ? 1 : 0, children: [_jsxs(Text, { color: style.color, dimColor: style.dim, children: [MARK[line.kind], ' '] }), _jsxs(Box, { flexDirection: "column", children: [line.kind === 'agent' ? (_jsx(Answer, { text: line.text })) : (
                     // The lead is what the eye scans for down the left edge, so
-                    // it keeps the row's colour without its dimming. Nested
+                    // it carries the weight the row's text does not. Nested
                     // rather than one string: Ink dims a whole Text or none of it.
-                    _jsxs(Text, { children: [line.lead ? _jsx(Text, { color: style.color, children: `${line.lead} ` }) : null, _jsx(Text, { color: style.color, dimColor: style.dim, bold: line.kind === 'you', children: line.text })] })), line.detail ? _jsx(Text, { dimColor: true, children: line.detail }) : null] })] }));
+                    _jsxs(Text, { children: [line.lead ? _jsx(Text, { color: style.color, bold: true, children: `${line.lead} ` }) : null, _jsx(Text, { color: style.color, dimColor: style.dim, bold: line.kind === 'you', children: line.text })] })), line.detail ? _jsx(Text, { dimColor: true, children: line.detail }) : null] })] }));
 }
 function Answer({ text }) {
     const { stdout } = useStdout();
@@ -511,11 +511,13 @@ function branchBoxesOf(tools, branches, now, width, lane, share) {
             }),
             // Between the calls it made and the one it is making: the reasoning
             // is what got it from one to the other.
-            ...(gist ? [{ key: `g:${b.name}`, label: `… ${gist}`, detail: '', past: true }] : []),
+            ...(gist
+                ? [{ key: `g:${b.name}`, label: `… ${gist}`, detail: '', thinking: true }]
+                : []),
             ...live,
         ];
         if (!rows.length) {
-            rows.push({ key: `w:${b.name}`, label: 'thinking…', detail: '', past: false });
+            rows.push({ key: `w:${b.name}`, label: 'thinking…', detail: '', thinking: true });
         }
         boxes.push({
             name: b.name,
@@ -572,18 +574,19 @@ function fitActivity(boxes, trunk, allowance) {
     };
 }
 function Branches({ boxes, spin, columns, }) {
+    const theme = useTheme();
     return (_jsx(Box, { flexDirection: "column", children: boxes.map((b) => {
             // Ink truncates rather than wraps, so an over-wide rule clips
             // instead of costing the box a row it was not given.
             const used = 3 + b.title.length + 2 + 2 + b.stats.length + 1;
-            return (_jsxs(Box, { flexDirection: "column", height: BOX_CHROME + b.rows.length, children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: '╭─ ' }), _jsx(Text, { color: b.color, children: b.title }), _jsx(Text, { color: b.color, children: ` ${spin}` }), _jsx(Text, { dimColor: true, children: `  ${b.stats} ` }), _jsx(Text, { dimColor: true, children: '─'.repeat(Math.max(0, columns - used)) })] }), b.rows.map((r) => (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: b.color, children: '│ ' }), _jsx(Text, { dimColor: true, children: r.label }), _jsx(Text, { dimColor: true, children: r.detail })] }, r.key))), _jsx(Text, { dimColor: true, children: '╰─' })] }, b.name));
+            return (_jsxs(Box, { flexDirection: "column", height: BOX_CHROME + b.rows.length, children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: '╭─ ' }), _jsx(Text, { color: b.color, children: b.title }), _jsx(Text, { color: b.color, children: ` ${spin}` }), _jsx(Text, { dimColor: true, children: `  ${b.stats} ` }), _jsx(Text, { dimColor: true, children: '─'.repeat(Math.max(0, columns - used)) })] }), b.rows.map((r) => (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: b.color, children: '│ ' }), _jsx(Text, { color: r.thinking ? theme.thinking.color : undefined, dimColor: r.thinking ? theme.thinking.dim : undefined, children: r.label }), _jsx(Text, { dimColor: true, children: r.detail })] }, r.key))), _jsx(Text, { dimColor: true, children: '╰─' })] }, b.name));
         }) }));
 }
 function Activity({ rows, hidden, }) {
     if (!rows.length && !hidden) {
         return null;
     }
-    return (_jsxs(Box, { flexDirection: "column", height: rows.length + (hidden ? 1 : 0), overflow: "hidden", children: [rows.map((r) => (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: '  ' }), _jsx(Text, { color: r.color, dimColor: r.color === undefined, children: r.label }), _jsx(Text, { dimColor: true, children: r.detail })] }, r.key))), hidden ? (_jsx(Text, { dimColor: true, children: `  + ${hidden} more ${hidden === 1 ? 'branch' : 'branches'}` })) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", height: rows.length + (hidden ? 1 : 0), overflow: "hidden", children: [rows.map((r) => (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: '  ' }), _jsx(Text, { color: r.color, children: r.label }), _jsx(Text, { dimColor: true, children: r.detail })] }, r.key))), hidden ? (_jsx(Text, { dimColor: true, children: `  + ${hidden} more ${hidden === 1 ? 'branch' : 'branches'}` })) : null] }));
 }
 /**
  * A stable colour per branch, handed out in order of first sight. Held in a ref
@@ -635,11 +638,13 @@ function Thinking({ text, columns, rows, spin, live, }) {
     // Ink truncates rather than wraps, so an over-wide rule clips instead of
     // costing the block a row it was not given.
     const dashes = Math.max(0, columns - TITLE.length - (live ? 6 : 4));
-    return (_jsxs(Box, { flexDirection: "column", height: shown.length + THINKING_CHROME, overflow: "hidden", children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: '╭─ ' }), _jsx(Text, { dimColor: true, children: TITLE }), live ? _jsx(Text, { color: theme.warn, children: ` ${spin}` }) : null, _jsx(Text, { dimColor: true, children: ` ${'─'.repeat(dashes)}` })] }), shown.map((row, i) => {
-                // Not italic: dim italic on a dark terminal is the least
-                // legible thing available, and this is meant to be read.
+    const { color, dim } = theme.thinking;
+    return (_jsxs(Box, { flexDirection: "column", height: shown.length + THINKING_CHROME, overflow: "hidden", children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: '╭─ ' }), _jsx(Text, { color: color, children: TITLE }), live ? _jsx(Text, { color: color, children: ` ${spin}` }) : null, _jsx(Text, { dimColor: true, children: ` ${'─'.repeat(dashes)}` })] }), shown.map((row, i) => {
+                // Not italic, and not dim: dim italic on a dark terminal is the
+                // least legible thing available, and this is meant to be read.
+                // Its own hue is what separates it from the tool rows instead.
                 const head = HEADING.exec(row);
-                return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: '│ ' }), _jsx(Text, { dimColor: true, bold: head !== null, children: head ? head[1] : row })] }, i));
+                return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: color, children: '│ ' }), _jsx(Text, { color: color, dimColor: dim, bold: head !== null, children: head ? head[1] : row })] }, i));
             }), _jsx(Text, { dimColor: true, children: '╰─' })] }));
 }
 function Live({ text, columns, rows }) {
@@ -679,7 +684,10 @@ function Footer({ agent, busy, spin, running, forked, step, model, stats, inflig
                     : 'thinking';
     // A clip has already ended it with one.
     const status = what.endsWith('…') ? what : `${what}…`;
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.accent, dimColor: true, children: agent }), busy ? (_jsxs(Text, { color: theme.warn, children: ['  ', spin, " ", status] })) : null, busy ? _jsx(Text, { dimColor: true, children: `  ${aside}` }) : null] }), inflight ? (_jsxs(Text, { dimColor: true, children: ['this turn'.padEnd(LABEL), tokens(inflight.usage), ` · ${secs(inflight.durationMs)}`] })) : (_jsxs(_Fragment, { children: [stats.turn ? (_jsxs(Text, { dimColor: true, children: ['last turn'.padEnd(LABEL), tokens(stats.turn), stats.durationMs === undefined
+    // Nothing of its own in flight means the word above is about reasoning, so
+    // it takes the same hue the reasoning block does.
+    const musing = !running.length && !forked;
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.accent, children: agent }), busy ? (_jsxs(Text, { color: musing ? theme.thinking.color : theme.warn, children: ['  ', spin, " ", status] })) : null, busy ? _jsx(Text, { dimColor: true, children: `  ${aside}` }) : null] }), inflight ? (_jsxs(Text, { dimColor: true, children: ['this turn'.padEnd(LABEL), tokens(inflight.usage), ` · ${secs(inflight.durationMs)}`] })) : (_jsxs(_Fragment, { children: [stats.turn ? (_jsxs(Text, { dimColor: true, children: ['last turn'.padEnd(LABEL), tokens(stats.turn), stats.durationMs === undefined
                                 ? ''
                                 : ` · ${durationOf(stats.durationMs) ?? ''}`] })) : null, _jsxs(Text, { dimColor: true, children: ['session'.padEnd(LABEL), tokens(stats.session), stats.calls
                                 ? ` · ${stats.calls} ${stats.calls === 1 ? 'call' : 'calls'}`

package/dist/tui/theme.d.ts

@@ -13,6 +13,13 @@ export interface Theme {
     readonly accent: string;
     /** Read-only badge, busy label. */
     readonly warn: string;
+    /**
+     * Reasoning. It is not a tool call and it is not the answer, and drawn in
+     * the same dim foreground as the rows around it there was nothing to say
+     * which — a wall of one weight reads as one thing. Its own hue is what
+     * separates the model's thinking from the work it went on to do.
+     */
+    readonly thinking: LineStyle;
     /**
      * Branch colours, cycled in order of first sight. A fan-out is the one
      * place where colour carries information rather than decoration: eight

package/dist/tui/theme.js

@@ -4,8 +4,8 @@
 // A terminal already has a colour scheme, and it is not ours to replace. The
 // rule here is to name as few colours as possible and to name them by role:
 // the answer is drawn in the terminal's *own* foreground (no colour at all),
-// asides are drawn dim, and only the few things that must stand out —
-// the person's own turn, the agent name, a warning, an error — take a colour.
+// and only the few things that must stand out — the person's own turn, the
+// agent name, what it is reasoning about, a warning, an error — take a colour.
 //
 // That alone fixes most of it. `white` was the bug: it is legible on exactly
 // one kind of background, and half the world runs the other kind. `gray` was
@@ -13,6 +13,11 @@
 // unreadable on dark and invisible on paper. What is left is the handful of
 // accents that ANSI *does* let a light theme get wrong, so those swap.
 //
+// Dim is spent on *chrome* — box rules, clocks, the footer's numbers — and no
+// longer on content. Tool rows are most of what is on screen, and dimming them
+// put the bulk of the transcript one step from unreadable: the whole thing read
+// as too dark. They are content, so they get the foreground like content does.
+//
 // Note what is *not* here: no hex, no 256-colour ramps, no attempt at a brand.
 // A palette that ignores the user's scheme is worse on both schemes than one
 // that mostly defers to it.
@@ -22,16 +27,17 @@ const DARK = {
     line: {
         you: { color: 'cyan' },
         agent: {},
-        // Dim alone, never dim *and* `gray`: bright black is already the
-        // faintest colour a terminal has, and dimming it again puts the bulk
-        // of the transcript a step from unreadable.
-        tool: { dim: true },
-        note: { color: 'cyan', dim: true },
+        // Never dim, and never `gray`: bright black is already the faintest
+        // colour a terminal has, and either one puts the bulk of the
+        // transcript a step from unreadable.
+        tool: {},
+        note: { color: 'cyan' },
         error: { color: 'red' },
     },
     accent: 'cyan',
     warn: 'yellow',
-    lanes: ['magenta', 'cyan', 'green', 'yellow', 'blue', 'red'],
+    thinking: { color: 'magenta' },
+    lanes: ['cyan', 'green', 'yellow', 'blue', 'red', 'magenta'],
 };
 // On a light background `cyan` and `yellow` are barely darker than the paper.
 // Dimmed default foreground and `blue`/`magenta` are the same information,
@@ -41,14 +47,15 @@ const LIGHT = {
     line: {
         you: { color: 'blue' },
         agent: {},
-        tool: { dim: true },
-        note: { color: 'blue', dim: true },
+        tool: {},
+        note: { color: 'blue' },
         error: { color: 'red' },
     },
     accent: 'blue',
     warn: 'magenta',
+    thinking: { color: 'magenta' },
     // No cyan or yellow: on paper they are barely darker than the paper.
-    lanes: ['magenta', 'blue', 'green', 'red'],
+    lanes: ['blue', 'green', 'red', 'magenta'],
 };
 export const THEMES = { dark: DARK, light: LIGHT };
 export function parseChoice(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zenera/cli",
-    "version": "1.1.11",
+    "version": "1.1.12",
     "description": "Command-line front end for @zenera/neo: agentic projects you can run, share and commit.",
     "keywords": [
         "agents",
@@ -51,7 +51,7 @@
         "@inkjs/ui": "^2.0.0",
         "ink": "^7.1.1",
         "react": "^19.2.8",
-        "@zenera/neo": "^1.1.11",
+        "@zenera/neo": "^1.1.12",
         "@anthropic-ai/sdk": "^0.120.0",
         "@google/genai": "^2.18.0",
         "@openrouter/sdk": "^1.2.80",