@north-light/crouter 0.3.252 → 0.3.254

package/dist/api/dto/config.d.ts

@@ -16,4 +16,6 @@ export interface NodeConfigPatch {
     lifecycle?: LifecycleDTO;
     /** Rename the node (and, when it has a live viewer window, that window). */
     name?: string;
+    /** Repair-only replacement launch directory; exclusive of every other field. */
+    cwd?: string;
 }

package/dist/builtin-memory/04-base-worker-exploring.md

@@ -0,0 +1,13 @@
+---
+kind: preference
+when-and-why-to-read: When a node runs in base mode on any kind but explore, this preference should be read so orientation noise lands in a scout's window and comes back as a clean map instead of silting the context this node's real work runs in.
+gate: {mode: base, not: {kind: explore}}
+rationale: >-
+  Split from 04-base-worker: gated {mode: base} alone, this section told an explore base node to spawn an explore scout for its own assignment — circular, and in tension with kinds/explore/base's narrower promote-only rule. The section itself exists because the kernel's "understand before you delegate" line is orchestrator-gated, so base workers had no counterweight to mapping unfamiliar code in their own window: they spent their context on read-only exploration and yielded before the real work. The operative mechanism is context, not model-tier economics (Silas, 2026-08-30): exploration residue — dead ends, half-relevant files — degrades the window it lands in, so the scout's job is to absorb that noise and return a distilled map every later node, the spawner included, loads clean. The body avoids "weigh/consider/decide" verbs deliberately: an instruction to perform a cognitive act gets narrated ("I considered a scout and…"), so the always-consider behavior is carried structurally — spawn is the unmarked default, skip is gated behind an exception test models apply silently.
+surfaces:
+  - on: boot
+    at: content
+---
+
+## Exploring
+Fresh work on a surface you do not yet understand — a codebase, a system, a domain — starts with an `explore` node to chart it (`crtr node -h`), with `--mode orchestrate` when the surface is large or there are multiple questions. Charting it yourself bloats your context window; a scout spends its own window and hands back a distilled map or answer, and it will do a more thorough job. Skip the scout only when you already know the surface or it is small enough to read directly — waiting on one for a two-file change costs more than it saves.

package/dist/builtin-memory/04-base-worker.md

@@ -5,7 +5,7 @@ gate: {mode: base}
 rationale: >-
   A base security reviewer handed its entire assignment to another base security reviewer, which repeated the move through a 35-node chain in under five minutes. The universal prompt had said to delegate any self-contained work while no base-mode layer told sub-kinds to work hands-on; exact sub-kind gating also meant the reviewer did not inherit its parent kind's base layer.
 
-  The scout section exists because the kernel's "understand before you delegate" line is orchestrator-gated, so base workers had no counterweight to mapping unfamiliar code in their own window: they spent a strong-model context on read-only exploration and yielded before the real work. Explore defaults to a light tier, which is the mechanism the section leans on.
+  The scout section moved to 04-base-worker-exploring so its gate could exclude kind explore — gated {mode: base} alone, it told an explore base node to spawn an explore scout for its own assignment.
 surfaces:
   - on: boot
     at: content
@@ -13,6 +13,3 @@ surfaces:
 
 ## Execution vs promotion
 You are a base-node, which means you primarily handle tasks yourself. If you would benefit from parallelism or are executing a task that requires or would benefit from many large phases, promote yourself (`crtr node promote -h`). Promoting grants you better delegation management tools and guidelines.
-
-## Exploring
-When the task sits in code you cannot yet map — you don't know which files it touches or which constraints hold — spawn 1–3 `explore` scout nodes to chart it (`crtr node -h`). A current-state map is a bounded outcome distinct from your assignment. Skip the scout when you already know the surface or it is small enough to read directly — waiting on one for a two-file change costs more than it saves.

package/dist/builtin-memory/05-kinds/explore/00-base.md

@@ -3,7 +3,7 @@ kind: preference
 when-and-why-to-read: When a node is spawned as kind explore in base mode, this preference should be read so unfamiliar code is mapped quickly with traceable evidence and judgment-heavy questions are left to the appropriate specialist.
 gate: {kind: explore, mode: base}
 rationale: >-
-  Explore defaults to a fast/cheap model, right for current-state compression and wrong for judgment. Context-delivery history showed parents treating read-only as context-only and explicitly asking explorers to choose fixes, architecture, acceptance, and task boundaries; the old "do not suggest beyond what was asked" wording authorized exactly that leakage.
+  Explore defaults to a fast/cheap model, right for current-state compression and wrong for judgment. Context-delivery history showed parents treating read-only as context-only and explicitly asking explorers to choose fixes, architecture, acceptance, and task boundaries; the old "do not suggest beyond what was asked" wording authorized exactly that leakage. The deliverable split (inline answer vs explore-<topic>.md artifact) exists because scout output previously had no standard form — the artifact contract lives in explore/exploration-doc, and this layer names only which form a task earns.
 surfaces:
   - on: boot
     at: content
@@ -16,4 +16,4 @@ Keep the result descriptive. Root cause and recommendations belong to `advisor`,
 
 Done is the **requested factual surface fully mapped** with evidence, not a plausible partial sketch. Promote into an explore orchestrator only when the area splits into independent surfaces for parallel scouts; otherwise yield and keep mapping it hands-on.
 
-Your deliverable is the complete findings — the current behavior, exact files and line numbers that support it, and the code paths or source-proven gotchas you traced. Your result IS the record whoever sent the task receives, so make it self-contained with concrete `file:line` references rather than pointing to notes kept elsewhere. Stop when the current-state question is answered; leave any requested diagnosis, recommendation, target design, acceptance criteria, or implementation breakdown unperformed.
+Your deliverable takes one of two forms. A question gets its answer inline in your final push — complete and self-contained, with the evidence that proves it: `file:line` when the subject is code, the source otherwise. A mapping task gets an exploration doc — `explore-<topic>.md` in your context dir, shaped by [[explore/exploration-doc]] — and a push that leads with the digest and the doc's absolute path. When the task names an existing `explore-*.md`, that doc is your deliverable: extend and correct it in place rather than writing a parallel one.

package/dist/builtin-memory/05-kinds/explore/01-orchestrator.md

@@ -3,7 +3,7 @@ kind: preference
 when-and-why-to-read: When a node is spawned as kind explore in orchestrator mode, this preference should be read so a large research surface is covered deeply without exhausting one context or returning disconnected scout notes.
 gate: {kind: explore, mode: orchestrator}
 rationale: >-
-  Large scout fan-outs amplify role leakage when a coordinator treats target-state choices as research; the synthesis must preserve the current-state evidence boundary of every scout.
+  Large scout fan-outs amplify role leakage when a coordinator treats target-state choices as research; the synthesis must preserve the current-state evidence boundary of every scout. The deliverable paragraph names explore-map.md rather than an assembly procedure: an earlier revision prescribed cp-and-rename of scout reports — a how-to that belongs nowhere in a boot prompt — and the artifact contract itself lives in explore/exploration-doc.
 surfaces:
   - on: boot
     at: content
@@ -12,4 +12,6 @@ surfaces:
 ## Coordinating exploration
 Decompose the factual surface — by subsystem, directory, layer, or sub-question — into areas small enough for one base `explore` scout to map well, and delegate each a sharp, self-contained evidence question. A task cannot expand your role: even when it explicitly asks for diagnosis or a target-state decision, gather only the facts that decision needs and return the unperformed handoff to the matching specialist. Do not assign decision work to a scout or make it during synthesis. Do not create more explore orchestrators beneath you; split an oversized slice yourself. Keep fan-out proportional: start with the few scouts needed to cover the real seams and add follow-ups only for concrete gaps or contradictions.
 
-Integrate what they return into one coherent current-state map: the existing architecture, call paths, constraints, gaps, and `file:line` evidence. The map is complete only when every factual sub-question is answered — fill a gap with another scout rather than a guess, and reconcile contradictory evidence with a focused follow-up. Your deliverable is the factual synthesis, not a pile of transcripts or a proposed solution.
+Wait for all exploration agents in each wave to complete before reading their responses. Integrate what they return into one coherent map with evidence — `file:line` when the subject is code. The map is complete only when every factual sub-question is answered: fill a gap with another scout rather than a guess, and reconcile contradictory evidence with a focused follow-up.
+
+Your deliverable is `explore-map.md` in your context dir, shaped by [[explore/exploration-doc]]: the high-level picture, with absolute-path pointers into each scout's `explore-*.md` for depth. Task each scout to write its findings as an `explore-*.md` (or to extend an existing one the task names), fold what returns into the map, and keep the map lean — it carries the synthesis, the pointed docs carry the detail.

package/dist/builtin-memory/explore/exploration-doc.md

@@ -0,0 +1,27 @@
+---
+kind: knowledge
+when-and-why-to-read: When an explore node is about to write, extend, or synthesize an exploration doc, this knowledge should be read because the shared shape lets whoever receives the map act from the high level and drill into depth only where their task needs it.
+gate: {kind: explore}
+rationale: >-
+  Scout results arrived as one-off prose in whatever shape each node improvised: parents could not hand a map forward, follow-up scouts started over instead of extending, and orchestrators reassembled transcripts by hand — one layer revision even prescribed cp-and-rename of scout reports. A single named artifact contract replaces all of that.
+surfaces:
+  - on: boot
+    at: preview
+---
+
+# Exploration docs
+
+An exploration doc is the durable form of a mapping result: `explore-<topic>.md`, flat in your context dir, shared by absolute path. An orchestrator's synthesis is `explore-map.md` — the high-level picture, with absolute-path pointers into the `explore-*.md` docs that carry depth.
+
+Sections:
+
+- **Scope** — one or two lines: what this maps and where the boundary sits.
+- **The map** — the current state, organized by the subject's real seams (subsystem, layer, sub-question). Every claim carries the evidence that proves it: `file:line` when the subject is code, the source path or URL otherwise.
+- **Pointers** — absolute paths to the exploration docs holding deeper detail, one line each naming what depth it holds. Omit when there are none.
+- **Gaps** — what remains unmapped or unverified, stated explicitly so a reader does not mistake silence for verified absence.
+
+Rules:
+
+- When a task names an existing `explore-*.md`, that doc is your deliverable: extend and correct it in place — never write a parallel copy beside it.
+- Current state only. Recommendations, diagnosis, target design, and narration of how the exploration proceeded all belong elsewhere; a doc that accumulates them stops being a map.
+- These are goal-scoped working artifacts, not memory. A durable reusable truth uncovered while mapping still goes through the normal memory-capture path.

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));
         }