@north-light/crouter 0.3.181 → 0.3.183

package/dist/build-root.js

@@ -1,5 +1,13 @@
 import { defineRoot } from './core/command.js';
 const TAGLINE = 'crtr: agentic runtime.';
+/** Flags handled before dispatch, so they belong to no leaf schema and are
+ *  stated once at root (help.ts renders them as the Globals footer). */
+const GLOBALS = [
+    {
+        name: '--json',
+        desc: "stdout as the leaf's declared outputs in raw JSON instead of prose — for scripts (a cron's bash, external tooling) that must branch on canvas state; prose stays the contract for what you read yourself.",
+    },
+];
 /** Lazy registry: subtree name → dynamic importer that builds its BranchDef.
  *  The whole point is that each `import()` only compiles that one subtree's
  *  module graph. The hot path (`crtr surface node focus …`, `crtr push …`, …) dispatches
@@ -10,7 +18,6 @@ const TAGLINE = 'crtr: agentic runtime.';
 const SUBTREE_LOADERS = {
     memory: async () => (await import('./commands/memory.js')).registerMemory(),
     profile: async () => (await import('./commands/profile.js')).registerProfile(),
-    search: async () => (await import('./commands/search.js')).registerSearch(),
     pkg: async () => (await import('./commands/pkg.js')).registerPkg(),
     human: async () => (await import('./commands/human.js')).registerHuman(),
     sys: async () => (await import('./commands/sys.js')).registerSys(),
@@ -53,7 +60,7 @@ export async function coreCommandPaths() {
 export async function resolveRoot(first) {
     const loader = first !== undefined ? SUBTREE_LOADERS[first] : undefined;
     if (loader !== undefined) {
-        return defineRoot({ tagline: TAGLINE, globals: [], subtrees: [await loader()] });
+        return defineRoot({ tagline: TAGLINE, globals: GLOBALS, subtrees: [await loader()] });
     }
     return buildRoot();
 }
@@ -88,5 +95,5 @@ export async function buildRoot() {
     // sys doctor). Reads only stored manifests — zero network.
     const snapshot = buildExternalCommandSnapshot(new Set(SUBTREE_NAMES));
     const external = composeExternalSubtrees(snapshot);
-    return defineRoot({ tagline: TAGLINE, globals: [], subtrees: [...core, ...external] });
+    return defineRoot({ tagline: TAGLINE, globals: GLOBALS, subtrees: [...core, ...external] });
 }

package/dist/builtin-memory/internal/memory-loading.md

@@ -13,7 +13,7 @@ Every memory doc declares its own loading policy in frontmatter; the runtime nev
 ## The two hooks
 
 - **System prompt** (`system-prompt-visibility`) — the boot catalog assembled into every node's system prompt at revive.
-- **File read** (`file-read-visibility`) — context attached to the workspace or to files. Two events: **workspace mount** during first-message assembly (docs routed `applies-to: "."`), and a later **matching file read** (docs routed by glob). Nothing positional fires from where the doc happens to sit on disk — only from its declared route.
+- **File read** (`file-read-visibility`) — context attached to the workspace or to files. Two events: **workspace mount** during first-message assembly (docs routed `applies-to: "."`), and a later **matching file read** — docs routed by glob, and `.`-routed docs whose store's owning dir contains the read file. Nothing positional fires from where the doc happens to sit on disk — only from its declared route.
 
 Each doc sets both rungs explicitly; there is no kind-based default. Usually one axis carries a real rung and the other is `none`.
 
@@ -38,6 +38,8 @@ At boot/first-message assembly the runtime mounts: builtin docs, the user store
 
 A root `INDEX.md` is a workspace's front door: `system-prompt-visibility: none`, `file-read-visibility: content`, `applies-to: "."` — the operating guide loads when that workspace mounts, not in every boot catalog. Multiple mounted roots render broad-to-specific, each under its own envelope name.
 
+A `.crouter/memory/` store nested BELOW a mounted root (a package or subsystem dir) is delivered by the read path, not by boot: reading any file beneath its owning dir surfaces its `.`-routed docs, deduplicated against everything already in the transcript. Addressability is separate — the `crtr memory` leaves (list/read/find/lint/delete/origin) discover nested stores through a bounded walk (git-aware, depth- and time-capped), while the boot catalog stays ancestor+profile only, which is why a nested doc's `system-prompt-visibility` rung is inert (lint warns; set `none`).
+
 ## Ordering
 
 The boot render is structural, never a per-doc knob: docs group by rung (content bodies as prose, then previews, then names), and within a group order general-to-specific — scope first (builtin → user → profile → outermost project root → nearest), then tree position (higher directories before deeper), then filename. A numeric `NN-` filename prefix (stripped from the doc's name) is the sparing escape hatch when an exact sequence must be pinned.

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

@@ -30,7 +30,7 @@ async function summarizedGroup(messages, key) {
         stats: {},
         state: { isStreaming: false },
         toolGroupSummaries: {
-            [key]: { bullets: ['broker recap'], nodesSpawned: 0, filesDeleted: 0 },
+            [key]: { bullets: ['broker recap'], filesDeleted: 0 },
         },
     });
     const group = internals.groups.find((candidate) => candidate.key === key);
@@ -70,7 +70,7 @@ test('a folded recap carries paths and counts, never diff or write payload bodie
         bashMode: tone('bashMode'), bashModeAlt: tone('bashModeAlt'),
     };
     const recap = new GroupRecapComponent();
-    recap.setRecap({ bullets: ['finished'], nodesSpawned: 0, filesDeleted: 2 }, 2, { memories: [{ action: 'read', name: 'alpha', path: '/tmp/memories/alpha.md' }], files: recorder.activity().files }, true, palette);
+    recap.setRecap({ bullets: ['finished'], filesDeleted: 2 }, 2, { memories: [{ action: 'read', name: 'alpha', path: '/tmp/memories/alpha.md' }], files: recorder.activity().files, nodes: [] }, true, palette);
     const text = recap.render(120).join('\n');
     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');

package/dist/clients/attach/__tests__/titled-editor-paste.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/titled-editor-paste.test.js

@@ -0,0 +1,114 @@
+// titled-editor-paste.test.ts — regression for the unbracketed multi-line paste
+// bug: a multi-line paste into the attach viewer submitted its FIRST line as a
+// prompt, then turned every following line into its own turn, a queued steering
+// message, or a "Agent is already processing" rejection.
+//
+// Root cause: when a terminal delivers a paste WITHOUT bracketed-paste markers,
+// pi-tui's StdinBuffer never enters paste mode and splits the paste into single
+// sequences, so each embedded line ending reaches the editor as a bare Enter and
+// the stock editor submits on it. TitledEditor.handleInput holds a line ending
+// for PASTE_BURST_MS and settles it on what FOLLOWS: more input means a paste's
+// own line break (insert a newline), silence means a human pressed Enter
+// (submit).
+//
+// Deciding on what follows — not on the gap before — is what keeps
+// `tmux send-keys <text> Enter` (one write, so its Enter arrives microseconds
+// after the text) submitting, which the earlier gap-based rescue broke. Both
+// properties are pinned below.
+//
+// The tests drive handleInput directly, bypassing the heavy TUI/stdin
+// constructor via Object.create and stubbing only the members the branch
+// touches; `super.handleInput` is intercepted by replacing
+// CustomEditor.prototype.handleInput (what the ES `super` call resolves to).
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { setTimeout as delay } from 'node:timers/promises';
+import { CustomEditor } from '@earendil-works/pi-coding-agent';
+import { TitledEditor } from '../input/titled-editor.js';
+/** Longer than PASTE_BURST_MS (10ms) — the hold window must have expired. */
+const AFTER_HOLD_MS = 40;
+/** A TitledEditor with its constructor bypassed and its collaborators stubbed:
+ *  - `km.matches` recognizes only the real Enter (`\r`) as `tui.input.submit`
+ *    and never the newLine chord (so that branch stays out of the way);
+ *  - `isShowingAutocomplete` is always false;
+ *  - `insertTextAtCursor` records inserts;
+ *  - the inherited (super) handleInput records what would have been submitted. */
+function makeHarness() {
+    const inserted = [];
+    const submitted = [];
+    const editor = Object.create(TitledEditor.prototype);
+    Object.assign(editor, {
+        km: {
+            matches: (data, binding) => binding === 'tui.input.submit' ? data === '\r' : false,
+        },
+        tui: { requestRender: () => { } },
+        isShowingAutocomplete: () => false,
+        insertTextAtCursor: (s) => inserted.push(s),
+        getCursor: () => ({ line: 0, col: 0 }),
+        getLines: () => [''],
+        maybeTriggerNonLeadingRefAutocomplete: () => { },
+    });
+    const originalSuper = CustomEditor.prototype.handleInput;
+    // `super.handleInput(data)` inside TitledEditor resolves to this prototype
+    // method; the stock editor SUBMITS a bare `\r`, so record that as a submit.
+    CustomEditor.prototype.handleInput = function (data) {
+        if (data === '\r' || data === '\n')
+            submitted.push(data);
+    };
+    return { editor, inserted, submitted, restore: () => { CustomEditor.prototype.handleInput = originalSuper; } };
+}
+test('unbracketed multi-line paste becomes newlines, never a mid-paste submit', async () => {
+    const { editor, inserted, submitted, restore } = makeHarness();
+    try {
+        // A paste floods handleInput synchronously: "line1\rline2\rline3".
+        for (const ch of ['l', 'i', 'n', 'e', '1', '\r', 'l', 'i', 'n', 'e', '2', '\r', 'l', 'i', 'n', 'e', '3']) {
+            editor.handleInput(ch);
+        }
+        await delay(AFTER_HOLD_MS);
+        assert.equal(inserted.filter((s) => s === '\n').length, 2, 'both pasted returns became newlines');
+        assert.equal(submitted.length, 0, 'no submit fired mid-paste — the full paste survives');
+    }
+    finally {
+        restore();
+    }
+});
+test('an unbracketed paste ending in a newline submits ONCE, carrying the whole block', async () => {
+    const { editor, inserted, submitted, restore } = makeHarness();
+    try {
+        for (const ch of ['a', '\n', 'b', '\n'])
+            editor.handleInput(ch);
+        await delay(AFTER_HOLD_MS);
+        assert.equal(inserted.filter((s) => s === '\n').length, 1, 'the interior line feed became a newline');
+        assert.equal(submitted.length, 1, 'only the trailing line feed submitted, with both lines in the editor');
+    }
+    finally {
+        restore();
+    }
+});
+test('a human Enter submits', async () => {
+    const { editor, inserted, submitted, restore } = makeHarness();
+    try {
+        editor.handleInput('\r');
+        await delay(AFTER_HOLD_MS);
+        assert.equal(submitted.length, 1, 'a pressed Enter submits');
+        assert.equal(inserted.length, 0, 'a pressed Enter does not insert a newline');
+    }
+    finally {
+        restore();
+    }
+});
+test('text and Enter delivered in one write (tmux send-keys) still submits', async () => {
+    const { editor, inserted, submitted, restore } = makeHarness();
+    try {
+        // `tmux send-keys -t <pane> '/graph' Enter` flushes both in a single write,
+        // so the Enter arrives microseconds after the text — with nothing after it.
+        for (const ch of ['/', 'g', 'r', 'a', 'p', 'h', '\r'])
+            editor.handleInput(ch);
+        await delay(AFTER_HOLD_MS);
+        assert.equal(submitted.length, 1, 'the trailing Enter of a send-keys burst submits');
+        assert.equal(inserted.length, 0, 'nothing was turned into a newline');
+    }
+    finally {
+        restore();
+    }
+});

package/dist/clients/attach/__tests__/titled-editor-preview.test.js

@@ -66,7 +66,7 @@ test('Enter-confirming a non-leading ref completion accepts the token and return
     assert.equal(editor.getText(), 'hey check /dev', 'the token was replaced in place, not submitted as typed');
     assert.equal(submitted, undefined, 'Enter-confirming a ref completion must never submit the message');
 });
-test('a real Enter submission preserves raw leading/trailing whitespace end-to-end', () => {
+test('a real Enter submission preserves raw leading/trailing whitespace end-to-end', async () => {
     const editor = makeEditor();
     let submitted;
     editor.onSubmit = (text) => {
@@ -74,6 +74,9 @@ test('a real Enter submission preserves raw leading/trailing whitespace end-to-e
     };
     editor.setText('  hello world  ');
     editor.handleInput('\r'); // real Enter keystroke — tui.input.submit
+    // The unbracketed-paste rescue holds a line ending for PASTE_BURST_MS to see
+    // whether more input follows it (a paste's own line break) before submitting.
+    await new Promise((resolve) => setTimeout(resolve, 40));
     assert.equal(submitted, '  hello world  ', 'onSubmit receives the exact untrimmed text, not the base editor\'s trimmed copy');
     assert.equal(editor.getText(), '', 'submitValue still resets editor state as usual');
 });

package/dist/clients/attach/input/titled-editor.d.ts

@@ -84,6 +84,17 @@ export declare class TitledEditor extends CustomEditor {
      *  converted to an accessor below whose getter always returns our substitution
      *  wrapper, not this value directly. */
     private realOnSubmit;
+    /** A line ending held back to learn whether more input follows it within
+     *  `PASTE_BURST_MS` — see `handleInput`'s unbracketed-paste rescue. More input
+     *  means it was a line break inside a paste (insert a newline); silence means
+     *  a human pressed Enter (submit). */
+    private pendingReturn;
+    /** How long a line ending is held before it counts as a real Enter. An
+     *  unbracketed paste floods `handleInput` within one event-loop tick, so its
+     *  next character always lands far inside this window; a human's next
+     *  keystroke after Enter is ~30ms+ away at the very fastest. Short enough that
+     *  the added submit latency is imperceptible. */
+    private static readonly PASTE_BURST_MS;
     constructor(tui: TUI, theme: EditorTheme, keybindings: ConstructorParameters<typeof CustomEditor>[2], options?: EditorOptions);
     /** Insert a newline on the newLine chord (Alt+Enter / Shift+Enter) using crtr's
      *  OWN keybindings manager, then defer everything else to the stock editor.
@@ -101,6 +112,13 @@ export declare class TitledEditor extends CustomEditor {
      *  the terminal delivers as bracketed-paste TEXT, not an image event). Returns
      *  true when it consumed the drop, so the raw path is never inserted as text. */
     onPasteImagePath?: (path: string) => boolean;
+    /** Settle a line ending held by the unbracketed-paste rescue. `'newline'` (more
+     *  input arrived, so it was a paste's own line break) inserts it in place;
+     *  `'submit'` (the hold window expired in silence, so a human pressed Enter)
+     *  replays it through the stock editor and repaints, because this runs outside
+     *  the TUI's own post-`handleInput` render request. No-op when nothing is
+     *  held. */
+    private settleHeldReturn;
     /** Width of an `[Image #N]` token sitting immediately before the cursor on the
      *  current line, or 0 when the cursor isn't at the end of such a token — used to
      *  delete/skip the token atomically. The token's separating space is a normal,

package/dist/clients/attach/input/titled-editor.js

@@ -441,6 +441,17 @@ export class TitledEditor extends CustomEditor {
      *  converted to an accessor below whose getter always returns our substitution
      *  wrapper, not this value directly. */
     realOnSubmit;
+    /** A line ending held back to learn whether more input follows it within
+     *  `PASTE_BURST_MS` — see `handleInput`'s unbracketed-paste rescue. More input
+     *  means it was a line break inside a paste (insert a newline); silence means
+     *  a human pressed Enter (submit). */
+    pendingReturn;
+    /** How long a line ending is held before it counts as a real Enter. An
+     *  unbracketed paste floods `handleInput` within one event-loop tick, so its
+     *  next character always lands far inside this window; a human's next
+     *  keystroke after Enter is ~30ms+ away at the very fastest. Short enough that
+     *  the added submit latency is imperceptible. */
+    static PASTE_BURST_MS = 10;
     // CustomEditor's ctor signature; captured so we own the newline chord (see
     // handleInput). The keybindings param is typed as pi's app-subclass manager,
     // but the attach viewer feeds it pi-tui's base manager — hence the cast.
@@ -507,6 +518,25 @@ export class TitledEditor extends CustomEditor {
      *  the terminal delivers as bracketed-paste TEXT, not an image event). Returns
      *  true when it consumed the drop, so the raw path is never inserted as text. */
     onPasteImagePath;
+    /** Settle a line ending held by the unbracketed-paste rescue. `'newline'` (more
+     *  input arrived, so it was a paste's own line break) inserts it in place;
+     *  `'submit'` (the hold window expired in silence, so a human pressed Enter)
+     *  replays it through the stock editor and repaints, because this runs outside
+     *  the TUI's own post-`handleInput` render request. No-op when nothing is
+     *  held. */
+    settleHeldReturn(as) {
+        const held = this.pendingReturn;
+        if (held === undefined)
+            return;
+        clearTimeout(held.timer);
+        this.pendingReturn = undefined;
+        if (as === 'newline') {
+            this.insertTextAtCursor('\n');
+            return;
+        }
+        super.handleInput(held.data);
+        this.tui.requestRender();
+    }
     /** Width of an `[Image #N]` token sitting immediately before the cursor on the
      *  current line, or 0 when the cursor isn't at the end of such a token — used to
      *  delete/skip the token atomically. The token's separating space is a normal,
@@ -531,6 +561,9 @@ export class TitledEditor extends CustomEditor {
         return match ? match[0].length : 0;
     }
     handleInput(data) {
+        // Any input arriving while a line ending is held settles it as a paste's own
+        // line break: insert it FIRST so this key lands after it, in typed order.
+        this.settleHeldReturn('newline');
         // Keep ↓ on the editor's native focused-input path. Only when its own
         // wrap-aware cursor and prompt-history navigation make no change does the
         // adjacent roster get a chance to take over.
@@ -590,6 +623,35 @@ export class TitledEditor extends CustomEditor {
         const droppedPath = detectDroppedImagePath(data);
         if (droppedPath && this.onPasteImagePath?.(droppedPath))
             return;
+        // Unbracketed multi-line paste rescue. When the terminal delivers a paste
+        // WITHOUT bracketed-paste markers (\x1b[200~ … \x1b[201~) — the outer
+        // terminal may not support them, or tmux attached its client with a terminfo
+        // entry lacking the Enbp/Dsbp caps — pi-tui's StdinBuffer never enters paste
+        // mode and instead splits the paste into single sequences. Each embedded
+        // line ending then reaches us as a bare Enter, and the stock editor SUBMITS
+        // on it: line one becomes a prompt and every following line becomes its own
+        // turn, is queued as steering, or is lost to pi's "Agent is already
+        // processing" rejection when it lands inside prompt()'s async preflight. The
+        // bracketed path (when markers DO arrive) is a single `\x1b[200~…` sequence
+        // that never trips this branch, so it stays fully intact.
+        //
+        // A pasted line break is told from a pressed Enter by what FOLLOWS it, not
+        // by what precedes it: a paste floods handleInput with its next character
+        // microseconds later, while an Enter is followed by human-scale silence.
+        // Deciding on the following input (rather than the preceding gap) is what
+        // keeps `tmux send-keys <text> Enter` — one write, so its Enter arrives
+        // microseconds after the text — submitting as intended, since nothing
+        // follows it. A paste that ends in a trailing newline likewise submits, by
+        // then carrying its WHOLE text, so no line is ever split off or lost.
+        // Skipped while the autocomplete popup is open, where Enter confirms a
+        // completion and must stay immediate.
+        if ((data === '\r' || data === '\n') && !this.isShowingAutocomplete()) {
+            this.pendingReturn = {
+                data,
+                timer: setTimeout(() => this.settleHeldReturn('submit'), TitledEditor.PASTE_BURST_MS),
+            };
+            return;
+        }
         const { line: beforeLine, col: beforeCol } = this.getCursor();
         const beforeText = this.getLines()[beforeLine] ?? '';
         super.handleInput(data);

package/dist/clients/attach/render/chat-view.d.ts

@@ -96,6 +96,9 @@ export declare class ChatView {
     private readonly groups;
     private openGroup;
     private readonly groupSummaries;
+    /** Node id → display name for every node spawned in this transcript, so a
+     *  later group's finish notice can name the child rather than its id. */
+    private readonly nodeRoster;
     private streamingWasGroupMember;
     private readonly onFooterEvent;
     /** Viewer hook that places activity in its fixed slot, when available. */

package/dist/clients/attach/render/chat-view.js

@@ -30,7 +30,7 @@ import { generatedContextExpandedBody, generatedContextPresentation, isRuntimeRe
 import { assistantVisibleText, isTrueUserMessage, } from '../../../shared/tool-groups.js';
 import { transformMessageDiagrams } from './diagram.js';
 import { transformMessageHtml } from './html-markdown.js';
-import { styleAttachMarkdownHeadings, styleAttachMessageMarkdown, styleAttachSummaryMarkdown, } from './markdown-headings.js';
+import { styleAttachMarkdownSource, styleAttachMessageMarkdown, styleAttachSummaryMarkdown, } from './markdown-source.js';
 import { createCrtrEditToolDefinition } from './edit-diff.js';
 import { GroupActivityRecorder } from './group-activity.js';
 import { GroupRecapComponent } from './group-recap.js';
@@ -290,6 +290,9 @@ export class ChatView {
     groups = [];
     openGroup;
     groupSummaries = new Map();
+    /** Node id → display name for every node spawned in this transcript, so a
+     *  later group's finish notice can name the child rather than its id. */
+    nodeRoster = new Map();
     streamingWasGroupMember = false;
     onFooterEvent;
     /** Viewer hook that places activity in its fixed slot, when available. */
@@ -1032,7 +1035,11 @@ export class ChatView {
                 this.appendExistingGroupMember(component);
             }
             else {
-                this.appendGroupMember(component);
+                const group = this.appendGroupMember(component);
+                // A child's final arrives as an inbox digest, not a tool call: without
+                // this the folded recap would hide the one row saying it finished.
+                if (generated.kind === 'inbox')
+                    group?.activity.noteInboxDigest(generated.body);
             }
             return;
         }
@@ -1104,18 +1111,18 @@ export class ChatView {
                     this.appendUserPart(new Spacer(1), !isTrueUserMessage(message));
                 const skillBlock = parseSkillBlock(textContent);
                 if (skillBlock) {
-                    const component = new SkillInvocationMessageComponent({ ...skillBlock, content: styleAttachMarkdownHeadings(skillBlock.content) }, attachMarkdownTheme());
+                    const component = new SkillInvocationMessageComponent({ ...skillBlock, content: styleAttachMarkdownSource(skillBlock.content) }, attachMarkdownTheme());
                     component.setExpanded(this.toolOutputExpanded);
                     this.appendUserPart(component, !isTrueUserMessage(message));
                     this.registerCopyBlock(component, 'user', textContent);
                     if (skillBlock.userMessage) {
-                        const userMessage = new UserMessageComponent(styleAttachMarkdownHeadings(skillBlock.userMessage), attachMarkdownTheme());
+                        const userMessage = new UserMessageComponent(styleAttachMarkdownSource(skillBlock.userMessage), attachMarkdownTheme());
                         this.appendUserPart(userMessage, !isTrueUserMessage(message));
                         this.registerCopyBlock(userMessage, 'user', skillBlock.userMessage);
                     }
                 }
                 else {
-                    const component = new UserMessageComponent(styleAttachMarkdownHeadings(textContent), attachMarkdownTheme());
+                    const component = new UserMessageComponent(styleAttachMarkdownSource(textContent), attachMarkdownTheme());
                     this.appendUserPart(component, !isTrueUserMessage(message));
                     this.registerCopyBlock(component, 'user', textContent);
                 }
@@ -1183,7 +1190,7 @@ export class ChatView {
         const group = {
             members: [],
             recap,
-            activity: new GroupActivityRecorder(this.cwd),
+            activity: new GroupActivityRecorder(this.cwd, this.nodeRoster),
             toolCount: 0,
             inFlight: new Set(),
         };
@@ -1203,6 +1210,7 @@ export class ChatView {
         this.append(component);
         if (group)
             group.members.push(component);
+        return group;
     }
     /** Used for context that may join an existing run but must not create one. */
     appendExistingGroupMember(component) {
@@ -1422,6 +1430,7 @@ export class ChatView {
         this.groups.length = 0;
         this.openGroup = undefined;
         this.groupSummaries.clear();
+        this.nodeRoster.clear();
         this.pendingTools.clear();
         this.lastAssistantText = undefined;
         this.copyBlockRecords.length = 0;

package/dist/clients/attach/render/context-message.js

@@ -11,7 +11,7 @@
 import { UserMessageComponent } from '@earendil-works/pi-coding-agent';
 import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
 import { attachMarkdownTheme } from '../config.js';
-import { styleAttachMarkdownHeadings } from './markdown-headings.js';
+import { styleAttachMarkdownSource } from './markdown-source.js';
 /** Default label/hint for the `crtr-context` bearings block. */
 const LABEL = 'crtr context';
 const COLLAPSED_HINT = ' orienting bearings — ctrl+o to expand';
@@ -30,7 +30,7 @@ export class ContextMessageComponent {
         this.collapsedHint = collapsedHint;
         this.expandsWithTools = expandsWithTools;
         this.expanded = expandsWithTools && expanded;
-        this.expandedBody = new UserMessageComponent(styleAttachMarkdownHeadings(body), attachMarkdownTheme());
+        this.expandedBody = new UserMessageComponent(styleAttachMarkdownSource(body), attachMarkdownTheme());
     }
     /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
     setExpanded(expanded) {

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

@@ -12,22 +12,39 @@ export type MemoryActivity = {
     name: string;
     path?: string;
 };
+/** One node this group started or saw finish. `name` is the spawn's display
+ * name, or the node id when the finish has no matching spawn in this session. */
+export type NodeActivity = {
+    action: 'spawned' | 'finished';
+    name: string;
+    id: string;
+};
 export type GroupActivity = {
     files: readonly FileActivity[];
     memories: readonly MemoryActivity[];
+    nodes: readonly NodeActivity[];
 };
 /** Per-group recorder. Calls retain only their current transcript references
  * until they settle; the settled activity is plain immutable evidence. */
 export declare class GroupActivityRecorder {
     private readonly cwd;
+    private readonly roster;
     private readonly calls;
     private readonly files;
     private readonly memories;
     private readonly memorySet;
-    constructor(cwd: string);
+    private readonly nodes;
+    private readonly nodeSet;
+    /** `roster` is the ChatView-wide node id → display name record: spawns fill
+     * it, and a later group's finish reads the name a sibling group recorded. */
+    constructor(cwd: string, roster?: Map<string, string>);
+    /** Record the nodes an inbox digest reports finished. The digest names senders
+     * by node id, so the spawn roster supplies the display name when it has one. */
+    noteInboxDigest(body: string): void;
     noteCall(id: string, name: string, args: unknown): void;
     settle(id: string, result: unknown, isError: boolean): void;
     resolveWithoutResult(id: string): void;
     activity(): GroupActivity;
+    private addNode;
     private extract;
 }

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

@@ -3,10 +3,12 @@
 // calls into the exact evidence already present in the session transcript.
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
+import { inboxFinishedSenders } from '../../../shared/generated-context.js';
 import { countDisplayDiffLines } from './edit-diff.js';
 const EMPTY_ACTIVITY = Object.freeze({
     files: Object.freeze([]),
     memories: Object.freeze([]),
+    nodes: Object.freeze([]),
 });
 function object(value) {
     return typeof value === 'object' && value !== null ? value : undefined;
@@ -77,7 +79,7 @@ function shellTokens(segment) {
 }
 /** Deliberately match an executable token, not a result-shaped string or a
  * quoted command fragment. */
-function invokesMemoryCommand(args, verb) {
+function invokesCrtrCommand(args, path) {
     const command = object(args)?.command;
     if (typeof command !== 'string')
         return false;
@@ -86,7 +88,9 @@ function invokesMemoryCommand(args, verb) {
         while (/^[A-Za-z_][A-Za-z0-9_]*=\S+$/.test(tokens[0] ?? ''))
             tokens.shift();
         const executable = tokens[0]?.split('/').at(-1);
-        return (executable === 'crtr' || executable === 'crouter') && tokens[1] === 'memory' && tokens[2] === verb;
+        if (executable !== 'crtr' && executable !== 'crouter')
+            return false;
+        return path.every((word, index) => tokens[index + 1] === word);
     });
 }
 /** A resolved read/write begins with the identity fields emitted by its leaf.
@@ -105,6 +109,19 @@ function resolvedMemories(result, action) {
     }
     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;
+}
 /** 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) {
@@ -132,12 +149,25 @@ function fileChange(name, args, result) {
  * until they settle; the settled activity is plain immutable evidence. */
 export class GroupActivityRecorder {
     cwd;
+    roster;
     calls = new Map();
     files = new Map();
     memories = [];
     memorySet = new Set();
-    constructor(cwd) {
+    nodes = [];
+    nodeSet = new Set();
+    /** `roster` is the ChatView-wide node id → display name record: spawns fill
+     * it, and a later group's finish reads the name a sibling group recorded. */
+    constructor(cwd, roster = new Map()) {
         this.cwd = cwd;
+        this.roster = roster;
+    }
+    /** Record the nodes an inbox digest reports finished. The digest names senders
+     * by node id, so the spawn roster supplies the display name when it has one. */
+    noteInboxDigest(body) {
+        for (const id of inboxFinishedSenders(body)) {
+            this.addNode({ action: 'finished', name: this.roster.get(id) ?? id, id });
+        }
     }
     noteCall(id, name, args) {
         const existing = this.calls.get(id);
@@ -163,16 +193,34 @@ export class GroupActivityRecorder {
         entry.args = undefined;
     }
     activity() {
-        if (this.files.size === 0 && this.memories.length === 0)
+        if (this.files.size === 0 && this.memories.length === 0 && this.nodes.length === 0)
             return EMPTY_ACTIVITY;
         const files = [...this.files.values()].map((file) => Object.freeze({ ...file }));
         const memories = this.memories.map((memory) => Object.freeze({ ...memory }));
-        return Object.freeze({ files: Object.freeze(files), memories: Object.freeze(memories) });
+        const nodes = this.nodes.map((node) => Object.freeze({ ...node }));
+        return Object.freeze({
+            files: Object.freeze(files),
+            memories: Object.freeze(memories),
+            nodes: Object.freeze(nodes),
+        });
+    }
+    addNode(node) {
+        const key = `${node.action}:${node.id}`;
+        if (this.nodeSet.has(key))
+            return;
+        this.nodeSet.add(key);
+        this.nodes.push(node);
+        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);
+            }
             for (const action of ['read', 'write']) {
-                if (!invokesMemoryCommand(entry.args, action))
+                if (!invokesCrtrCommand(entry.args, ['memory', action]))
                     continue;
                 for (const memory of resolvedMemories(result, action)) {
                     const key = `${action}:${memory.path ?? memory.name}`;

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

@@ -31,6 +31,9 @@ function countMemories(memories, action) {
 function distinctFileCount(files) {
     return new Set(files.map((file) => file.key)).size;
 }
+function countNodes(nodes, action) {
+    return nodes.filter((node) => node.action === action).length;
+}
 class RecapDetailLine {
     prefix;
     path;
@@ -56,6 +59,9 @@ export class GroupRecapComponent extends Container {
             return;
         this.addChild(new Spacer(1));
         if (detailed) {
+            for (const node of activity.nodes) {
+                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), ''));
@@ -69,8 +75,13 @@ export class GroupRecapComponent extends Container {
         }
         else {
             const stats = [toolCallCount];
-            if (summary.nodesSpawned >= 1) {
-                stats.push(`${palette.accent(ICON.graph)} ${palette.muted(count(summary.nodesSpawned, 'node spawned', 'nodes spawned'))}`);
+            const nodesSpawned = countNodes(activity.nodes, 'spawned');
+            if (nodesSpawned >= 1) {
+                stats.push(`${palette.accent(ICON.graph)} ${palette.muted(count(nodesSpawned, 'node spawned', 'nodes spawned'))}`);
+            }
+            const nodesFinished = countNodes(activity.nodes, 'finished');
+            if (nodesFinished >= 1) {
+                stats.push(`${palette.accent(ICON.graph)} ${palette.muted(count(nodesFinished, 'node finished', 'nodes finished'))}`);
             }
             const changedFiles = distinctFileCount(activity.files);
             if (changedFiles >= 1) {