@zenera/cli 1.1.21 → 1.1.22

package/README.md

@@ -310,13 +310,13 @@ agents:
     - name: reader
       description: Reads the workspace and summarises what is in it.
       system: agents/prompts/reader.md
-      tools: [workspace:read_file, workspace:list_dir, workspace:find_files]
+      tools: [files:read_file, files:list_dir, files:find_files]
       handoffs: [writer]
 
     - name: writer
       description: Turns a summary into a file on disk.
       system: agents/prompts/writer.md
-      tools: [workspace:*]
+      tools: [files:*]
       handoffs: [reader] # a hand-off does not return by itself; give it a way back
 ```
 
@@ -351,7 +351,7 @@ lines. Then say where you put it and stop.
 | `description` | what it is for - read by the _other_ agents when deciding to hand off |
 | `system`      | its own brief, in prose, at `agents/prompts/<name>.md`                |
 | `model`       | this agent's model; the top-level one otherwise                       |
-| `tools`       | what it may reach for - `workspace:*`, `sandbox:*`, a named tool      |
+| `tools`       | what it may reach for - `files:*` (or `workspace:*`), `sandbox:*`     |
 | `handoffs`    | who it may pass the work to                                           |
 | `skills`      | knowledge pulled in mid-run instead of carried in every prompt        |
 

package/dist/banner.d.ts

@@ -1,29 +1,38 @@
+/**
+ * A stroke and the bevel that shades it, one step darker in the same hue.
+ *
+ * The head word is the terminal's own ink, so it has one per background: near
+ * white raised off grey, or near black embossed into it. The accent does not
+ * — it is the brand, it is the same orange on both, and it is the only word
+ * here that is allowed not to care what it is printed on.
+ */
+interface Tone {
+    face: string;
+    shade: string;
+}
 /** One per sub-brand, so two of them are told apart before the word is read. */
 declare const ACCENTS: {
-    readonly orange: {
-        readonly face: "\u001B[1;38;5;208m";
-        readonly shade: "\u001B[0;38;5;130m";
-    };
-    readonly green: {
-        readonly face: "\u001B[1;38;5;41m";
-        readonly shade: "\u001B[0;38;5;29m";
-    };
-    readonly cyan: {
-        readonly face: "\u001B[1;38;5;51m";
-        readonly shade: "\u001B[0;38;5;37m";
-    };
-    readonly mint: {
-        readonly face: "\u001B[1;38;5;121m";
-        readonly shade: "\u001B[0;38;5;78m";
-    };
-    readonly gold: {
-        readonly face: "\u001B[1;38;5;220m";
-        readonly shade: "\u001B[0;38;5;178m";
-    };
-    readonly dusk: {
-        readonly face: "\u001B[1;38;5;141m";
-        readonly shade: "\u001B[0;38;5;97m";
-    };
+    readonly orange: Tone;
+    readonly amber: Tone;
+    readonly gold: Tone;
+    readonly lime: Tone;
+    readonly green: Tone;
+    readonly emerald: Tone;
+    readonly mint: Tone;
+    readonly teal: Tone;
+    readonly cyan: Tone;
+    readonly sky: Tone;
+    readonly azure: Tone;
+    readonly steel: Tone;
+    readonly indigo: Tone;
+    readonly violet: Tone;
+    readonly purple: Tone;
+    readonly magenta: Tone;
+    readonly pink: Tone;
+    readonly rose: Tone;
+    readonly crimson: Tone;
+    readonly red: Tone;
+    readonly dusk: Tone;
 };
 export type Hue = keyof typeof ACCENTS;
 export interface BannerText {

package/dist/banner.js

@@ -69,14 +69,33 @@ const HEADS = {
     dark: { face: '\u001b[1;38;5;231m', shade: '\u001b[0;38;5;244m' },
     light: { face: '\u001b[1;38;5;235m', shade: '\u001b[0;38;5;245m' },
 };
+const tone = (face, shade) => ({
+    face: `\u001b[1;38;5;${face}m`,
+    shade: `\u001b[0;38;5;${shade}m`,
+});
 /** One per sub-brand, so two of them are told apart before the word is read. */
 const ACCENTS = {
-    orange: { face: '\u001b[1;38;5;208m', shade: '\u001b[0;38;5;130m' },
-    green: { face: '\u001b[1;38;5;41m', shade: '\u001b[0;38;5;29m' },
-    cyan: { face: '\u001b[1;38;5;51m', shade: '\u001b[0;38;5;37m' },
-    mint: { face: '\u001b[1;38;5;121m', shade: '\u001b[0;38;5;78m' },
-    gold: { face: '\u001b[1;38;5;220m', shade: '\u001b[0;38;5;178m' },
-    dusk: { face: '\u001b[1;38;5;141m', shade: '\u001b[0;38;5;97m' },
+    orange: tone(208, 130),
+    amber: tone(214, 172),
+    gold: tone(220, 178),
+    lime: tone(154, 106),
+    green: tone(41, 29),
+    emerald: tone(48, 29),
+    mint: tone(121, 78),
+    teal: tone(44, 30),
+    cyan: tone(51, 37),
+    sky: tone(39, 26),
+    azure: tone(33, 25),
+    steel: tone(110, 67),
+    indigo: tone(105, 61),
+    violet: tone(141, 97),
+    purple: tone(171, 90),
+    magenta: tone(201, 127),
+    pink: tone(212, 169),
+    rose: tone(204, 125),
+    crimson: tone(197, 124),
+    red: tone(196, 88),
+    dusk: tone(141, 97),
 };
 /** Runs of stroke and runs of bevel, alternating; spaces stay unstyled. */
 const RUNS = /[█▀▄]+|[^█▀▄ ]+/g;

package/dist/commands/check.js

@@ -34,6 +34,7 @@ const USAGE = 'zen check [name|dir] [--project <name|dir>] [--fix] [--no-sandbox
 export const check = {
     summary: 'Validate agents.yaml and every file it names, and ask its models.',
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Check', subtitle: 'Project Health', hue: 'lime' },
     details: [
         'Checks the whole project: the configuration parses and satisfies the',
         'schema, every prompt, skill and catalog it names is on disk, hand-offs',

package/dist/commands/init.js

@@ -126,6 +126,7 @@ function hasExa(store) {
 export const init = {
     summary: 'Create a project here, or in <dir>, and register it.',
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Init', subtitle: 'Project Scaffolding', hue: 'rose' },
     details: [
         'Writes SPECIFICATION.md, agents.yaml, agents/ (house rules, the memory',
         'rules and one role prompt) and scripts/, then records the directory so',

package/dist/commands/inspect.js

@@ -13,6 +13,7 @@ const USAGE = 'zen inspect [run] [--session <id>] [--open] [--rebuild] [--serve
 export const inspect = {
     summary: "Open or rebuild a run's report.html.",
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Inspect', subtitle: 'Run Trajectory', hue: 'indigo' },
     details: [
         'With no arguments: asks which session and run, or takes the newest of',
         'each when there is nothing to ask on.',

package/dist/commands/key.js

@@ -508,6 +508,7 @@ const SUBS = {
 export const key = {
     summary: 'The credential store: add, choose, verify and export API keys.',
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Keys', subtitle: 'Credential Keyring', hue: 'amber' },
     details: [
         'Keys live in ~/.zenera/neo/keys.json (0600) and are materialised into',
         'the environment before a run. A real environment variable always wins,',

package/dist/commands/list.js

@@ -9,6 +9,7 @@ const USAGE = 'zen list [--sessions] [--prune]';
 export const list = {
     summary: 'Every known project: sessions, last run, whether one is live.',
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Projects', subtitle: 'Project Registry', hue: 'sky' },
     details: [
         'The registry is an index, not the truth. An entry whose directory has',
         'gone away is shown dimmed rather than hidden; --prune forgets them.',

package/dist/commands/memory.js

@@ -31,6 +31,7 @@ const LISTED = 30;
 export const memory = {
     summary: 'What the agents remember, and getting rid of it.',
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Memory', subtitle: 'Knowledge Graph', hue: 'purple' },
     details: [
         '  stats                  Size, vocabulary, and whether it is embedded.',
         '  ls                     Nodes, newest first. Changes nothing.',

package/dist/commands/open.js

@@ -16,6 +16,7 @@ const USAGE = 'zen open [project] [--editor <cmd>] [--wait]';
 export const open = {
     summary: 'Open a project in your editor.',
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Open', subtitle: 'Workspace Studio', hue: 'teal' },
     details: [
         'Editor: --editor, then $ZENERA_EDITOR, then the editor this terminal',
         'belongs to, then $VISUAL or $EDITOR, then a known editor on PATH or',

package/dist/commands/run.js

@@ -12,6 +12,7 @@ const USAGE = 'zen run [project] [prompt] [options]';
 export const run = {
     summary: 'Run the project — the TUI on a terminal, one shot otherwise.',
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Neo', subtitle: 'Agentic Runtime', hue: 'orange' },
     details: [
         'Arguments:',
         '  [project]   Name of a project. Default: the one you are in.',
@@ -31,6 +32,7 @@ export const run = {
         '  --theme <dark|light>   Colours for the TUI. Default: auto.',
         '  --out <file>           Put the answer in this file instead of on screen.',
         '  --yes                  Answer yes to every question.',
+        '  --json                 Print machine-readable JSON (session, run, mounts, output, etc...).',
         '',
         'The first word is the project when it names one, otherwise the prompt.',
         'The answer goes to stdout and the progress to stderr, so `> out.md` keeps',
@@ -46,6 +48,7 @@ export const run = {
         '  git diff | zen run                    take the prompt from stdin',
         '  zen run "what changed?" > out.md      redirect the answer into a file',
         '  zen run --out out.md "what changed?"  write the answer to out.md only',
+        '  zen run --json "what changed?"        output JSON with workspace, run paths, state, etc...',
         '  zen run --read-only "what changed?"   let it read but not write',
         '  zen run --memory ./mem                remember into ./mem, not the project',
         '  zen run --new                         open the TUI in a new session',

package/dist/commands/sandbox.js

@@ -21,6 +21,7 @@ const INDENT = ' '.repeat(11);
 export const sandbox = {
     summary: 'Check and prepare the container command-line tools run in.',
     usage: USAGE,
+    banner: { head: 'Zenera', accent: 'Sandbox', subtitle: 'Container Isolation', hue: 'azure' },
     details: [
         '  status                 What is installed, running and pulled. Changes nothing.',
         '  up                     Install if asked, start the machine, pull or build the image.',

package/dist/commands/version.js

@@ -20,6 +20,7 @@ function libraryManifest() {
 export const version = {
     summary: 'Print the CLI, library and Node versions.',
     usage: 'zen version',
+    banner: { head: 'Zenera', accent: 'Version', subtitle: 'Runtime & Build', hue: 'steel' },
     run: async (ctx) => {
         const versions = {
             cli: await versionOf(cliManifest),

package/dist/lib.d.ts

@@ -7,5 +7,6 @@ export { assertPrivate, ensureDir, ensureHome, home, paths, readJson, writeJson
 export { assertNotEmpty, assertOwner, assertUsable, describe, envNames, envOf, form, isOwner, isProvider, keyId, KeyStore, mask, OWNERS, parseRef, PROVIDERS, SERVICES, SHAPES, type CredentialForm, type KeyCheck, type KeyEntry, type KeyOwner, type Liveness, type Provider, type Service, } from './keys.ts';
 export { probe, probeAll } from './liveness.ts';
 export { engineDisk, ensurePodmanReady, ownedContainers, podmanStatus, removeContainers, type DiskLine, type EngineDisk, type OwnedContainer, type PodmanOptions, type PodmanStatus, } from './podman.ts';
-export { ago, bold, CliError, count, credentialError, cyan, dim, EXIT, fail, green, invalidError, isInteractive, json, note, pad, red, table, usageError, warn, write, writeAll, yellow, type ExitCode, } from './term.ts';
+export { ago, bold, CliError, count, credentialError, cyan, dim, EXIT, fail, green, invalidError, isInteractive, italic, json, note, pad, red, table, underline, usageError, warn, write, writeAll, yellow, type ExitCode, } from './term.ts';
+export { formatBlocks, formatInline, formatMarkdown, wrapSpans } from './tui/markdown.ts';
 //# sourceMappingURL=lib.d.ts.map

package/dist/lib.js

@@ -29,5 +29,6 @@ export { assertPrivate, ensureDir, ensureHome, home, paths, readJson, writeJson
 export { assertNotEmpty, assertOwner, assertUsable, describe, envNames, envOf, form, isOwner, isProvider, keyId, KeyStore, mask, OWNERS, parseRef, PROVIDERS, SERVICES, SHAPES, } from "./keys.js";
 export { probe, probeAll } from "./liveness.js";
 export { engineDisk, ensurePodmanReady, ownedContainers, podmanStatus, removeContainers, } from "./podman.js";
-export { ago, bold, CliError, count, credentialError, cyan, dim, EXIT, fail, green, invalidError, isInteractive, json, note, pad, red, table, usageError, warn, write, writeAll, yellow, } from "./term.js";
+export { ago, bold, CliError, count, credentialError, cyan, dim, EXIT, fail, green, invalidError, isInteractive, italic, json, note, pad, red, table, underline, usageError, warn, write, writeAll, yellow, } from "./term.js";
+export { formatBlocks, formatInline, formatMarkdown, wrapSpans } from "./tui/markdown.js";
 //# sourceMappingURL=lib.js.map

package/dist/meta.d.ts

@@ -179,7 +179,7 @@ export declare function footerCells(label: string, width: number): string[];
 export declare function windowSink(rows?: number): Sink;
 /**
  * The answer in the same box `zen run` draws it in: bounded width, rounded
- * rule, fenced blocks kept as they were written.
+ * 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.

package/dist/meta.js

@@ -6,7 +6,8 @@ import { invokedAs } from "./args.js";
 import { paths, readJson, writeJson } from "./home.js";
 import { envOf } from "./keys.js";
 import { credentialError, cut, cyan, dim, note, pad, plain, red, styled, usageError, write, yellow, } from "./term.js";
-import { blocksOf, boxWidth, textOf, wrap } from "./tui/wrap.js";
+import { formatInline, formatMarkdown } from "./tui/markdown.js";
+import { boxWidth } from "./tui/wrap.js";
 export const PROMPT_DIR = '.github/prompts';
 const PROMPT_SUFFIX = '.prompt.md';
 // ---------------------------------------------------------------------------
@@ -483,7 +484,7 @@ export function windowSink(rows = WINDOW_ROWS) {
 }
 /**
  * The answer in the same box `zen run` draws it in: bounded width, rounded
- * rule, fenced blocks kept as they were written.
+ * 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.
@@ -494,31 +495,7 @@ export function answerBox(text, columns = process.stdout.columns ?? 80) {
     }
     const outer = boxWidth(text, columns);
     const inner = outer - 4;
-    const body = [];
-    let previous;
-    for (const block of blocksOf(text)) {
-        if (previous && !(block.kind === 'item' && previous.kind === 'item')) {
-            body.push('');
-        }
-        previous = block;
-        if (block.kind === 'code') {
-            // Indentation is the meaning of a fenced block, so it is cut rather
-            // than reflowed.
-            body.push(dim(`\u250c\u2500${block.title ? ` ${block.title}` : ''}`));
-            body.push(...(block.lines ?? []).map((l) => `${dim('\u2502')} ${cut(l, inner - 2)}`));
-            body.push(dim('\u2514\u2500'));
-        }
-        else if (block.lines || block.kind === 'table') {
-            body.push(...textOf(block)
-                .split('\n')
-                .map((l) => cut(l, inner)));
-        }
-        else {
-            // Plain, not styled: `wrap` counts characters, and a bold run
-            // measured with its escape codes in it folds the line early.
-            body.push(...wrap(textOf(block, inner), inner));
-        }
-    }
+    const body = formatMarkdown(text, inner);
     const rule = BOX.h.repeat(outer - 2);
     return [
         '',
@@ -586,7 +563,7 @@ export function absorb(event, out, sink, width) {
                 out.answer = content;
             }
             else if (content) {
-                sink.narrate(cut(content.replace(/\s+/g, ' '), width));
+                sink.narrate(cut(formatInline(content.replace(/\s+/g, ' ')), width));
             }
             break;
         }

package/dist/resolve.js

@@ -1,9 +1,10 @@
 import { existsSync } from 'node:fs';
-import { relative, resolve, sep } from 'node:path';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { stamp } from "./ids.js";
 import * as Projects from "./projects.js";
 import { createSession, listSessions, readSessionMeta, requireSession, sessionPaths, } from "./session.js";
-import { ago, bold, choose, confirm, cyan, dim, isInteractive, usageError, warn, yellow, } from "./term.js";
+import * as term from "./term.js";
+import { ago, bold, cyan, dim, usageError, yellow } from "./term.js";
 // ---------------------------------------------------------------------------
 // Project
 // ---------------------------------------------------------------------------
@@ -20,7 +21,7 @@ export async function project(want) {
     if (known.length === 0) {
         throw usageError('not inside a project, and none are registered', 'create one: zen init');
     }
-    if (!isInteractive()) {
+    if (!term.isInteractive()) {
         throw usageError('not inside a project', 'name one with --project');
     }
     // Most recently worked in first: the answer to "which project" is nearly
@@ -29,7 +30,7 @@ export async function project(want) {
     const ranked = known
         .map((entry) => ({ entry, used: Projects.lastUsedAt(entry.path) ?? '' }))
         .sort((a, b) => b.used.localeCompare(a.used) || a.entry.name.localeCompare(b.entry.name));
-    const chosen = await choose('Which project?', ranked.map(({ entry }) => ({ label: entry.name, detail: entry.path, value: entry })));
+    const chosen = await term.choose('Which project?', ranked.map(({ entry }) => ({ label: entry.name, detail: entry.path, value: entry })));
     return Projects.openDir(chosen.path);
 }
 // ---------------------------------------------------------------------------
@@ -89,11 +90,11 @@ async function pickExisting(projectDir) {
     if (all.length === 0) {
         return undefined;
     }
-    if (!isInteractive()) {
+    if (!term.isInteractive()) {
         return sessionPaths(projectDir, all[0].id);
     }
     const sessions = all.slice(0, MAX_SESSIONS);
-    const choice = await choose('Session', [
+    const choice = await term.choose('Session', [
         {
             key: '0',
             label: bold(cyan('New session…')),
@@ -137,10 +138,10 @@ export async function chooseWorkspace(session, want) {
         await approve(at, session, want);
         return at;
     }
-    if (!isInteractive()) {
+    if (!term.isInteractive()) {
         return own;
     }
-    const chosen = await choose('Workspace — what the agent can read and write', [
+    const chosen = await term.choose('Workspace — what the agent can read and write', [
         { label: 'A fresh, empty directory', detail: own, value: own },
         { label: 'The directory you started in', detail: want.cwd, value: want.cwd },
     ]);
@@ -151,20 +152,26 @@ async function approve(at, session, want) {
     if (contains(session.dir, at)) {
         return;
     }
-    warn(`the agent will be able to read and write ${at}`);
+    if (!want.workspace) {
+        term.warn(`the agent will be able to read and write ${at}`);
+    }
     if (want.yes) {
         return;
     }
-    if (!isInteractive()) {
+    if (!term.isInteractive()) {
         throw usageError('refusing a workspace outside the session without confirmation', 'pass --yes if that is what you meant');
     }
-    if (!(await confirm('Continue?'))) {
+    if (!(await term.confirm('Continue?'))) {
         throw usageError('cancelled');
     }
 }
 function contains(parent, child) {
     const from = resolve(parent);
     const to = resolve(child);
-    return from === to || !relative(from, to).startsWith(`..${sep}`);
+    if (from === to) {
+        return true;
+    }
+    const rel = relative(from, to);
+    return !rel.startsWith(`..${sep}`) && rel !== '..' && !isAbsolute(rel);
 }
 //# sourceMappingURL=resolve.js.map

package/dist/sandbox.js

@@ -161,6 +161,7 @@ function toSpec(config, extra, secrets) {
         network: config.network,
         workdir: config.workdir,
         timeout: config.timeout,
+        hardening: config.hardening,
         user: config.user,
         persist: config.persist,
         env,

package/dist/scaffold.js

@@ -33,6 +33,8 @@ import { fileURLToPath } from 'node:url';
 const TEMPLATES = fileURLToPath(new URL('../templates', import.meta.url));
 /** The suffix on a file with `{{...}}` in it, dropped when the file lands. */
 const TEMPLATE = '.tmpl';
+/** How to use file tools: a house rules file, landing under `agents/`. */
+const FILE_RULES = join('agents', 'files-instructions.md');
 /** How to use the memory graph: a house rules file, landing under `agents/`. */
 const MEMORY_RULES = join('agents', 'memory-instructions.md');
 /** How tools are called: the same, and equally not the project's to maintain. */
@@ -51,7 +53,7 @@ const FORK_RULES = join('agents', 'fork-instructions.md');
  * place: project policy on any of those subjects goes in a topic file of its
  * own beside them.
  */
-export const SHARED_RULES = [FORK_RULES, MEMORY_RULES, TOOL_RULES];
+export const SHARED_RULES = [FILE_RULES, FORK_RULES, MEMORY_RULES, TOOL_RULES];
 /** The same bytes, kept in the `zen-memory` skill to restore or diff against. */
 const MEMORY_REFERENCE = join('.github', 'skills', 'zen-memory', 'references', 'memory-instructions.md');
 /**

package/dist/term.d.ts

@@ -26,6 +26,8 @@ export declare const CHROME: Record<Appearance, number>;
 /** What the terminal looks like, as far as can be known without asking it. */
 export declare function appearance(): Appearance;
 export declare const bold: (s: string) => string;
+export declare const italic: (s: string) => string;
+export declare const underline: (s: string) => string;
 /**
  * One step quieter, which is half of everything this tool prints: paths,
  * counts, hints, the second column of every table.

package/dist/term.js

@@ -88,6 +88,8 @@ function fromAppleTerminal() {
 // Styling
 // ---------------------------------------------------------------------------
 export const bold = (s) => styleText('bold', s);
+export const italic = (s) => styleText('italic', s);
+export const underline = (s) => styleText('underline', s);
 /**
  * One step quieter, which is half of everything this tool prints: paths,
  * counts, hints, the second column of every table.

package/dist/tui/markdown.d.ts

@@ -0,0 +1,16 @@
+import { type Block, type Span } from './wrap.ts';
+export declare function wrapSpans(spans: readonly Span[], width: number, prefix?: string, subsequentPrefix?: string): string[];
+/**
+ * Render a sequence of AST `Block`s into styled terminal lines wrapped to `width`.
+ */
+export declare function formatBlocks(blocks: readonly Block[], width?: number): string[];
+/**
+ * Format markdown text into styled ANSI terminal lines wrapped to `width`.
+ */
+export declare function formatMarkdown(text: string, width?: number): string[];
+/**
+ * Format inline markdown text (bold, italic, code, links) into a styled ANSI string.
+ * Markers like backticks and asterisks are resolved and removed.
+ */
+export declare function formatInline(text: string): string;
+//# sourceMappingURL=markdown.d.ts.map