@north-light/crouter 0.3.253 → 0.3.255

package/dist/clients/attach/__tests__/group-activity.test.js

@@ -5,6 +5,10 @@
 //      failed — the folded rows just stop.
 //   2. A recap is a digest, never a payload dump: edit diffs and write bodies
 //      must never leak into it.
+//   3. `crtr` chips come from the structured record the CLI mirrors onto the
+//      tool result, never from rendered stdout. Scraping stdout is what broke
+//      every chip when `memory read` gained a field, and a bash call that runs
+//      several crtr commands must contribute one chip per invocation.
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { Container, TuiMainScreen } from '@earendil-works/pi-tui';
@@ -82,3 +86,80 @@ test('a folded recap carries paths and counts, never diff or write payload bodie
     assert.match(text, /overwritten\.ts/, 'the recap still names what changed');
     assert.doesNotMatch(text, /sensitive-old-diff|sensitive-new-diff|sensitive-write-payload/, 'payload bodies never leak into a recap');
 });
+// Records captured verbatim from real invocations with CRTR_PREVIEW_RESULT_PATH
+// set. One bash call ran the write and both reads; a second ran a command that
+// failed. Rendered stdout is deliberately absent from every fixture here.
+const WRITE_RECORD = {
+    path: 'memory write',
+    result: { name: 'prevproj/child', scope: 'project', path: '/private/tmp/prevproj/.crouter/memory/child.md' },
+};
+const READ_RECORD = {
+    path: 'memory read',
+    result: {
+        name: 'prevproj/child', local_name: 'child', kind: 'knowledge', scope: 'project',
+        path: '/private/tmp/prevproj/.crouter/memory/child.md',
+        store_root: '/private/tmp/prevproj/.crouter/memory', representation: 'leaf-file',
+        content: 'Body text one.\n', extensions: {},
+    },
+};
+const DIRECTORY_READ_RECORD = {
+    path: 'memory read',
+    result: { name: 'prevproj', kind: 'knowledge', scope: 'project', path: '/private/tmp/prevproj/.crouter/memory/INDEX.md', representation: 'directory-index' },
+};
+const EDIT_RECORD = {
+    path: 'memory edit',
+    result: {
+        name: 'prevproj/child', kind: 'knowledge', scope: 'project',
+        path: '/private/tmp/prevproj/.crouter/memory/child.md', revision: 8, changed: ['body'],
+    },
+};
+const DELETE_RECORD = {
+    path: 'memory delete',
+    result: {
+        name: 'prevproj/child', scope: 'project',
+        path: '/private/tmp/prevproj/.crouter/memory/child.md',
+        log_path: '/private/tmp/prevproj/.crouter/memory/.history/child.jsonl',
+    },
+};
+const FAILED_READ_RECORD = {
+    path: 'memory read',
+    error: { error: 'not_found', message: 'memory document not found: no/such/doc' },
+};
+function crtrCall(...records) {
+    return { details: { crtrPreviews: records, crtrPreview: records.at(-1) } };
+}
+test('every crtr invocation in one bash call becomes its own chip, read from the structured record', () => {
+    const recorder = new GroupActivityRecorder('/tmp/activity');
+    recorder.noteCall('chained', 'bash', { command: 'crtr memory write … && crtr memory read … && crtr memory read prevproj && crtr memory edit … && crtr memory delete …' });
+    recorder.settle('chained', crtrCall(WRITE_RECORD, READ_RECORD, DIRECTORY_READ_RECORD, EDIT_RECORD, DELETE_RECORD), false);
+    recorder.noteCall('failed', 'bash', { command: 'crtr memory read no/such/doc' });
+    recorder.settle('failed', crtrCall(FAILED_READ_RECORD), false);
+    const { memories } = recorder.activity();
+    assert.deepEqual(memories.map((memory) => [memory.action, memory.name]), [
+        ['write', 'prevproj/child'],
+        ['read', 'prevproj/child'],
+        ['read', 'prevproj'],
+        ['edit', 'prevproj/child'],
+        ['delete', 'prevproj/child'],
+    ], 'each invocation contributes once, under its own leaf; a failed one contributes nothing');
+    assert.equal(memories[0]?.path, '/private/tmp/prevproj/.crouter/memory/child.md', 'the path travels for the hyperlink');
+    assert.equal(memories.find((memory) => memory.action === 'delete')?.path, undefined, 'a deleted document carries no path: the file is gone and the link would be dead');
+});
+test('a transcript persisted before the channel carried a list still yields its chip', () => {
+    const recorder = new GroupActivityRecorder('/tmp/activity');
+    recorder.noteCall('legacy', 'bash', { command: 'crtr memory read prevproj/child' });
+    recorder.settle('legacy', { details: { crtrPreview: READ_RECORD } }, false);
+    assert.deepEqual(recorder.activity().memories, [{
+            action: 'read',
+            name: 'prevproj/child',
+            path: '/private/tmp/prevproj/.crouter/memory/child.md',
+        }]);
+});
+test('a node chip waits for a broker that actually started', () => {
+    const recorder = new GroupActivityRecorder('/tmp/activity');
+    recorder.noteCall('started', 'bash', { command: 'crtr node new --kind explore' });
+    recorder.settle('started', crtrCall({ path: 'node new', result: { node_id: 'abc-123', name: 'scout' } }), false);
+    recorder.noteCall('frozen', 'bash', { command: 'crtr node new --kind explore' });
+    recorder.settle('frozen', crtrCall({ path: 'node new', result: { node_id: 'def-456', name: 'deferred', frozen_at: '2026-01-01T00:00:00Z' } }), false);
+    assert.deepEqual(recorder.activity().nodes, [{ action: 'spawned', name: 'scout', id: 'abc-123' }]);
+});

package/dist/clients/attach/render/group-activity.d.ts

@@ -9,8 +9,10 @@ export type FileActivity = {
     hasKnownCounts: boolean;
     countsIncomplete: boolean;
 };
+/** `path` is the doc on disk, carried so the chip can hyperlink to it. A
+ * delete has no path: the file is gone, and a link to it would be dead. */
 export type MemoryActivity = {
-    action: 'read' | 'write';
+    action: 'read' | 'write' | 'edit' | 'delete';
     name: string;
     path?: string;
 };
@@ -72,5 +74,11 @@ export declare class GroupActivityRecorder {
     private addCard;
     private addEvent;
     private addNode;
+    /** The recorded leaf path is authoritative: which command ran and what it
+     * returned are both facts here, so a read can never be logged as a save and
+     * an inserted output field can never break a chip. A record carrying an
+     * `error` is a failed call, which is not activity. */
+    private noteCrtrInvocation;
+    private addMemory;
     private extract;
 }

package/dist/clients/attach/render/group-activity.js

@@ -22,110 +22,41 @@ function filePath(args) {
     const path = value?.file_path ?? value?.path;
     return typeof path === 'string' && path !== '' ? path : undefined;
 }
-function resultText(result) {
-    const content = object(result)?.content;
-    if (typeof content === 'string')
-        return content;
-    if (!Array.isArray(content))
-        return '';
-    return content
-        .flatMap((part) => {
-        const value = object(part);
-        return value?.type === 'text' && typeof value.text === 'string' ? [value.text] : [];
-    })
-        .join('');
-}
 function lineCount(content) {
     if (content.length === 0)
         return 0;
     return (content.match(/\n/g)?.length ?? 0) + (content.endsWith('\n') ? 0 : 1);
 }
-/** Shell-level command segments only: a quoted `crtr memory read` is data, not
- * an invocation. This intentionally handles the same separators the viewer's
- * command preview treats as command boundaries. */
-function shellSegments(command) {
-    const segments = [];
-    let segment = '';
-    let quote;
-    for (let i = 0; i < command.length; i++) {
-        const char = command[i];
-        if (char === '\\' && quote !== "'") {
-            segment += char + (command[++i] ?? '');
-            continue;
-        }
-        if (quote !== undefined) {
-            if (char === quote)
-                quote = undefined;
-            segment += char;
-            continue;
-        }
-        if (char === '"' || char === "'") {
-            quote = char;
-            segment += char;
-            continue;
-        }
-        if (char === '\n' || char === ';' || char === '|' || char === '&' || char === '(' || char === ')') {
-            if (segment.trim())
-                segments.push(segment);
-            segment = '';
-            continue;
-        }
-        segment += char;
-    }
-    if (segment.trim())
-        segments.push(segment);
-    return segments;
-}
-function shellTokens(segment) {
-    return segment.match(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+/g)?.map((token) => token.length >= 2 && ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith("'") && token.endsWith("'")))
-        ? token.slice(1, -1)
-        : token) ?? [];
-}
-/** Deliberately match an executable token, not a result-shaped string or a
- * quoted command fragment. */
-function invokesCrtrCommand(args, path) {
-    const command = object(args)?.command;
-    if (typeof command !== 'string')
-        return false;
-    return shellSegments(command).some((segment) => {
-        const tokens = shellTokens(segment);
-        while (/^[A-Za-z_][A-Za-z0-9_]*=\S+$/.test(tokens[0] ?? ''))
-            tokens.shift();
-        const executable = tokens[0]?.split('/').at(-1);
-        if (executable !== 'crtr' && executable !== 'crouter')
-            return false;
-        return path.every((word, index) => tokens[index + 1] === word);
+/** One crtr invocation's own structured result, mirrored onto the bash tool
+ * result by the canvas preview extension — present on live tool events and on
+ * rebuilt snapshot messages alike, which is what makes it valid evidence for a
+ * recap that reduces historical transcript.
+ *
+ * `crtrPreviews` carries every invocation in the bash call; `crtrPreview` (the
+ * last one alone) is all a transcript persisted before the channel became a
+ * list can offer, so both are read. */
+function crtrPreviews(result) {
+    const details = object(object(result)?.details);
+    if (details === undefined)
+        return [];
+    const all = details['crtrPreviews'];
+    const records = Array.isArray(all) ? all : [details['crtrPreview']];
+    return records.flatMap((entry) => {
+        const record = object(entry);
+        if (record === undefined || typeof record['path'] !== 'string')
+            return [];
+        return [{ path: record['path'], result: object(record['result']), error: object(record['error']) }];
     });
 }
-/** A resolved read/write begins with the identity fields emitted by its leaf.
- * The write receipt also requires `created`, so result-shaped read output can
- * never be reported as a saved memory. */
-function resolvedMemories(result, action) {
-    const memories = [];
-    const identity = action === 'read'
-        ? /^- name:\s*([^\r\n]+)\r?\n- kind:\s*[^\r\n]+\r?\n- scope:\s*[^\r\n]+(?:\r?\n- path:\s*([^\r\n]+)|\r?\n\r?\n\*\*path:\*\*\s*([^\r\n]+))?/gm
-        : /^- name:\s*([^\r\n]+)\r?\n- kind:\s*[^\r\n]+\r?\n- scope:\s*[^\r\n]+\r?\n- created:\s*(?:true|false)(?:\r?\n- path:\s*([^\r\n]+)|\r?\n\r?\n\*\*path:\*\*\s*([^\r\n]+))?/gm;
-    for (const match of resultText(result).matchAll(identity)) {
-        const name = match[1]?.trim();
-        const path = (match[2] ?? match[3])?.trim();
-        if (name)
-            memories.push(path ? { action, name, path } : { action, name });
-    }
-    return memories;
-}
-/** The `node new` receipt line (commands/node/create.ts `render`), which names
- * the node only once its broker is actually running. */
-const SPAWNED_NODE_RE = /^Spawned "([^"\n]+)" \(([^)\s]+)\)/gm;
-function spawnedNodes(result) {
-    const nodes = [];
-    for (const match of resultText(result).matchAll(SPAWNED_NODE_RE)) {
-        const name = match[1]?.trim();
-        const id = match[2]?.trim();
-        if (name && id)
-            nodes.push({ action: 'spawned', name, id });
-    }
-    return nodes;
+function text(value) {
+    return typeof value === 'string' && value !== '' ? value : undefined;
 }
+const MEMORY_ACTIONS = {
+    'memory read': 'read',
+    'memory write': 'write',
+    'memory edit': 'edit',
+    'memory delete': 'delete',
+};
 /** Local mirror of pi's `resolveToCwd`: file tools expand `~` before resolving
  * against the node cwd, and the recap must key the exact same file identically. */
 function canonicalPath(rawPath, cwd) {
@@ -271,23 +202,56 @@ export class GroupActivityRecorder {
         if (node.action === 'spawned')
             this.roster.set(node.id, node.name);
     }
-    extract(entry, result) {
-        if (entry.name === 'bash') {
-            if (invokesCrtrCommand(entry.args, ['node', 'new'])) {
-                for (const node of spawnedNodes(result))
-                    this.addNode(node);
+    /** The recorded leaf path is authoritative: which command ran and what it
+     * returned are both facts here, so a read can never be logged as a save and
+     * an inserted output field can never break a chip. A record carrying an
+     * `error` is a failed call, which is not activity. */
+    noteCrtrInvocation(invocation) {
+        if (invocation.error !== undefined || invocation.result === undefined)
+            return;
+        const fields = invocation.result;
+        switch (invocation.path) {
+            case 'memory read':
+            case 'memory write':
+            case 'memory edit':
+            case 'memory delete': {
+                const name = text(fields['name']);
+                if (name === undefined)
+                    return;
+                const action = MEMORY_ACTIONS[invocation.path];
+                // A directory read resolves a name but no path, and a deleted doc's
+                // path now points at nothing — the chip stands either way, it just
+                // carries no hyperlink.
+                const path = action === 'delete' ? undefined : text(fields['path']);
+                this.addMemory(path === undefined ? { action, name } : { action, name, path });
+                return;
             }
-            for (const action of ['read', 'write']) {
-                if (!invokesCrtrCommand(entry.args, ['memory', action]))
-                    continue;
-                for (const memory of resolvedMemories(result, action)) {
-                    const key = `${action}:${memory.path ?? memory.name}`;
-                    if (!this.memorySet.has(key)) {
-                        this.memorySet.add(key);
-                        this.memories.push(memory);
-                    }
-                }
+            case 'node new': {
+                // `frozen_at` is the deferred-broker case: capacity held the child's
+                // engine back, so nothing started and the recap says nothing.
+                if (fields['frozen_at'] !== undefined && fields['frozen_at'] !== null)
+                    return;
+                const id = text(fields['node_id']);
+                const name = text(fields['name']);
+                if (id !== undefined && name !== undefined)
+                    this.addNode({ action: 'spawned', name, id });
+                return;
             }
+            default:
+                return;
+        }
+    }
+    addMemory(memory) {
+        const key = `${memory.action}:${memory.path ?? memory.name}`;
+        if (this.memorySet.has(key))
+            return;
+        this.memorySet.add(key);
+        this.memories.push(memory);
+    }
+    extract(entry, result) {
+        if (entry.name === 'bash') {
+            for (const invocation of crtrPreviews(result))
+                this.noteCrtrInvocation(invocation);
             return;
         }
         const rawPath = filePath(entry.args);

package/dist/clients/attach/render/group-recap.js

@@ -30,6 +30,21 @@ function memoryName(memory, palette) {
 function countMemories(memories, action) {
     return memories.filter((memory) => memory.action === action).length;
 }
+const MEMORY_ACTION_ICON = {
+    read: MEMORY_ICON,
+    write: TOOL_ICON.write,
+    edit: TOOL_ICON.edit,
+    delete: DELETE_ICON,
+};
+/** One stat per action a group actually performed, in the order the work
+ *  naturally happens. A group rarely does more than two of them, so the stat
+ *  line stays short. */
+const MEMORY_STATS = [
+    ['read', 'memory read', 'memory reads'],
+    ['write', 'memory saved', 'memories saved'],
+    ['edit', 'memory revised', 'memories revised'],
+    ['delete', 'memory deleted', 'memories deleted'],
+];
 function distinctFileCount(files) {
     return new Set(files.map((file) => file.key)).size;
 }
@@ -65,8 +80,9 @@ export class GroupRecapComponent extends Container {
                 this.addChild(new RecapDetailLine(`${palette.accent(ICON.graph)} `, palette.muted(node.name), palette.muted(node.action === 'spawned' ? ' spawned' : ' finished')));
             }
             for (const memory of activity.memories) {
-                const icon = memory.action === 'write' ? TOOL_ICON.write : MEMORY_ICON;
-                this.addChild(new RecapDetailLine(`${palette.info(icon)} `, memoryName(memory, palette), ''));
+                const icon = MEMORY_ACTION_ICON[memory.action];
+                const tone = memory.action === 'delete' ? palette.diffRemoved : palette.info;
+                this.addChild(new RecapDetailLine(`${tone(icon)} `, memoryName(memory, palette), ''));
             }
             for (const file of activity.files)
                 this.addFile(file, palette);
@@ -94,13 +110,12 @@ export class GroupRecapComponent extends Container {
             if (summary.filesDeleted >= 1) {
                 stats.push(`${palette.diffRemoved(DELETE_ICON)} ${palette.muted(count(summary.filesDeleted, 'file deleted', 'files deleted'))}`);
             }
-            const memoriesRead = countMemories(activity.memories, 'read');
-            if (memoriesRead >= 1) {
-                stats.push(`${palette.info(MEMORY_ICON)} ${palette.muted(count(memoriesRead, 'memory read', 'memory reads'))}`);
-            }
-            const memoriesSaved = countMemories(activity.memories, 'write');
-            if (memoriesSaved >= 1) {
-                stats.push(`${palette.info(TOOL_ICON.write)} ${palette.muted(count(memoriesSaved, 'memory saved', 'memories saved'))}`);
+            for (const [action, singular, plural] of MEMORY_STATS) {
+                const changed = countMemories(activity.memories, action);
+                if (changed < 1)
+                    continue;
+                const tone = action === 'delete' ? palette.diffRemoved : palette.info;
+                stats.push(`${tone(MEMORY_ACTION_ICON[action])} ${palette.muted(count(changed, singular, plural))}`);
             }
             this.addChild(new Text(stats.join(palette.muted(' · ')), 0, 0));
         }