@north-light/crouter 0.3.291 → 0.3.292

package/dist/clients/attach/__tests__/crtr-output.test.js

@@ -11,11 +11,11 @@ const theme = {
 };
 /** pi calls tool renderers with a shared state bag; a normal (unfolded) call has an empty one. */
 function renderCall(command) {
-    const definition = createCrtrBashToolDefinition({ command });
+    const definition = createCrtrBashToolDefinition({ command })?.definition;
     return definition.renderCall({ command }, theme, { state: {} }).render(80).join('\n');
 }
 function renderResult(command, text, expanded) {
-    const definition = createCrtrBashToolDefinition({ command });
+    const definition = createCrtrBashToolDefinition({ command })?.definition;
     return definition.renderResult({ content: [{ type: 'text', text }] }, { expanded }, theme, {}).render(70);
 }
 test('detects crtr in bash command position, not heredoc body prose', () => {
@@ -50,7 +50,7 @@ test('scopes -h/--help detection and the displayed path to the crtr invocation\'
 });
 test('crtr results do not invalidate their owning tool component', () => {
     let ownerInvalidations = 0;
-    const def = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard' });
+    const def = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard' })?.definition;
     const component = def.renderResult({ content: [{ type: 'text', text: 'dashboard' }] }, { expanded: false }, theme, { invalidate: () => { ownerInvalidations++; } });
     component.invalidate?.();
     assert.equal(ownerInvalidations, 0);

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

@@ -201,8 +201,8 @@ class MinimizableToolComponent extends ToolExecutionComponent {
     expandedState = false;
     foldController;
     resultObserver;
-    /** A foldable definition owns its folded call component; an edit definition
-     *  may also observe results before the imported shell renders them. */
+    /** A foldable definition owns its folded call component; it may also observe
+     *  results before the imported shell renders them. */
     setToolView(foldController, resultObserver) {
         this.foldController = foldController;
         this.resultObserver = resultObserver;
@@ -1387,7 +1387,14 @@ export class ChatView {
         let resultObserver;
         let toolDefinition;
         if (name === 'bash') {
-            toolDefinition = createCrtrBashToolDefinition(args, fold) ?? createCrtrPlainBashToolDefinition(this.cwd, fold, this.backgroundBashHint);
+            const crtr = createCrtrBashToolDefinition(args, fold);
+            if (crtr === undefined) {
+                toolDefinition = createCrtrPlainBashToolDefinition(this.cwd, fold, this.backgroundBashHint);
+            }
+            else {
+                toolDefinition = crtr.definition;
+                resultObserver = crtr.observeResult;
+            }
         }
         else if (name === 'edit') {
             const edit = createCrtrEditToolDefinition(this.cwd, fold);

package/dist/clients/attach/render/crtr-output.d.ts

@@ -1,5 +1,5 @@
 import { Box } from '@earendil-works/pi-tui';
-import { FoldedToolCallController } from './tool-calls.js';
+import { FoldedToolCallController, type ToolResultObserver } from './tool-calls.js';
 type Theme = {
     fg: (name: string, text: string) => string;
     bg: (name: string, text: string) => string;
@@ -45,5 +45,9 @@ export declare class CrtrOutputMessageComponent extends Box {
     constructor(content: string, expanded: boolean, theme: Theme);
     setExpanded(expanded: boolean): void;
 }
-export declare function createCrtrBashToolDefinition(args: unknown, fold?: FoldedToolCallController): unknown | undefined;
+export type CrtrBashToolView = {
+    definition: unknown;
+    observeResult: ToolResultObserver;
+};
+export declare function createCrtrBashToolDefinition(args: unknown, fold?: FoldedToolCallController): CrtrBashToolView | undefined;
 export {};

package/dist/clients/attach/render/crtr-output.js

@@ -1,6 +1,8 @@
 import { truncateToVisualLines } from '@earendil-works/pi-coding-agent';
 import { Box, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
-import { HELP_ICON, iconForPath, suppressOutputForPath, summarizePath, } from '../../../core/preview-registry.js';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { crtrPreviewRecords, HELP_ICON, iconForPath, suppressOutputForPath, summarizePath, } from '../../../core/preview-registry.js';
+import { parseSurfaces } from '../../../core/substrate/schema.js';
 import { FoldedToolCallController } from './tool-calls.js';
 // Hard cap on a collapsed crtr card's total rendered lines (rule 12,
 // inline-ui-placement): help synthesis or a normal truncated result never
@@ -152,6 +154,141 @@ function commandFromArgs(args) {
 const CRTR_FLAG_TOKEN = /^-{1,2}[A-Za-z0-9]/;
 const CRTR_ATTACHED_FLAG_VALUE = /^(--?[A-Za-z0-9][^=]*)(=)(.*)$/;
 const CRTR_NUMBER_VALUE = /^-?(?:\d+(?:\.\d+)?|\.\d+)$/;
+// Memory routing
+//
+// `memory write` and `memory edit` decide who sees a document, when, and at what
+// context cost. Folded, their argv is a wall of frontmatter flags that wraps over
+// several rows, so the row states the routing itself instead: the scope the
+// document landed in, its gate, its surface entries with the rung each delivers
+// at, and its `when-and-why-to-read` line.
+//
+// The frontmatter flags are in the invocation's own argv — the same text the
+// write copies verbatim into the document. `scope` is not a flag: the selector
+// rules resolve it, and the leaf reports it in its RESULT. The result is
+// reachable here because this definition observes every settled tool result
+// (`observeResult`), which runs before a fold hides the result record.
+const MEMORY_ROUTING_LEAVES = new Set(['memory write', 'memory edit']);
+/** Every value the invocation passed for one flag, in either spelling
+ *  (`--flag value`, `--flag=value`). A flag left without a value takes the next
+ *  flag token as its own, so the separated spelling only claims a non-flag. */
+function crtrFlagValues(tokens, flag) {
+    const attached = `--${flag}=`;
+    const values = [];
+    tokens.forEach((token, index) => {
+        if (token === `--${flag}`) {
+            const value = tokens[index + 1];
+            if (value !== undefined && !CRTR_FLAG_TOKEN.test(value))
+                values.push(value);
+            return;
+        }
+        if (token.startsWith(attached))
+            values.push(token.slice(attached.length));
+    });
+    return values;
+}
+function crtrFlagValue(tokens, flag) {
+    return crtrFlagValues(tokens, flag)[0];
+}
+function parsedYaml(raw) {
+    try {
+        return parseYaml(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A predicate printed the way it is authored on the command line: one-line
+ *  YAML flow. Anything that is not a field→matcher map is shown as typed. */
+function predicateText(raw) {
+    const parsed = parsedYaml(raw);
+    return parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)
+        ? raw.trim()
+        : stringifyYaml(parsed, { collectionStyle: 'flow', flowCollectionPadding: false, lineWidth: 0 }).trim();
+}
+function predicateValueText(value) {
+    return stringifyYaml(value, { collectionStyle: 'flow', flowCollectionPadding: false, lineWidth: 0 }).trim();
+}
+function stringField(record, field) {
+    const value = record?.[field];
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}
+/** The routing a `memory write`/`memory edit` invocation states, or undefined
+ *  for every other leaf. The result record is authoritative where it speaks:
+ *  it carries the scope the selector rules chose and the resolved canonical
+ *  name, which composes the store's namespace onto the name that was passed. */
+function memoryRouting(tokens, records) {
+    const leaf = tokens.slice(0, 2).join(' ');
+    if (!MEMORY_ROUTING_LEAVES.has(leaf))
+        return undefined;
+    const positional = tokens[2] !== undefined && !CRTR_FLAG_TOKEN.test(tokens[2]) ? tokens[2] : undefined;
+    // One bash call may run several crtr invocations; the row shows the first, so
+    // it reads the first record this leaf produced.
+    const result = records.find((record) => record.path === leaf)?.result;
+    const gate = crtrFlagValue(tokens, 'gate');
+    return {
+        leaf,
+        name: stringField(result, 'name') ?? positional ?? '',
+        scope: stringField(result, 'scope') ?? crtrFlagValue(tokens, 'scope'),
+        gate: gate === undefined ? undefined : predicateText(gate),
+        surfaces: parseSurfaces(crtrFlagValues(tokens, 'surface').map(parsedYaml)),
+        whenAndWhyToRead: crtrFlagValue(tokens, 'when-and-why-to-read'),
+    };
+}
+/** How much of the document the entry delivers, toned by how much context it
+ *  costs every agent it reaches. */
+function rungTone(rung) {
+    return rung === 'content' ? 'warning' : rung === 'preview' ? 'accent' : 'muted';
+}
+/** One `surfaces` entry in its authored key order: the event, what it matches,
+ *  the predicates that narrow it, and the rung it delivers at. */
+function surfaceEntryText(entry, theme) {
+    const constraints = [entry.on];
+    if (entry.match !== undefined)
+        constraints.push(entry.match.join(' '));
+    if (entry.matchFrontmatter !== undefined)
+        constraints.push(`match-frontmatter ${predicateValueText(entry.matchFrontmatter)}`);
+    if (entry.gate !== undefined)
+        constraints.push(`gate ${predicateValueText(entry.gate)}`);
+    return `${theme.fg('text', constraints.join(' '))} ${theme.fg('dim', 'at')} ${theme.fg(rungTone(entry.at), entry.at)}`;
+}
+function labelledFact(label, value, theme) {
+    return `${theme.fg('dim', label)} ${value}`;
+}
+/** The routing block under the folded call's header line: scope and gate
+ *  together, then the surface entries, then the routing line. A fact the
+ *  invocation does not state is left out rather than shown as empty. */
+function memoryRoutingLines(routing, theme) {
+    const indent = '  ';
+    const lines = [];
+    const placement = [];
+    if (routing.scope !== undefined)
+        placement.push(labelledFact('scope', theme.fg('text', routing.scope), theme));
+    if (routing.gate !== undefined)
+        placement.push(labelledFact('gate', theme.fg('text', routing.gate), theme));
+    if (placement.length > 0)
+        lines.push(`${indent}${placement.join(theme.fg('dim', ' · '))}`);
+    const surfaces = routing.surfaces.length === 0
+        ? theme.fg('muted', 'none')
+        : routing.surfaces.map((entry) => surfaceEntryText(entry, theme)).join(theme.fg('dim', ', '));
+    lines.push(`${indent}${labelledFact('surface', surfaces, theme)}`);
+    if (routing.whenAndWhyToRead !== undefined) {
+        lines.push(`${indent}${labelledFact('when-and-why-to-read', theme.fg('text', routing.whenAndWhyToRead), theme)}`);
+    }
+    return lines;
+}
+/** A folded call that states more than one line. Every line is clipped to the
+ *  pane, never wrapped: the viewer's frame length depends on a folded call
+ *  painting exactly the rows it reports. */
+class FoldedCrtrCallComponent {
+    lines;
+    constructor(lines) {
+        this.lines = lines;
+    }
+    invalidate() { }
+    render(width) {
+        return this.lines.map((line) => truncateToWidth(line, width, '…'));
+    }
+}
 /** Syntax-color flags and their values while leaving the command path and
  * positional arguments in the folded row's existing bold title style. */
 function styleFoldedCrtrTokens(tokens, theme) {
@@ -182,17 +319,6 @@ function resultText(result) {
         .join('\n')
         .trimEnd();
 }
-/** The canvas preview extension attaches the CLI's exact result record here.
- * This deliberately validates only the transport envelope; command-owned
- * summaries validate the fields they use in preview-registry.ts. */
-function previewFromDetails(details) {
-    if (details === null || typeof details !== 'object')
-        return undefined;
-    const preview = details['crtrPreview'];
-    if (preview === null || typeof preview !== 'object' || typeof preview['path'] !== 'string')
-        return undefined;
-    return preview;
-}
 function styledLabelValue(indent, marker, label, separator, value, theme) {
     const styledMarker = marker === '' ? '' : theme.fg('accent', marker);
     return `${indent}${styledMarker}${theme.fg('dim', label)}${theme.fg('dim', separator)}${theme.fg('text', value)}`;
@@ -700,7 +826,15 @@ export function createCrtrBashToolDefinition(args, fold = new FoldedToolCallCont
     const command = commandFromArgs(args);
     if (!isCrtrBashCommand(command))
         return undefined;
-    return {
+    // The invocations' own result records, kept from the settled tool result so a
+    // folded row can still state a fact the argv does not carry.
+    let records = [];
+    const observeResult = (result, isPartial) => {
+        if (isPartial)
+            return;
+        records = crtrPreviewRecords(result);
+    };
+    const definition = {
         name: 'bash',
         label: 'bash',
         description: 'Render crtr bash output with crtr-specific chrome in the attach viewer.',
@@ -719,13 +853,23 @@ export function createCrtrBashToolDefinition(args, fold = new FoldedToolCallCont
             const icon = isHelp ? HELP_ICON : iconForPath(pathTokens);
             const prefix = isHelp ? `${icon} crtr help` : `${icon} crtr`;
             const styledPrefix = theme.fg('accent', theme.bold(prefix));
+            // A memory write/edit folds to its routing, not to its flag dump: the
+            // fold is what the human scans, and these flags are the document's whole
+            // reach.
+            const routing = fold.folded && !isHelp ? memoryRouting(pathTokens, records) : undefined;
+            if (routing !== undefined) {
+                const named = routing.name === '' ? '' : ` ${theme.fg('toolTitle', theme.bold(routing.name))}`;
+                const header = `${styledPrefix} ${theme.fg('toolTitle', theme.bold(routing.leaf))}${named}`;
+                return fold.capture(new FoldedCrtrCallComponent([header, ...memoryRoutingLines(routing, theme)]));
+            }
             const styledPath = path
                 ? ` ${fold.folded ? styleFoldedCrtrTokens(pathTokens, theme) : theme.fg('toolTitle', theme.bold(path))}`
                 : '';
             return fold.capture(new Text(`${styledPrefix}${styledPath}`, 0, 0));
         },
         renderResult(result, options, theme, context) {
-            return new CrtrResultComponent(resultText(result), options, context, theme, command, DEFAULT_PREVIEW_STATE, previewFromDetails(result.details));
+            return new CrtrResultComponent(resultText(result), options, context, theme, command, DEFAULT_PREVIEW_STATE, crtrPreviewRecords(result).at(-1));
         },
     };
+    return { definition, observeResult };
 }

package/dist/clients/attach/render/edit-diff.d.ts

@@ -1,18 +1,7 @@
-import { FoldedToolCallController, type FileLineChanges } from './tool-calls.js';
-type ToolResultLike = {
-    content?: Array<{
-        type?: unknown;
-        text?: unknown;
-    }>;
-    details?: {
-        diff?: unknown;
-    };
-    isError?: boolean;
-};
-export type EditResultObserver = (result: ToolResultLike, isPartial: boolean) => void;
+import { FoldedToolCallController, type FileLineChanges, type ToolResultObserver } from './tool-calls.js';
 export type CrtrEditToolView = {
     definition: unknown;
-    observeResult: EditResultObserver;
+    observeResult: ToolResultObserver;
 };
 /** Count only changed rows in pi's display diff; context and ellipsis rows do
  *  not contribute to the folded file summary. */
@@ -21,4 +10,3 @@ export declare function countDisplayDiffLines(diff: string): FileLineChanges;
  *  card has two explicit phases: streamed argument diff, then executed result
  *  diff. No asynchronous preview can write after settlement. */
 export declare function createCrtrEditToolDefinition(cwd: string, fold?: FoldedToolCallController): CrtrEditToolView;
-export {};

package/dist/clients/attach/render/edit-diff.js

@@ -266,7 +266,10 @@ export function createCrtrEditToolDefinition(cwd, fold = new FoldedToolCallContr
             return;
         state.settled = true;
         state.isError = result.isError === true;
-        const resultDiff = result.details?.diff;
+        const details = result.details;
+        const resultDiff = details !== null && typeof details === 'object'
+            ? details.diff
+            : undefined;
         state.diff = !state.isError && typeof resultDiff === 'string' ? resultDiff : undefined;
     };
     const definition = {

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

@@ -3,6 +3,7 @@
 // calls into the exact evidence already present in the session transcript.
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
+import { crtrPreviewRecords } from '../../../core/preview-registry.js';
 import { countDisplayDiffLines } from './edit-diff.js';
 /** Distinct event lines one recap will show before it starts counting. */
 const MAX_RECAP_EVENTS = 3;
@@ -27,27 +28,6 @@ function lineCount(content) {
         return 0;
     return (content.match(/\n/g)?.length ?? 0) + (content.endsWith('\n') ? 0 : 1);
 }
-/** 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']) }];
-    });
-}
 function text(value) {
     return typeof value === 'string' && value !== '' ? value : undefined;
 }
@@ -250,7 +230,7 @@ export class GroupActivityRecorder {
     }
     extract(entry, result) {
         if (entry.name === 'bash') {
-            for (const invocation of crtrPreviews(result))
+            for (const invocation of crtrPreviewRecords(result))
                 this.noteCrtrInvocation(invocation);
             return;
         }

package/dist/clients/attach/render/tool-calls.d.ts

@@ -6,6 +6,21 @@ type Theme = {
 /** Per-tool fold state owned by the attach viewer. Tool definitions capture the
  *  call component they render while folded, so the viewer never reaches into
  *  `ToolExecutionComponent`'s private renderer fields to recover it. */
+/** A settled tool result on its way to the transcript. `MinimizableToolComponent`
+ *  hands it to a definition's observer BEFORE the imported shell renders it, so a
+ *  definition whose folded call row states a fact from the result (an edit's
+ *  changed-line counts, a memory write's scope) still has that fact once the fold
+ *  renders instead of the result record — on the live stream and on a rebuilt
+ *  transcript alike. */
+export type ObservedToolResult = {
+    content?: Array<{
+        type?: unknown;
+        text?: unknown;
+    }>;
+    details?: unknown;
+    isError?: boolean;
+};
+export type ToolResultObserver = (result: ObservedToolResult, isPartial: boolean) => void;
 export declare class FoldedToolCallController {
     folded: boolean;
     private component;

package/dist/clients/attach/render/tool-calls.js

@@ -36,9 +36,6 @@ function backgroundHintLines(theme, startedAt, hint, width) {
         return [];
     return [truncateToWidth(`  ${theme.fg('muted', `⧗ ${text}`)}`, width, '…')];
 }
-/** Per-tool fold state owned by the attach viewer. Tool definitions capture the
- *  call component they render while folded, so the viewer never reaches into
- *  `ToolExecutionComponent`'s private renderer fields to recover it. */
 export class FoldedToolCallController {
     folded = false;
     component;