@zenera/cli 1.1.10 → 1.1.12

package/dist/commands/index.js

@@ -1,8 +1,10 @@
+import { cache } from "./cache.js";
 import { check } from "./check.js";
 import { init } from "./init.js";
 import { inspect } from "./inspect.js";
 import { key } from "./key.js";
 import { list } from "./list.js";
+import { memory } from "./memory.js";
 import { models } from "./models.js";
 import { open } from "./open.js";
 import { run } from "./run.js";
@@ -22,7 +24,9 @@ export const COMMANDS = {
     models,
     check,
     inspect,
+    memory,
     sandbox,
+    cache,
     version,
 };
 /** Names that are not listed in help but still work. */
@@ -34,6 +38,7 @@ export const ALIASES = {
     validate: 'check',
     doctor: 'check',
     report: 'inspect',
+    mem: 'memory',
     edit: 'open',
     code: 'open',
     mock: 'faker',

package/dist/commands/init.js

@@ -96,10 +96,14 @@ export const init = {
     summary: 'Create a project here, or in <dir>, and register it.',
     usage: USAGE,
     details: [
-        'Writes INSTRUCTIONS.md, agents.yaml and agents/, then records the',
-        'directory so `zen list` and `zen open` can find it by name. Editor files',
-        '(.vscode/settings.json and the .github/ tree) are written',
-        'alongside, replacing any already there.',
+        'Writes SPECIFICATION.md, INSTRUCTIONS.md, agents.yaml, agents/ and',
+        'scripts/, then records the directory so `zen list` and `zen open` can',
+        'find it by name. Editor files (.vscode/settings.json and the .github/',
+        'tree) are written alongside, replacing any already there.',
+        '',
+        'SPECIFICATION.md states what the project is for and what it may do,',
+        'and describes the one that was just written. Say what you are building',
+        'there, then run /sync-with-spec in your editor to make the rest match.',
         '',
         'The default agent gets the file tools and a sandboxed shell, plus',
         '`exa:*` when the keyring holds an Exa key. Without --model, the',

package/dist/commands/key.js

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { parse } from "../args.js";
 import { ensureHome } from "../home.js";
-import { ambient, ambientId, assertNotEmpty, describe, envNames, envOf, keyId, KeyStore, mask, OWNERS, parseRef, SHAPES, } from "../keys.js";
+import { ambient, ambientId, assertNotEmpty, checkRegion, describe, envNames, envOf, formOf, keyId, KeyStore, mask, OWNERS, parseRef, SHAPES, } from "../keys.js";
 import { probe, probeAll } from "../liveness.js";
 import { ago, ask, askSecret, bold, confirm, credentialError, cyan, dim, green, isInteractive, json, note, progress, readStdin, red, table, usageError, write, writeAll, yellow, } from "../term.js";
 const USAGE = 'zen key <ls|add|use|check|rm|show|env> [ref] [options]';
@@ -17,6 +17,32 @@ const MARK = {
 function state(entry) {
     return entry.check ? MARK[entry.check.state] : dim('unchecked');
 }
+/** Where a Vertex project id came from, since only one of the three was typed. */
+const ORIGIN = {
+    env: 'from $GOOGLE_CLOUD_PROJECT',
+    stored: 'from --gcp-project',
+    file: 'from the key file',
+};
+/**
+ * Only a Vertex service account addresses a project and a region. An unset
+ * region is shown as the `global` it will actually be, not left blank: it is
+ * the slow endpoint, and a blank column is how it goes unnoticed. The project
+ * is shown whether or not one was stored, because the file names one too and a
+ * blank there reads as "none" rather than "not written down here". Yellow when
+ * the environment supplied either, because then the stored one is not in play.
+ */
+function placed(store, entry) {
+    if (entry.provider !== 'vertex' || entry.holds !== 'file') {
+        return '';
+    }
+    const fromEnv = process.env.GOOGLE_CLOUD_LOCATION;
+    const where = fromEnv ?? entry.location ?? 'global';
+    const project = store.projectOf(entry);
+    const id = project ? project.id : '';
+    return [fromEnv ? yellow(where) : dim(where), project?.from === 'env' ? yellow(id) : dim(id)]
+        .join(' ')
+        .trimEnd();
+}
 /**
  * An ambient credential borrowed into the shape the rest of this file works
  * in. It is not in the store and never will be: `store.find` misses it, so
@@ -35,7 +61,7 @@ function asEntry(cred) {
 }
 function rows(store, borrowed) {
     const out = [
-        [bold(''), bold('KEY'), bold('VALUE'), bold('STATE'), bold('CHECKED')],
+        [bold(''), bold('KEY'), bold('VALUE'), bold('GCP'), bold('STATE'), bold('CHECKED')],
     ];
     for (const provider of OWNERS) {
         for (const entry of store.for(provider)) {
@@ -44,6 +70,7 @@ function rows(store, borrowed) {
                 store.isActive(entry) ? green('*') : ' ',
                 keyId(entry),
                 dim(describe(store, entry)),
+                placed(store, entry),
                 state(entry),
                 dim(entry.check ? ago(entry.check.at) : '—') +
                     (shadow && store.isActive(entry) ? yellow(`  shadowed by $${shadow}`) : ''),
@@ -54,6 +81,7 @@ function rows(store, borrowed) {
                 dim('~'),
                 dim(ambientId(cred)),
                 dim(describe(store, entry)),
+                placed(store, entry),
                 state(entry),
                 dim(cred.env ? 'from the environment' : 'from gcloud'),
             ]);
@@ -133,9 +161,11 @@ const add = async (ctx, args) => {
     const { values, positionals } = parse(args, {
         name: { type: 'string' },
         'no-check': { type: 'boolean' },
-        project: { type: 'string' },
-        location: { type: 'string' },
-    }, 'zen key add <provider>[/name] [--name <name>] [--project <id>] [--location <region>] [--no-check]');
+        // Prefixed because every other command's --project is a Zenera one.
+        'gcp-project': { type: 'string' },
+        'gcp-location': { type: 'string' },
+    }, 'zen key add <provider>[/name] [--name <name>] [--gcp-project <id>] ' +
+        '[--gcp-location <region>] [--no-check]');
     const ref = positionals[0];
     if (!ref) {
         throw usageError('which provider?', `one of: ${OWNERS.join(', ')}`);
@@ -144,8 +174,14 @@ const add = async (ctx, args) => {
     const provider = parsed.provider;
     const name = values.name ?? parsed.name ?? 'default';
     const shape = SHAPES[provider];
-    if ((values.project || values.location) && provider !== 'vertex') {
-        throw usageError(`--project and --location mean nothing to ${shape.label}`, 'they configure a Vertex service account');
+    if ((values['gcp-project'] || values['gcp-location']) && provider !== 'vertex') {
+        throw usageError(`--gcp-project and --gcp-location mean nothing to ${shape.label}`, 'they configure a Vertex service account');
+    }
+    // Checked before the prompt, so a typo does not cost you pasting the key.
+    const region = values['gcp-location'];
+    if (region !== undefined && !checkRegion(region)) {
+        note(yellow(`${region} is not a region this build knows; storing it anyway`));
+        note(dim('  if it is new, this is fine; if it is a typo, Vertex answers 404'));
     }
     ensureHome();
     const store = await KeyStore.open();
@@ -164,9 +200,14 @@ const add = async (ctx, args) => {
     if (shape.forms.length === 1 && shape.forms[0].holds === 'file' && !existsSync(raw)) {
         throw usageError(`no such file: ${raw}`);
     }
+    // Which shape was given is only knowable now, and `add` would drop these
+    // two on an express key rather than store a combination Vertex refuses.
+    if (formOf(provider, raw).holds !== 'file' && (values['gcp-project'] || region)) {
+        throw usageError('--gcp-project and --gcp-location need a service-account file', 'the value given is an express-mode key, which addresses no project or region');
+    }
     const entry = store.add(provider, name, raw, {
-        project: values.project,
-        location: values.location,
+        project: values['gcp-project'],
+        location: values['gcp-location'],
     });
     // Verified before it is trusted, but stored either way: a key that cannot
     // be checked right now — offline, behind a proxy — is not a key that is
@@ -186,6 +227,12 @@ const add = async (ctx, args) => {
                 note(dim(`  ${check.fix}`));
             }
         }
+        else if (check.state === 'unknown' && check.fix) {
+            // Most unknowns are a plane or a proxy and say nothing worth a
+            // line. One carrying a fix is different: we know what is wrong.
+            note(`${yellow('unverified')} ${check.detail}`);
+            note(dim(`  ${check.fix}`));
+        }
     }
     store.save();
     if (ctx.json) {
@@ -203,7 +250,10 @@ const add = async (ctx, args) => {
         note(yellow(`$${envOf(entry)} is set and will win over this`));
     }
     if (provider === 'vertex' && entry.holds === 'file' && !entry.project) {
-        note(dim('no --project given; the project_id inside the file will be used'));
+        const found = store.projectOf(entry);
+        note(dim(found
+            ? `no --gcp-project given; project ${found.id}, read from the key file`
+            : 'no --gcp-project given, and the key file names no project_id'));
     }
 };
 /**
@@ -329,12 +379,14 @@ const show = async (ctx, args) => {
         throw usageError(`no key ${ref}`, 'see: zen key ls');
     }
     const value = values.reveal ? store.reveal(entry) : describe(store, entry);
+    const project = store.projectOf(entry);
     if (ctx.json) {
         json({
             key: keyId(entry),
             env: envOf(entry),
             value,
             revealed: Boolean(values.reveal),
+            ...(project ? { project: project.id, projectFrom: project.from } : {}),
         });
         return;
     }
@@ -348,8 +400,10 @@ const show = async (ctx, args) => {
         [dim('key'), keyId(entry)],
         [dim('env'), envOf(entry)],
         [dim('value'), value],
-        ...(entry.project ? [[dim('project'), entry.project]] : []),
-        ...(entry.location ? [[dim('location'), entry.location]] : []),
+        ...(project
+            ? [[dim('gcp project'), `${project.id} ${dim(ORIGIN[project.from])}`]]
+            : []),
+        ...(entry.location ? [[dim('gcp location'), entry.location]] : []),
         [dim('state'), state(entry)],
         ...(entry.check?.fix ? [[dim('fix'), entry.check.fix]] : []),
         [dim('added'), ago(entry.addedAt)],
@@ -416,8 +470,8 @@ export const key = {
         'Services the tools call: exa.',
         '',
         'Vertex takes either shape: a service-account JSON file, which wants',
-        '--project and --location too, or an express-mode API key, which wants',
-        'neither. Which one you gave is read off the value.',
+        '--gcp-project and --gcp-location too, or an express-mode API key, which',
+        'wants neither. Which one you gave is read off the value.',
         '',
         '  zen key ls [--check]              Everything stored, and its state.',
         '  zen key add <provider>[/name]     Read a key from stdin, or ask for it.',

package/dist/commands/memory.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from '../command.ts';
+export declare const memory: Command;
+//# sourceMappingURL=memory.d.ts.map

package/dist/commands/memory.js

@@ -0,0 +1,375 @@
+import { ALL_AGENTS, buildMemoryReport, hostPath, memoryDir, MemoryIndex, MemoryStore, readProjectConfig, renderMemoryHtml, } from '@zenera/neo';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { isAbsolute, join, resolve } from 'node:path';
+import { parse } from "../args.js";
+import { project as resolveProject } from "../resolve.js";
+import { ago, bold, bytes, confirm, count, cyan, dim, green, isInteractive, json, note, table, usageError, write, writeAll, yellow, } from "../term.js";
+const USAGE = 'zen memory [stats|ls|show|export|forget] [args] [options]';
+const SUBCOMMANDS = ['stats', 'ls', 'show', 'export', 'forget'];
+/** Enough to see the shape of it; the rest is a number. */
+const LISTED = 30;
+// ---------------------------------------------------------------------------
+// zen memory
+//
+// The graph from outside the agents, and the reason it needs a command is that
+// there is otherwise no way to answer the question memory always eventually
+// raises: *why did it recall that?* Recall is masked, ranked and truncated by
+// design, so what an agent sees is never the whole picture — and when the
+// picture is what is wrong, you need the part that was hidden.
+//
+// So everything here reads the graph unmasked. That is safe because it is
+// local: this command is a person at a terminal in the project directory, not
+// an agent inside a run, and the mask exists to keep agents apart rather than
+// to keep secrets from the person who owns the files.
+//
+// Nothing here contacts a model. The store is opened without an embedder, so
+// inspection is free and works offline; the price is that `ls` filters by text
+// rather than by meaning, which is the right trade for a debugging tool.
+// ---------------------------------------------------------------------------
+export const memory = {
+    summary: 'What the agents remember, and getting rid of it.',
+    usage: USAGE,
+    details: [
+        '  stats                  Size, vocabulary, and whether it is embedded.',
+        '  ls                     Nodes, newest first. Changes nothing.',
+        '  show <id>              One node in full, with what it links to.',
+        '  export [file]          The whole graph as one HTML page.',
+        '  forget <id...>         Remove nodes, their vectors and their files.',
+        '',
+        '  --project <name|dir>   Which project. Defaults to the one you are in.',
+        '  --kind <name>          Only this kind of node.',
+        '  --audience <name>      Only nodes committed under this label.',
+        '  --files                Only nodes that remember a file.',
+        '  --stale                Only nodes something has superseded.',
+        '  --limit <n>            Rows to list. Default 30.',
+        '  --out <file>           Where `export` writes. Default memory.html.',
+        '  --open                 Open the exported page.',
+        '  --yes                  Do not ask before removing.',
+        '',
+        'Everything here reads the graph *unmasked* — every audience, including',
+        'what no agent can see. That is the point: when a mask is the thing',
+        'that is wrong, the hidden part is what you need to look at.',
+        '',
+        '`export` is the one to reach for. It writes a single self-contained',
+        'page: the node list on the left, the graph in the middle, and whatever',
+        'you click on the right, file contents and all.',
+    ],
+    run: async (ctx) => {
+        const { values, positionals } = parse(ctx.args, {
+            project: { type: 'string' },
+            kind: { type: 'string' },
+            audience: { type: 'string' },
+            files: { type: 'boolean' },
+            stale: { type: 'boolean' },
+            limit: { type: 'string' },
+            out: { type: 'string' },
+            open: { type: 'boolean' },
+            yes: { type: 'boolean' },
+        }, USAGE);
+        const what = positionals[0] ?? 'stats';
+        if (!SUBCOMMANDS.includes(what)) {
+            throw usageError(`unknown subcommand: ${what}`, USAGE);
+        }
+        const rest = positionals.slice(1);
+        const opened = await open(ctx.cwd, values.project);
+        try {
+            switch (what) {
+                case 'stats':
+                    return stats(opened, ctx.json);
+                case 'ls':
+                    return list(opened, values, ctx.json);
+                case 'show':
+                    return show(opened, rest, ctx.json);
+                case 'export':
+                    return await write_(opened, rest, values, ctx.cwd, ctx.json);
+                default:
+                    return await forget(opened, rest, values, ctx.json);
+            }
+        }
+        finally {
+            opened.store.release();
+        }
+    },
+};
+/**
+ * The store, opened directly rather than through `loadProject`. Loading the
+ * project would resolve models and read every prompt file to inspect a graph
+ * that needs none of it — and would fail on a project whose credentials are
+ * missing, which is exactly when someone is debugging.
+ */
+async function open(cwd, want) {
+    const project = await resolveProject({ cwd, project: want });
+    const { config } = readProjectConfig(project.dir);
+    const dir = memoryDir(project.dir, config);
+    if (!dir) {
+        throw usageError(`${project.name} has no memory`, 'give an agent `memory: true` in agents.yaml, or add a `memory:` block');
+    }
+    if (!existsSync(join(dir, 'manifest.json'))) {
+        throw usageError(`${project.name} has a memory configured but nothing in it yet`, 'it is written the first time an agent commits something');
+    }
+    return { store: await MemoryStore.open(dir), dir, project: project.name };
+}
+// ---------------------------------------------------------------------------
+// stats
+// ---------------------------------------------------------------------------
+function stats(o, asJson) {
+    const nodes = o.store.graph.nodes();
+    const edges = o.store.graph.edges();
+    const stale = o.store.graph.superseded();
+    const vectors = o.store.vectors;
+    const files = nodes.filter((n) => n.file);
+    const byKind = tally(nodes.map((n) => n.kind));
+    const byRelation = tally(edges.map((e) => e.relation));
+    const byAudience = tally(nodes.flatMap((n) => n.audience));
+    if (asJson) {
+        json({
+            dir: o.dir,
+            nodes: nodes.length,
+            edges: edges.length,
+            superseded: stale.size,
+            files: {
+                count: files.length,
+                bytes: files.reduce((t, n) => t + (n.file?.bytes ?? 0), 0),
+            },
+            embedding: o.store.embedding,
+            vectors: vectors ? { rows: vectors.rows, dims: vectors.dims } : undefined,
+            kinds: byKind,
+            relations: byRelation,
+            audiences: byAudience,
+        });
+        return;
+    }
+    if (!nodes.length) {
+        note(`nothing remembered yet ${dim(o.dir)}`);
+        return;
+    }
+    write(bold(o.project) + dim(' · ' + o.dir));
+    write();
+    writeAll(table([
+        [dim('nodes'), String(nodes.length)],
+        [dim('edges'), String(edges.length)],
+        [dim('superseded'), String(stale.size)],
+        [
+            dim('files'),
+            files.length
+                ? `${files.length} · ${bytes(files.reduce((t, n) => t + (n.file?.bytes ?? 0), 0))}`
+                : '0',
+        ],
+        [
+            dim('embedding'),
+            o.store.embedding
+                ? `${o.store.embedding.model} ${dim(o.store.embedding.dimensions + 'd')}`
+                : yellow('none — recall falls back to term overlap'),
+        ],
+        [dim('vectors'), vectors ? `${vectors.rows} rows` : dim('—')],
+    ]));
+    // A node without a vector cannot be found by meaning, only by luck. It is
+    // the one silent failure this store has, so it is called out by name.
+    if (vectors && vectors.rows < nodes.length) {
+        write();
+        note(yellow(`${count(nodes.length - vectors.rows, 'node')} with no vector`));
+    }
+    section('kinds', byKind);
+    section('relations', byRelation);
+    section('audiences', byAudience);
+}
+function section(title, counts) {
+    const rows = Object.entries(counts).sort((a, b) => b[1] - a[1]);
+    if (!rows.length) {
+        return;
+    }
+    write();
+    write(dim(title));
+    writeAll(table(rows.map(([k, n]) => [`  ${cyan(k)}`, String(n)])));
+}
+function tally(values) {
+    const out = {};
+    for (const v of values) {
+        out[v] = (out[v] ?? 0) + 1;
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// ls
+// ---------------------------------------------------------------------------
+function list(o, flags, asJson) {
+    const stale = o.store.graph.superseded();
+    const limit = Number(flags.limit ?? LISTED);
+    if (!Number.isInteger(limit) || limit < 1) {
+        throw usageError(`--limit wants a positive whole number, got ${flags.limit}`, USAGE);
+    }
+    const all = o.store.graph
+        .nodes()
+        .filter((n) => !flags.kind || n.kind === flags.kind)
+        .filter((n) => !flags.audience || n.audience.includes(flags.audience))
+        .filter((n) => !flags.files || n.file)
+        .filter((n) => !flags.stale || stale.has(n.id))
+        .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    if (asJson) {
+        json({ total: all.length, nodes: all.slice(0, limit) });
+        return;
+    }
+    if (!all.length) {
+        note('nothing matches');
+        return;
+    }
+    writeAll(table(all
+        .slice(0, limit)
+        .map((n) => [
+        cyan(n.id),
+        n.kind,
+        n.file ? dim('⎘ ' + n.file.format) : '',
+        clip(n.text, 56),
+        dim(ago(n.createdAt)),
+        stale.has(n.id) ? yellow('superseded') : '',
+    ])));
+    if (all.length > limit) {
+        write();
+        note(dim(`${all.length - limit} more — raise --limit, or use \`zen memory export\``));
+    }
+}
+// ---------------------------------------------------------------------------
+// show
+// ---------------------------------------------------------------------------
+function show(o, ids, asJson) {
+    const id = ids[0];
+    if (!id || ids.length > 1) {
+        throw usageError('show takes exactly one id', 'zen memory show <id>');
+    }
+    const node = o.store.graph.get(id);
+    if (!node) {
+        throw usageError(`no node ${id}`, 'list them with `zen memory ls`');
+    }
+    const links = o.store.graph.neighbors(id);
+    if (asJson) {
+        json({ node, links, file: node.file ? hostPath(o.dir, node.file) : undefined });
+        return;
+    }
+    write(bold(node.id) + ' ' + cyan(node.kind));
+    write();
+    writeAll(table([
+        [dim('revision'), String(node.revision)],
+        [dim('used'), `${node.useCount}× · last ${ago(node.lastUsedAt)}`],
+        [dim('created'), `${node.createdAt} ${dim(ago(node.createdAt))}`],
+        [dim('updated'), node.updatedAt],
+        [dim('audience'), node.audience.join(', ')],
+    ]));
+    write();
+    write(node.text);
+    if (node.metadata) {
+        write();
+        write(dim('metadata'));
+        write(JSON.stringify(node.metadata, null, 2));
+    }
+    if (node.file) {
+        write();
+        write(dim('file'));
+        writeAll(table([
+            [dim('  path'), hostPath(o.dir, node.file)],
+            [dim('  size'), bytes(node.file.bytes)],
+            [dim('  sha256'), node.file.sha256],
+        ]));
+    }
+    write();
+    write(dim(`links (${links.length})`));
+    if (!links.length) {
+        note(dim('  nothing points here and it points nowhere'));
+        return;
+    }
+    writeAll(table(links.map((e) => {
+        const out = e.source === id;
+        const other = out ? e.target : e.source;
+        return [
+            `  ${out ? '→' : '←'} ${yellow(e.relation)}`,
+            cyan(other),
+            clip(o.store.graph.get(other)?.text ?? '', 48),
+        ];
+    })));
+}
+// ---------------------------------------------------------------------------
+// export
+// ---------------------------------------------------------------------------
+async function write_(o, rest, flags, cwd, asJson) {
+    if (rest.length > 1) {
+        throw usageError('export takes at most one file name', 'zen memory export [file]');
+    }
+    const named = rest[0] ?? flags.out ?? 'memory.html';
+    const target = isAbsolute(named) ? named : resolve(cwd, named);
+    const report = await buildMemoryReport(o.store, { title: `${o.project} · memory` });
+    await writeFile(target, renderMemoryHtml(report), 'utf8');
+    if (asJson) {
+        json({ path: target, nodes: report.nodes.length, edges: report.edges.length });
+    }
+    else {
+        note(`${green('wrote')} ${target} ${dim(`· ${count(report.nodes.length, 'node')}, ${count(report.edges.length, 'edge')}`)}`);
+    }
+    if (flags.open) {
+        reveal(target);
+    }
+}
+/**
+ * Handing a path to the platform opener. `spawn` without a shell, so the path
+ * is an argument rather than something a shell gets to interpret.
+ */
+function reveal(target) {
+    const command = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'explorer'
+            : 'xdg-open';
+    spawn(command, [target], { stdio: 'ignore', detached: true }).unref();
+}
+// ---------------------------------------------------------------------------
+// forget
+// ---------------------------------------------------------------------------
+/**
+ * The only destructive thing here, and it is deliberately not the way to fix a
+ * memory that turned out wrong — that is a new node and a `SUPERSEDES` edge,
+ * which keeps the reason it changed. This is for what should never have been
+ * written down: it takes the node, its vector and its file bytes together.
+ */
+async function forget(o, ids, flags, asJson) {
+    if (!ids.length) {
+        throw usageError('forget takes at least one id', 'zen memory forget <id...>');
+    }
+    const found = [];
+    for (const id of ids) {
+        const node = o.store.graph.get(id);
+        if (!node) {
+            throw usageError(`no node ${id}`, 'list them with `zen memory ls`');
+        }
+        found.push(node);
+    }
+    if (!flags.yes) {
+        if (!isInteractive()) {
+            throw usageError('refusing to remove without confirmation', 'pass --yes');
+        }
+        writeAll(table(found.map((n) => [cyan(n.id), n.kind, clip(n.text, 56)])));
+        write();
+        if (!(await confirm(`Forget ${count(found.length, 'node')}?`))) {
+            note('nothing removed');
+            return;
+        }
+    }
+    // The vector and the bytes go with the node, which `MemoryIndex` already
+    // guarantees; `sees` is every audience in the graph, because this command
+    // is the person who owns the files rather than an agent inside a run.
+    const index = new MemoryIndex({ store: o.store });
+    await index.forget(found.map((n) => n.id), [ALL_AGENTS, ...new Set(o.store.graph.nodes().flatMap((n) => n.audience))]);
+    if (asJson) {
+        json({ forgotten: found.map((n) => n.id) });
+    }
+    else {
+        note(`${green('forgot')} ${count(found.length, 'node')}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Shared
+// ---------------------------------------------------------------------------
+function clip(text, n) {
+    const one = text.replace(/\s+/g, ' ').trim();
+    return one.length > n ? one.slice(0, n - 1) + '…' : one;
+}
+//# sourceMappingURL=memory.js.map

package/dist/commands/models.js

@@ -393,6 +393,17 @@ function verdict(probe) {
             return dim('no answer');
     }
 }
+/**
+ * Which project and region a Vertex call was actually made in. A publisher
+ * model is only missing *somewhere*, and the somewhere is the part nobody
+ * typed: it comes off the key, or out of the service-account file itself.
+ */
+function vertexAt(where) {
+    const entry = where.fromEnv.has('vertex') ? undefined : where.store.active('vertex');
+    const id = entry ? where.store.projectOf(entry)?.id : process.env.GOOGLE_CLOUD_PROJECT;
+    const location = process.env.GOOGLE_CLOUD_LOCATION ?? entry?.location ?? 'global';
+    return `vertex: project ${id ?? 'unset'} · location ${location}`;
+}
 const test = async (ctx, args) => {
     const { values, positionals } = parse(args, ROLE_OPTIONS, 'zen models test <provider:model> … [--chat|--embedding]');
     if (positionals.length === 0) {
@@ -402,7 +413,7 @@ const test = async (ctx, args) => {
     // Every ref is split before anything is built, so a typo in the third one
     // does not arrive after two billable calls.
     const parsed = positionals.map((ref) => ({ ref, ...split(ref) }));
-    await credentials();
+    const where = await credentials();
     const probes = [];
     const bar = ctx.json ? undefined : progress();
     for (const { ref, provider, id } of parsed) {
@@ -425,6 +436,11 @@ const test = async (ctx, args) => {
                 note(dim(`${p.ref}: ${p.check.fix}`));
             }
         }
+        // A Vertex refusal is about a model *in a project*, and the project is
+        // the half of that nobody typed.
+        if (parsed.some((p) => p.provider === 'vertex')) {
+            note(dim(vertexAt(where)));
+        }
     }
     const failed = probes.filter((p) => p.check.state !== 'live');
     if (failed.length > 0) {