@zenera/cli 1.1.24 → 1.1.25

package/dist/commands/inspect.js

@@ -1,4 +1,4 @@
-import { assertState, buildRunReport, FilePayloadStore, memoryDir, MemoryStore, PayloadResolver, projectRegistry, readProjectConfig, renderReportHtml, } from '@zenera/neo';
+import { assertState, buildRunReport, FilePayloadStore, memoryDir, MemoryStore, PayloadResolver, projectRegistry, readProjectConfig, renderReportHtml, text, } from '@zenera/neo';
 import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
@@ -11,7 +11,10 @@ import { sessionIds } from "../projects.js";
 import { project as resolveProject } from "../resolve.js";
 import { display, listRuns, listSessions, newestRun, readRunMeta, requireSession, runPaths, runPathsAt, sessionPaths, } from "../session.js";
 import { nodeDetail, parseNodeIds, traceIndex, traceMermaid, traceOf, } from "../trace.js";
-import { ago, bold, bytes, choose, cyan, dim, invalidError, isInteractive, json, note, usageError, write, writeAll, yellow, } from "../term.js";
+import { formatMarkdown } from "../tui/markdown.js";
+import { boxWidth } from "../tui/wrap.js";
+import { ago, bold, bytes, choose, cyan, dim, invalidError, isInteractive, json, note, pad, ask as prompt, readStdin, usageError, write, writeAll, yellow, } from "../term.js";
+import { appendUsage } from "../usage.js";
 const USAGE = 'zen inspect [report|graph|node|ask] [run] [--dir <run dir>] [--open]';
 const SUBCOMMANDS = ['report', 'graph', 'node', 'ask'];
 // ---------------------------------------------------------------------------
@@ -44,7 +47,8 @@ export const inspect = {
         '  report                 Build and print the path to report.html. Default.',
         '  graph                  The whole run as one Mermaid flowchart, on stdout.',
         '  node <id...>           Those nodes of the graph in full. Ranges: n5..n9.',
-        '  ask <id> <question>    Put a question to the model that made that call.',
+        '  ask <id> <question>    One answer on stdout, then exit. Never prompts.',
+        '  ask [<id>]             A conversation at a terminal. Prompts for the rest.',
         '',
         '  --project <name|dir>   Which project. Defaults to the one you are in.',
         '  --session <id>         Which session. Defaults to the newest that ran.',
@@ -52,6 +56,7 @@ export const inspect = {
         '  --dir <dir>            A run directory, as `zen run --json` reports it.',
         '  --memory <dir>         Read this memory instead of the project’s.',
         '  --model <ref>          Answer `ask` with this model instead of the run’s.',
+        '  --question-file <path> Read the `ask` question from a file; `-` is stdin.',
         '  --part <name>          Print this part of a node in full. Repeatable.',
         '  --full                 Print every part, the recorded `request` included.',
         '  --rebuild              Build report.html again from the run state.',
@@ -59,8 +64,8 @@ export const inspect = {
         '  --no-timing            Leave the clock off the graph.',
         '  --no-style             Leave the colours off the graph. Shorter to read.',
         '',
-        'With no arguments: asks which session and run, or takes the newest of',
-        'each when there is nothing to ask on.',
+        'With no run named, report, graph and node ask which session and run at',
+        'a terminal, and take the newest of each when there is nothing to ask on.',
         '',
         '`graph` is written to be read by a model. Nodes are declared in the',
         'order they happened, with ids `n1`, `n2`, …; every edge is collected in',
@@ -82,9 +87,27 @@ export const inspect = {
         '`ask` replays one `llm_call` — its system prompt, its messages, its tool',
         'schemas — to a model, with your question on the end and tool calling off.',
         'It is told the run is over and that it may quote its own instructions, so',
-        'the answer names the prompt or skill behind the behaviour:',
+        'the answer names the prompt or skill behind the behaviour. It has two',
+        'modes, and which one is decided by whether the question is given:',
+        '',
+        'One-shot — a question on the line, in --question-file, or --json. For a',
+        'script or a model: no banner, no prompt, no picker; stdout is the answer',
+        'and nothing else. Name the run with --dir, --run or --session, or the',
+        'newest is taken.',
         '',
         '  zen inspect ask n11 "why run python -c when the skill says npm test?"',
+        '  zen inspect ask n11 --question-file q.md --dir <run dir>',
+        '',
+        'A question with quotes, backticks or several lines goes in a file, so no',
+        'shell ever parses it.',
+        '',
+        'Interactive — no question. For a person at a terminal: asks for whatever',
+        'is not named (session, run, LLM call), then the question, and keeps the',
+        'conversation going until an empty question. Without a terminal it is an',
+        'error, never a wait.',
+        '',
+        '  zen inspect ask',
+        '  zen inspect ask n11 --dir <run dir>',
         '',
         'All of it, at length: .github/skills/zen-cli/references/inspect.md',
     ],
@@ -97,6 +120,7 @@ export const inspect = {
             memory: { type: 'string' },
             model: { type: 'string' },
             part: { type: 'string', multiple: true },
+            'question-file': { type: 'string' },
             full: { type: 'boolean' },
             open: { type: 'boolean' },
             rebuild: { type: 'boolean' },
@@ -117,8 +141,13 @@ export const inspect = {
             return await nodes(at, values, rest, ctx.json);
         }
         if (what === 'ask') {
-            const at = await locate(ctx.cwd, values, undefined, asking);
-            return await ask(at, values, rest, ctx.json);
+            // Given a question it is one-shot; only a bare `ask` converses.
+            const oneShot = ctx.json || values['question-file'] !== undefined || rest.length > 1;
+            if (!oneShot && !(asking && process.stdout.isTTY)) {
+                throw usageError('interactive `ask` needs a terminal; give the node id and a question', 'zen inspect ask n11 --question-file q.md --dir <run dir>');
+            }
+            const at = await locate(ctx.cwd, values, undefined, !oneShot);
+            return await ask(at, values, rest, ctx.cwd, ctx.json, !oneShot);
         }
         const at = await locate(ctx.cwd, values, rest[0], asking);
         if (what === 'graph') {
@@ -245,14 +274,82 @@ export function wholeParts(found, values) {
  * it. Everything it sees is what it saw at the time, so an answer naming the
  * skill that steered it is checkable against the same node.
  */
-async function ask(at, values, rest, asJson) {
+export function replayableCalls(trace) {
+    return trace.entries.flatMap((entry) => entry.node.type === 'llm_call' && entry.node.request ? [{ entry, node: entry.node }] : []);
+}
+const ASK_BOX = { tl: '╭', tr: '╮', bl: '╰', br: '╯', h: '─', v: '│' };
+function askPanel(title, text, outer, border) {
+    const inner = outer - 4;
+    const rule = ASK_BOX.h.repeat(Math.max(1, outer - title.length - 5));
+    return [
+        border(`${ASK_BOX.tl}${ASK_BOX.h} ${title} ${rule}${ASK_BOX.tr}`),
+        ...formatMarkdown(text, inner).map((line) => `${border(ASK_BOX.v)} ${pad(line, inner)} ${border(ASK_BOX.v)}`),
+        border(`${ASK_BOX.bl}${ASK_BOX.h.repeat(outer - 2)}${ASK_BOX.br}`),
+    ];
+}
+export function renderAskExchange(question, answer, columns = 80) {
+    const outer = boxWidth(`${question}\n\n${answer}`, columns);
+    return [
+        '',
+        ...askPanel('Question', question, outer, cyan),
+        '',
+        ...askPanel('Answer', answer, outer, dim),
+        '',
+    ];
+}
+export async function repeatQuestions(initial, next, answer) {
+    let question = initial;
+    while (question) {
+        await answer(question);
+        question = (await next()).trim();
+    }
+}
+/** The question: the words on the line, or the whole of `--question-file` (`-` is stdin). */
+export async function readQuestion(words, file, cwd) {
+    const typed = words.join(' ').trim();
+    if (file === undefined) {
+        return typed;
+    }
+    if (typed) {
+        throw usageError('give the question either as words or as --question-file, not both', 'zen inspect ask n11 --question-file q.md');
+    }
+    if (file === '-') {
+        return (await readStdin()) ?? '';
+    }
+    try {
+        return (await readFile(resolve(cwd, file), 'utf8')).trim();
+    }
+    catch (err) {
+        throw invalidError(`cannot read question file ${file}: ${err.code ?? err}`, 'write the question to that path first');
+    }
+}
+async function ask(at, values, rest, cwd, asJson, interactive) {
     const { project, session, run } = at;
-    const [id, ...words] = rest;
-    const query = words.join(' ').trim();
-    if (!id || !query) {
+    const trace = traceOf(await readState(run));
+    let [id, ...words] = rest;
+    if (!id && interactive) {
+        const calls = replayableCalls(trace);
+        if (calls.length === 0) {
+            throw invalidError(`run ${run.id} has no recorded LLM call to replay`, 'only runs that record requests can be asked about');
+        }
+        const entry = await choose('Which LLM call?', calls.map((candidate) => ({
+            label: `${candidate.entry.key} ${candidate.node.model}`,
+            detail: [
+                candidate.node.agent,
+                candidate.node.toolCalls.length
+                    ? `calls ${candidate.node.toolCalls.map((call) => call.name).join(', ')}`
+                    : '',
+                candidate.entry.branch ? `branch ${candidate.entry.branch}` : '',
+            ]
+                .filter(Boolean)
+                .join('  '),
+            value: candidate.entry,
+        })));
+        id = entry.key;
+    }
+    if (!id) {
         throw usageError('ask takes one node id and a question', 'zen inspect ask n11 "why did you run python -c instead of the tests?"');
     }
-    const trace = traceOf(await readState(run));
     let wanted;
     try {
         wanted = parseNodeIds([id], trace.byKey);
@@ -272,6 +369,15 @@ async function ask(at, values, rest, asJson) {
         throw invalidError(`${entry.key} did not record the request that produced it`, 'only a run made by this CLI records requests; an SDK run needs ' +
             '`runner({ recordRequests: true })`');
     }
+    const query = interactive
+        ? await prompt('Question (empty to finish)?')
+        : await readQuestion(words, values['question-file'], cwd);
+    if (!query && interactive) {
+        return;
+    }
+    if (!query) {
+        throw usageError('ask takes one node id and a question', 'zen inspect ask n11 "why did you run python -c instead of the tests?"');
+    }
     const payloads = new PayloadResolver(new FilePayloadStore({ dir: session.blobs, id: 'file' }));
     // Deliberately not the preview fallback `node` uses: a truncated request is
     // not the call that happened, and an answer about it would be about nothing.
@@ -292,8 +398,32 @@ async function ask(at, values, rest, asJson) {
             'a second opinion, not the model looking at itself'));
     }
     const model = projectRegistry(config).model(picked.ref);
-    const res = await model.generate(buildDiagnostic({ request: recorded, answer, toolCalls, query }));
+    const record = async (call) => {
+        const startedAt = new Date();
+        const res = await call();
+        appendUsage(project, {
+            kind: 'ask',
+            ts: new Date().toISOString(),
+            runDir: run.dir,
+            node: entry.key,
+            nodeAgent: node.agent,
+            nodeModel: node.model,
+            model: picked.label,
+            usage: res.usage,
+            startedAt: startedAt.toISOString(),
+            durationMs: Date.now() - startedAt.getTime(),
+        });
+        return res;
+    };
+    const generate = (question) => record(() => model.generate(buildDiagnostic({ request: recorded, answer, toolCalls, query: question })));
+    const usage = (res) => {
+        note(dim(`${bold(entry.key)} ${picked.label}` +
+            (res.usage
+                ? ` · ${res.usage.inputTokens} in, ${res.usage.outputTokens} out`
+                : '')));
+    };
     if (asJson) {
+        const res = await generate(query);
         json({
             session: session.id,
             run: run.id,
@@ -306,9 +436,28 @@ async function ask(at, values, rest, asJson) {
         });
         return;
     }
-    write(res.text);
-    note(dim(`${bold(entry.key)} ${picked.label}` +
-        (res.usage ? ` · ${res.usage.inputTokens} in, ${res.usage.outputTokens} out` : '')));
+    if (!interactive) {
+        write((await generate(query)).text);
+        return;
+    }
+    let conversation;
+    await repeatQuestions(query, () => prompt('Question (empty to finish)?'), async (question) => {
+        if (!conversation) {
+            conversation = buildDiagnostic({
+                request: recorded,
+                answer,
+                toolCalls,
+                query: question,
+            });
+        }
+        else {
+            conversation.messages.push({ role: 'user', content: [text(question)] });
+        }
+        const res = await record(() => model.generate(conversation));
+        conversation.messages.push({ role: 'assistant', content: res.text });
+        writeAll(renderAskExchange(question, res.text, process.stdout.columns ?? 80));
+        usage(res);
+    });
 }
 /**
  * A part name as it can be typed back. The tool-call parts are named
@@ -371,7 +520,7 @@ export function renderNode(node, whole = () => true) {
  * it can be used again would be work for nothing. A person holds an id, or
  * nothing at all and gets asked.
  */
-async function locate(cwd, values, positional, asking) {
+export async function locate(cwd, values, positional, asking) {
     // A run id is a stamp and never has a separator in it, so a positional
     // with one is unambiguously a path.
     const asPath = positional?.includes('/') ? positional : undefined;

package/dist/commands/memory.js

@@ -1,15 +1,15 @@
-import { ALL_AGENTS, buildMemoryReport, createEmbedder, GREP_FIELDS, grepMemory, hostPath, memoryDir, MemoryError, MemoryIndex, MemoryStore, MergeConflicts, mergeMemories, readProjectConfig, renderMemoryHtml, renderRecollection, } from '@zenera/neo';
+import { ALL_AGENTS, buildMemoryReport, createEmbedder, diffMemories, GREP_FIELDS, grepMemory, hostPath, memoryDir, MemoryError, MemoryIndex, MemoryStore, MergeConflicts, mergeMemories, readProjectConfig, renderMemoryHtml, renderRecollection, } from '@zenera/neo';
 import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
-import { basename, isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, isAbsolute, join, resolve } from 'node:path';
 import { parse } from "../args.js";
 import { loadProjectEnv } from "../env.js";
 import { KeyStore } from "../keys.js";
 import { project as resolveProject } from "../resolve.js";
-import { ago, bold, bytes, CliError, confirm, count, cyan, dim, EXIT, green, isInteractive, json, note, table, usageError, write, writeAll, yellow, } from "../term.js";
-const USAGE = 'zen memory [stats|ls|search|grep|show|export|merge|forget] [args] [options]';
-const SUBCOMMANDS = ['stats', 'ls', 'search', 'grep', 'show', 'export', 'merge', 'forget'];
+import { ago, bold, bytes, CliError, confirm, count, cyan, dim, EXIT, green, isInteractive, json, note, plain, table, usageError, write, writeAll, yellow, } from "../term.js";
+const USAGE = 'zen memory [stats|ls|search|grep|show|diff|export|merge|forget] [args] [options]';
+const SUBCOMMANDS = ['stats', 'ls', 'search', 'grep', 'show', 'diff', 'export', 'merge', 'forget'];
 /** Enough to see the shape of it; the rest is a number. */
 const LISTED = 30;
 // ---------------------------------------------------------------------------
@@ -42,6 +42,7 @@ export const memory = {
         '  search <text>          Recall it, the way an agent does. Ranked.',
         '  grep <pattern>         Every node containing it, with the matching lines.',
         '  show <id>              One node in full, with what it links to.',
+        '  diff <base>            What this memory holds that <base> did not.',
         '  export [file]          The whole graph as one HTML page.',
         '  merge <dir...>         Fold other memories into this one.',
         '  forget <id...>         Remove nodes, their vectors and their files.',
@@ -104,6 +105,12 @@ export const memory = {
         '  zen memory merge <batch-dir>/*/memory',
         '',
         'which is where `zen run batch` leaves them.',
+        '',
+        '`diff` is the question after a run that started from a copy: what it',
+        'added, which of those `merge` would fold onto a node <base> already held',
+        '(a re-commit), what it revised, and which nodes `memory_load` read:',
+        '',
+        '  zen memory diff <candidate> --dir <batch-dir>/<id>/memory',
     ],
     run: async (ctx) => {
         const { values, positionals } = parse(ctx.args, {
@@ -156,6 +163,8 @@ export const memory = {
                     return await grep(opened, rest, values, ctx.json);
                 case 'show':
                     return show(opened, rest, ctx.json);
+                case 'diff':
+                    return await diff(opened, rest, ctx.cwd, ctx.json);
                 case 'export':
                     return await write_(opened, rest, values, ctx.cwd, ctx.json);
                 case 'merge':
@@ -309,23 +318,22 @@ function list(o, flags, asJson) {
         .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) });
+        json({ total: all.length, nodes: all.slice(0, limit).map((n) => onHost(o, n)) });
         return;
     }
     if (!all.length) {
         note('nothing matches');
         return;
     }
-    writeAll(table(all
+    writeAll(textLast(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') : '',
-    ])));
+        n.kind + (n.file ? dim(' ⎘ ' + n.file.format) : ''),
+        n.audience.join(','),
+        dim(`r${n.revision}`),
+        dim(ago(n.createdAt)) + (stale.has(n.id) ? ' ' + yellow('superseded') : ''),
+    ]), all.slice(0, limit).map((n) => n.text)));
     if (all.length > limit) {
         write();
         note(dim(`${all.length - limit} more — raise --limit, or use \`zen memory export\``));
@@ -552,7 +560,7 @@ async function grep(o, rest, flags, asJson) {
                 hits: m.hits,
                 more: m.more,
             })),
-            unsearched: res.skipped,
+            unsearched: res.skipped.map((s) => ({ ...s, path: hostPath(o.dir, s) })),
         });
         return;
     }
@@ -562,7 +570,7 @@ async function grep(o, rest, flags, asJson) {
     }
     if (!res.found) {
         note(`nothing matches ${pattern}`);
-        unsearched(res.skipped);
+        unsearched(o, res.skipped);
         return;
     }
     for (const m of res.matches) {
@@ -570,7 +578,7 @@ async function grep(o, rest, flags, asJson) {
             ' ' +
             m.node.kind +
             (m.stale ? ' ' + yellow('superseded') : '') +
-            (m.node.file ? ' ' + dim(m.node.file.path) : ''));
+            (m.node.file ? ' ' + dim(hostPath(o.dir, m.node.file)) : ''));
         writeAll(table(m.hits.map((h) => [`  ${dim(h.where + ':' + h.line)}`, clip(h.text, 120)])));
         if (m.more) {
             write(dim(`  … ${count(m.more, 'more line')} in this node`));
@@ -580,19 +588,19 @@ async function grep(o, rest, flags, asJson) {
     if (res.truncated) {
         note(dim(`${res.found - res.matches.length} more nodes — raise --limit`));
     }
-    unsearched(res.skipped);
+    unsearched(o, res.skipped);
 }
 /**
  * Named rather than counted. A file that was not read is a hole in an answer
  * whose whole value is that it has none, so the ids have to be printable.
  */
-function unsearched(skipped) {
+function unsearched(o, skipped) {
     if (!skipped.length) {
         return;
     }
     write();
     note(yellow(`${count(skipped.length, 'file')} not searched`));
-    writeAll(table(skipped.map((s) => [`  ${cyan(s.id)}`, dim(s.reason), s.path])));
+    writeAll(table(skipped.map((s) => [`  ${cyan(s.id)}`, dim(s.reason), hostPath(o.dir, s)])));
 }
 // ---------------------------------------------------------------------------
 // show
@@ -608,7 +616,11 @@ function show(o, ids, asJson) {
     }
     const links = o.store.graph.neighbors(id);
     if (asJson) {
-        json({ node, links, file: node.file ? hostPath(o.dir, node.file) : undefined });
+        json({
+            node: onHost(o, node),
+            links,
+            file: node.file ? hostPath(o.dir, node.file) : undefined,
+        });
         return;
     }
     write(bold(node.id) + ' ' + cyan(node.kind));
@@ -653,6 +665,82 @@ function show(o, ids, asJson) {
     })));
 }
 // ---------------------------------------------------------------------------
+// diff
+// ---------------------------------------------------------------------------
+async function diff(o, rest, cwd, asJson) {
+    if (rest.length !== 1) {
+        throw usageError('diff takes exactly one base memory', 'zen memory diff <base> [--dir <dir>]');
+    }
+    const at = resolve(cwd, rest[0]);
+    if (!existsSync(join(at, 'manifest.json'))) {
+        throw usageError(`${at} is not a memory`, 'no manifest.json in it');
+    }
+    const base = await MemoryStore.open(at, { lock: false });
+    try {
+        const d = diffMemories(base, o.store);
+        const mine = (n) => onHost(o, n);
+        const theirs = (n) => n.file ? { ...n, file: { ...n.file, path: hostPath(at, n.file) } } : n;
+        if (asJson) {
+            json({
+                ...d,
+                added: d.added.map((a) => ({ ...a, node: mine(a.node) })),
+                revised: d.revised.map((r) => ({ before: theirs(r.before), after: mine(r.after) })),
+                used: d.used.map((u) => ({ ...u, node: mine(u.node) })),
+                removed: d.removed.map(theirs),
+            });
+            return;
+        }
+        const twins = d.added.filter((a) => a.twin).length;
+        write(bold(o.dir) + dim(` against ${at} · nearest by ${d.by}`));
+        write();
+        write(`${bold('added')} ${d.added.length}` +
+            (twins ? ` · ${yellow(`${twins} already held`)}` : '') +
+            ` · ${bold('revised')} ${d.revised.length}` +
+            ` · ${bold('used')} ${d.used.length}` +
+            ` · ${bold('removed')} ${d.removed.length}` +
+            ` · ${bold('edges')} +${d.edges}`);
+        if (d.added.length) {
+            write();
+            write(dim('added'));
+            writeAll(textLast(d.added.map((a) => [
+                `  ${cyan(a.node.id)}`,
+                a.node.kind,
+                a.node.audience.join(','),
+                a.nearest
+                    ? `${a.twin ? yellow('twin of') : dim('near')} ${a.nearest.id} ${dim(a.nearest.score.toFixed(2))}`
+                    : dim('nothing near'),
+            ]), d.added.map((a) => a.node.text)));
+        }
+        if (d.revised.length) {
+            write();
+            write(dim('revised'));
+            writeAll(textLast(d.revised.map((r) => [
+                `  ${cyan(r.after.id)}`,
+                r.after.kind,
+                dim(`r${r.before.revision} → r${r.after.revision}`),
+            ]), d.revised.map((r) => r.after.text)));
+        }
+        if (d.used.length) {
+            write();
+            write(dim('used — returned by memory_load'));
+            writeAll(textLast(d.used.map((u) => [`  ${cyan(u.node.id)}`, u.node.kind, `${u.loads}×`]), d.used.map((u) => u.node.text)));
+        }
+        if (d.removed.length) {
+            write();
+            write(dim('removed'));
+            writeAll(textLast(d.removed.map((n) => [`  ${cyan(n.id)}`, n.kind]), d.removed.map((n) => n.text)));
+        }
+        if (d.supersedes.length) {
+            write();
+            write(dim('supersedes'));
+            writeAll(table(d.supersedes.map((s) => [`  ${cyan(s.source)}`, '→', cyan(s.target)])));
+        }
+    }
+    finally {
+        base.release();
+    }
+}
+// ---------------------------------------------------------------------------
 // export
 // ---------------------------------------------------------------------------
 async function write_(o, rest, flags, cwd, asJson) {
@@ -661,7 +749,8 @@ async function write_(o, rest, flags, cwd, asJson) {
     }
     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` });
+    const built = await buildMemoryReport(o.store, { title: `${o.project} · memory` });
+    const report = { ...built, nodes: built.nodes.map((n) => onHost(o, n)) };
     await writeFile(target, renderMemoryHtml(report), 'utf8');
     if (asJson) {
         json({ path: target, nodes: report.nodes.length, edges: report.edges.length });
@@ -720,7 +809,7 @@ async function merge(o, dirs, flags, cwd, asJson) {
     }
     catch (err) {
         if (err instanceof MergeConflicts) {
-            throw diverged(err, cwd, asJson);
+            throw diverged(err, asJson);
         }
         throw err;
     }
@@ -731,7 +820,7 @@ async function merge(o, dirs, flags, cwd, asJson) {
     writeAll(table([
         [dim('memory'), dim('nodes'), dim('new'), dim('shared'), dim('folded'), dim('files')],
         ...report.sources.map((s) => [
-            near(s.dir, cwd),
+            s.dir,
             String(s.nodes),
             s.added ? green(String(s.added)) : '0',
             String(s.shared),
@@ -752,7 +841,7 @@ async function merge(o, dirs, flags, cwd, asJson) {
  * point of stopping is that a person decides, and they cannot decide from a
  * count.
  */
-function diverged(err, cwd, asJson) {
+function diverged(err, asJson) {
     if (asJson) {
         json({ error: err.message, conflicts: err.conflicts });
     }
@@ -761,7 +850,7 @@ function diverged(err, cwd, asJson) {
             cyan(c.id),
             dim(`r${c.mine} ↔ r${c.theirs}`),
             clip(c.text, 48),
-            dim(near(c.dir, cwd)),
+            dim(c.dir),
         ])));
         write();
     }
@@ -818,9 +907,19 @@ function clip(text, n) {
     const one = text.replace(/\s+/g, ' ').trim();
     return one.length > n ? one.slice(0, n - 1) + '…' : one;
 }
-/** A path as it was probably typed: relative when it is below here, absolute when it is not. */
-function near(dir, cwd) {
-    const rel = relative(cwd, dir);
-    return rel && !rel.startsWith('..') ? rel : dir;
+/**
+ * A table whose last column is the text: cut to what the terminal has left,
+ * and whole when nobody is looking at a terminal — a pipe or an agent wants all of it.
+ */
+function textLast(rows, texts) {
+    const widths = rows[0]?.map((_, c) => Math.max(...rows.map((r) => plain(r[c] ?? '').length)));
+    const room = process.stdout.isTTY
+        ? Math.max(24, (process.stdout.columns || 120) - (widths ?? []).reduce((t, w) => t + w + 2, 0))
+        : Infinity;
+    return table(rows.map((r, i) => [...r, clip(texts[i] ?? '', room)]));
+}
+/** The stored `/memory/<id>.<ext>` is the agent's mount path; a terminal needs the host one. */
+function onHost(o, n) {
+    return n.file ? { ...n, file: { ...n.file, path: hostPath(o.dir, n.file) } } : n;
 }
 //# sourceMappingURL=memory.js.map