@north-light/api 0.3.580 → 0.3.587

package/dist/clients/attach/render/diagram.d.ts

@@ -0,0 +1,4 @@
+/** Cheap predicate for a fence that this viewer can turn into a diagram. */
+export declare function textHasDiagram(text: string): boolean;
+/** Replace every supported complete fence in `text` with its rendered diagram. */
+export declare function transformDiagramFences(text: string, width: number): string;

package/dist/clients/attach/render/diagram.js

@@ -0,0 +1,111 @@
+// render/diagram.ts — inline process-diagram rendering for assistant messages
+// in the `crtr surface attach` viewer.
+//
+// Mermaid fences and compact three-stage Unicode-arrow text fences both become
+// box-drawing diagrams before the text reaches pi's markdown renderer, so the
+// viewer shows the process rather than source syntax.
+//
+// How it stays simple:
+//   • The rendered lines are spliced back into markdown inside a plain ``` code
+//     fence, and pi's Markdown shows a fence body VERBATIM — no re-wrapping, and
+//     ANSI escapes pass through to the terminal unchanged. That pass-through is
+//     what the splice depends on, because mermaid output is NOT escape-free:
+//     since termrender 4.12.9 an emphasis tag in a node or edge label (`<b>`,
+//     `<strong>`, `<i>`, `<em>`) renders as a real ANSI run. Verified on screen
+//     — an emphasized label arrives bold, with its box borders still aligned.
+//   • So treat these lines as STYLED text, not plain text. termrender already
+//     sized every box off the visible glyphs, so anything here that measures,
+//     truncates, or pads a rendered line must be escape-aware or it will
+//     silently reintroduce the misalignment termrender just removed. The
+//     trailing-whitespace trim below is safe only because termrender closes a
+//     run before the cell padding that follows it.
+//   • `renderMarkdown` (crouter's sole org-wide termrender binding) is
+//     synchronous and memoized, so this is a plain string→string transform with
+//     no async swap or component lifecycle.
+//
+// Scope: Mermaid and a single-line `text`/`plain`/untagged Unicode-arrow chain.
+// The wider termrender directive vocabulary remains out of scope — see the base
+// prompt's Diagrams note.
+import { ensureRenderer, isRendererReady, renderMarkdown } from '../../../core/termrender/termrender.js';
+/** A complete Mermaid fence, including normal Markdown's optional three-space
+ *  indentation. Line-anchored (m flag), non-greedy body (captured). An unclosed
+ *  fence (still streaming) does not match, so mid-stream text is left raw and
+ *  only settles to a diagram once the closing ``` arrives. */
+const MERMAID_FENCE = /^[ \t]{0,3}```mermaid[^\n]*\n([\s\S]*?)\n[ \t]{0,3}```[ \t]*$/gm;
+const ARROW_CHAIN_FENCE = /^```(?:text|plain|plaintext)?[ \t]*\n([^\n]+)\n```[ \t]*$/gim;
+const ARROW_CHAIN_FENCE_TEST = /^```(?:text|plain|plaintext)?[ \t]*\n[^\n]+\n```[ \t]*$/im;
+const ARROW_CHAIN_SPLIT = /\s*(?:→|⟶|⇒|⟹)\s*/;
+const CODE_PUNCTUATION = /[=;{}\[\]`]/;
+/** Box-drawing, block-element, and geometric-shape ranges — the glyphs a real
+ *  mermaid-ascii render is made of. Their PRESENCE distinguishes a rendered
+ *  diagram from termrender's silent plaintext fallback, which echoes the mermaid
+ *  SOURCE verbatim (pure ASCII: `-->`, `[ ]`, `{ }`) when mermaid-ascii cannot
+ *  parse the diagram (e.g. an indented body, an unsupported node shape). */
+const DIAGRAM_GLYPH = /[\u2500-\u259F\u25A0-\u25FF]/;
+/** Strip the common leading indentation shared by every non-blank body line.
+ *  Agents routinely indent a fenced block to sit under a list item or heading,
+ *  and mermaid-ascii FAILS on a leading-indented `flowchart`/`graph` line —
+ *  dedenting first is what turns that common case from a fallback back into a
+ *  real diagram. */
+function dedent(body) {
+    const lines = body.split('\n');
+    let min = Infinity;
+    for (const line of lines) {
+        if (line.trim() === '')
+            continue;
+        min = Math.min(min, line.length - line.replace(/^[ \t]+/, '').length);
+    }
+    if (!Number.isFinite(min) || min === 0)
+        return body;
+    return lines.map((line) => (line.trim() === '' ? '' : line.slice(min))).join('\n');
+}
+/** Cheap predicate for a fence that this viewer can turn into a diagram. */
+export function textHasDiagram(text) {
+    return text.includes('```mermaid') || ARROW_CHAIN_FENCE_TEST.test(text);
+}
+/** Turn a terse process chain into the Mermaid flowchart termrender accepts. */
+function arrowChainToMermaid(body) {
+    const stages = body.trim().split(ARROW_CHAIN_SPLIT).map((stage) => stage.trim());
+    if (stages.length < 3 || stages.some((stage) => !stage || CODE_PUNCTUATION.test(stage)))
+        return null;
+    const nodes = stages.map((stage, index) => `chain_${index}[${JSON.stringify(stage)}]`);
+    const edges = stages.slice(1).map((_, index) => `chain_${index} --> chain_${index + 1}`);
+    return ['flowchart LR', ...nodes, ...edges].join('\n');
+}
+function stripBlankEdges(lines) {
+    let start = 0;
+    let end = lines.length;
+    while (start < end && lines[start].trim() === '')
+        start++;
+    while (end > start && lines[end - 1].trim() === '')
+        end--;
+    return lines.slice(start, end);
+}
+/** Render a Mermaid source into a plain fence pi preserves as aligned monospace. */
+function renderDiagram(whole, source, width) {
+    try {
+        const doc = `\`\`\`mermaid\n${dedent(source)}\n\`\`\``;
+        const rendered = stripBlankEdges(renderMarkdown(doc, width).map((line) => line.replace(/\s+$/, '')));
+        // No diagram glyphs means termrender echoed unsupported source. Preserve the
+        // original fence rather than replacing it with an unlabelled code block.
+        if (rendered.length === 0 || !rendered.some((line) => DIAGRAM_GLYPH.test(line)))
+            return whole;
+        return ['```', ...rendered, '```'].join('\n');
+    }
+    catch {
+        return whole;
+    }
+}
+/** Replace every supported complete fence in `text` with its rendered diagram. */
+export function transformDiagramFences(text, width) {
+    if (!textHasDiagram(text))
+        return text;
+    ensureRenderer();
+    if (!isRendererReady())
+        return text;
+    const mermaidRendered = text.replace(MERMAID_FENCE, (whole, body) => renderDiagram(whole, body, width));
+    return mermaidRendered.replace(ARROW_CHAIN_FENCE, (whole, body) => {
+        const source = arrowChainToMermaid(body);
+        return source === null ? whole : renderDiagram(whole, source, width);
+    });
+}

package/dist/clients/attach/render/doc-links.d.ts

@@ -0,0 +1,36 @@
+/** What the renderer needs from the viewer. Every call is synchronous and reads
+ *  live viewer state; a miss may schedule a fetch that re-renders later. */
+export interface DocLinkContext {
+    /** The node this viewer is attached to. */
+    selfNodeId: string;
+    /** A node's display name, when known. */
+    nodeName(nodeId: string): string | undefined;
+    /** The browser URL of a document ref, absent on remote attach. */
+    urlFor(ref: string): string | undefined;
+}
+/** Bumped whenever a document name or path lands, so a surface that holds
+ *  rendered Markdown (the inbox preview) knows to render it again. */
+export declare function docLinksRevision(): number;
+/** Record that a name or path landed; see `docLinksRevision`. */
+export declare function noteDocLinksChanged(): void;
+/** Install (or clear) the viewer's document-link context. */
+export declare function setDocLinkContext(context: DocLinkContext | undefined): void;
+/** The node-id owner and remaining name of a ref, when its first segment is a node id. */
+export declare function splitDocRef(ref: string, context?: DocLinkContext): {
+    nodeId?: string;
+    name: string;
+};
+/** A readable name for a document ref: `name`, plus the owning node's name
+ *  when another node owns it. Plain text, for pickers and notices. */
+export declare function docLinkLabel(ref: string, context?: DocLinkContext | undefined): {
+    name: string;
+    owner?: string;
+};
+/** One-line plain-text label: `name` or `name · owner`. */
+export declare function docLinkText(ref: string, context?: DocLinkContext | undefined): string;
+/** Every `[[ref]]` in `text`, in order of appearance, without brackets. */
+export declare function extractDocRefs(text: string): string[];
+/** Rewrite each `[[ref]]` in a prose fragment (never a code span or fence —
+ *  the caller skips those) into its readable, openable display form. Without
+ *  an installed context the prose is returned unchanged. */
+export declare function rewriteProseDocLinks(prose: string, context?: DocLinkContext | undefined): string;

package/dist/clients/attach/render/doc-links.js

@@ -0,0 +1,78 @@
+// render/doc-links.ts — readable, openable `[[owner/name]]` document links.
+//
+// Agents point at canvas documents as `[[<node-id>/<name>]]`. The raw id is
+// noise to a person, so the DISPLAY copy of agent Markdown names the document
+// the way the person would: its bare name when this viewer's node owns it, the
+// name plus the owning node's display name (dimmed) when another node does, and
+// the text as written for repo/profile/user/plugin documents. The source text —
+// what other agents and `/copy` see — is never changed.
+//
+// Local links point to the daemon's browser listener; remote attach shows names only.
+const DOC_REF = /\[\[([^[\]\n]+?)\]\]/g;
+/** A minted node id: `<install>-<time36>-<rand>`. */
+const NODE_ID_SHAPE = /^[a-z0-9]+-[a-z0-9]+-[a-z0-9]+$/;
+const DIM = (text) => `\x1b[2m${text}\x1b[22m`;
+const UNDERLINE = (text) => `\x1b[4m${text}\x1b[24m`;
+let current;
+let revision = 0;
+/** Bumped whenever a document name or path lands, so a surface that holds
+ *  rendered Markdown (the inbox preview) knows to render it again. */
+export function docLinksRevision() {
+    return revision;
+}
+/** Record that a name or path landed; see `docLinksRevision`. */
+export function noteDocLinksChanged() {
+    revision++;
+}
+/** Install (or clear) the viewer's document-link context. */
+export function setDocLinkContext(context) {
+    current = context;
+}
+/** The node-id owner and remaining name of a ref, when its first segment is a node id. */
+export function splitDocRef(ref, context) {
+    const slash = ref.indexOf('/');
+    if (slash <= 0)
+        return { name: ref };
+    const head = ref.slice(0, slash);
+    const isNode = head === context?.selfNodeId || context?.nodeName(head) !== undefined || NODE_ID_SHAPE.test(head);
+    return isNode ? { nodeId: head, name: ref.slice(slash + 1) } : { name: ref };
+}
+/** A readable name for a document ref: `name`, plus the owning node's name
+ *  when another node owns it. Plain text, for pickers and notices. */
+export function docLinkLabel(ref, context = current) {
+    const { nodeId, name } = splitDocRef(ref, context);
+    if (nodeId === undefined)
+        return { name };
+    if (nodeId === context?.selfNodeId)
+        return { name };
+    return { name, owner: context?.nodeName(nodeId) ?? nodeId.slice(nodeId.lastIndexOf('-') + 1) };
+}
+/** One-line plain-text label: `name` or `name · owner`. */
+export function docLinkText(ref, context = current) {
+    const label = docLinkLabel(ref, context);
+    return label.owner === undefined ? label.name : `${label.name} · ${label.owner}`;
+}
+/** Every `[[ref]]` in `text`, in order of appearance, without brackets. */
+export function extractDocRefs(text) {
+    return [...text.matchAll(DOC_REF)].map((match) => match[1].trim()).filter((ref) => ref !== '');
+}
+/** Rewrite each `[[ref]]` in a prose fragment (never a code span or fence —
+ *  the caller skips those) into its readable, openable display form. Without
+ *  an installed context the prose is returned unchanged. */
+export function rewriteProseDocLinks(prose, context = current) {
+    if (context === undefined || !prose.includes('[['))
+        return prose;
+    return prose.replace(DOC_REF, (whole, inner) => {
+        const ref = inner.trim();
+        if (ref === '')
+            return whole;
+        const label = docLinkLabel(ref, context);
+        const url = context.urlFor(ref);
+        const name = escapeLabel(label.name);
+        const link = url === undefined ? UNDERLINE(name) : `[${name}](${url})`;
+        return label.owner === undefined ? link : `${link}${DIM(` · ${escapeLabel(label.owner)}`)}`;
+    });
+}
+function escapeLabel(text) {
+    return text.replace(/([\\[\]*_`<>])/g, '\\$1');
+}

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

@@ -0,0 +1,12 @@
+import { FoldedToolCallController, type FileLineChanges, type ToolResultObserver } from './tool-calls.js';
+export type CrtrEditToolView = {
+    definition: unknown;
+    observeResult: ToolResultObserver;
+};
+/** Count only changed rows in pi's display diff; context and ellipsis rows do
+ *  not contribute to the folded file summary. */
+export declare function countDisplayDiffLines(diff: string): FileLineChanges;
+/** Crouter owns edit presentation while the imported tool owns execution. The
+ *  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;

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

@@ -0,0 +1,304 @@
+// render/edit-diff.ts — crouter-owned edit presentation for the attach viewer.
+//
+// The card renders replacement arguments synchronously while they stream, then
+// switches to the executed tool result's full-file diff when the tool settles.
+// Added and removed rows receive full-width tinted backgrounds, with the changed
+// span inside a 1↔1 line modification emphasized in a brighter tint. The imported
+// pi package remains responsible for edit execution, not viewer lifecycle.
+import { generateDiffString } from '@earendil-works/pi-coding-agent';
+import { Box, Container, Spacer, Text } from '@earendil-works/pi-tui';
+import { FoldedToolCallController, foldedFileCallLine } from './tool-calls.js';
+const FALLBACK_ADDED = { r: 181, g: 189, b: 104 }; // pi dark green
+const FALLBACK_REMOVED = { r: 204, g: 102, b: 102 }; // pi dark red
+const FALLBACK_CARD_BG = { r: 40, g: 50, b: 40 }; // pi dark toolSuccessBg
+/** Standard xterm-256 palette → rgb (cube + grayscale ramps; 16 base approximated). */
+function xterm256ToRgb(n) {
+    if (n < 16) {
+        const base = [
+            [0, 0, 0], [205, 0, 0], [0, 205, 0], [205, 205, 0],
+            [0, 0, 238], [205, 0, 205], [0, 205, 205], [229, 229, 229],
+            [127, 127, 127], [255, 0, 0], [0, 255, 0], [255, 255, 0],
+            [92, 92, 255], [255, 0, 255], [0, 255, 255], [255, 255, 255],
+        ];
+        const [r, g, b] = base[n] ?? [128, 128, 128];
+        return { r, g, b };
+    }
+    if (n < 232) {
+        const i = n - 16;
+        const steps = [0, 95, 135, 175, 215, 255];
+        return { r: steps[Math.floor(i / 36) % 6], g: steps[Math.floor(i / 6) % 6], b: steps[i % 6] };
+    }
+    const v = 8 + (n - 232) * 10;
+    return { r: v, g: v, b: v };
+}
+/** rgb → nearest xterm-256 cube/gray index (for non-truecolor terminals). */
+function rgbTo256(c) {
+    const toCube = (v) => (v < 48 ? 0 : v < 115 ? 1 : Math.min(5, Math.floor((v - 35) / 40)));
+    const steps = [0, 95, 135, 175, 215, 255];
+    const cr = toCube(c.r);
+    const cg = toCube(c.g);
+    const cb = toCube(c.b);
+    const cubeIdx = 16 + 36 * cr + 6 * cg + cb;
+    const cube = { r: steps[cr], g: steps[cg], b: steps[cb] };
+    const gray = Math.max(0, Math.min(23, Math.round((((c.r + c.g + c.b) / 3) - 8) / 10)));
+    const grayIdx = 232 + gray;
+    const grayRgb = xterm256ToRgb(grayIdx);
+    const dist = (a, b) => (a.r - b.r) ** 2 + (a.g - b.g) ** 2 + (a.b - b.b) ** 2;
+    return dist(c, cube) <= dist(c, grayRgb) ? cubeIdx : grayIdx;
+}
+/** Parse the rgb out of a theme SGR open code (`38/48;2;r;g;b` or `38/48;5;n`). */
+function parseAnsiRgb(ansi) {
+    const truecolor = ansi.match(/\x1b\[[34]8;2;(\d+);(\d+);(\d+)m/);
+    if (truecolor)
+        return { r: Number(truecolor[1]), g: Number(truecolor[2]), b: Number(truecolor[3]) };
+    const indexed = ansi.match(/\x1b\[[34]8;5;(\d+)m/);
+    if (indexed)
+        return xterm256ToRgb(Number(indexed[1]));
+    return undefined;
+}
+function mix(a, b, t) {
+    return {
+        r: Math.round(a.r * t + b.r * (1 - t)),
+        g: Math.round(a.g * t + b.g * (1 - t)),
+        b: Math.round(a.b * t + b.b * (1 - t)),
+    };
+}
+function bgOpen(c, mode) {
+    if (mode === 'truecolor')
+        return `\x1b[48;2;${c.r};${c.g};${c.b}m`;
+    return `\x1b[48;5;${rgbTo256(c)}m`;
+}
+function themeFgRgb(theme, name, fallback) {
+    try {
+        return parseAnsiRgb(theme.getFgAnsi(name)) ?? fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+function themeBgRgb(theme, name, fallback) {
+    try {
+        return parseAnsiRgb(theme.getBgAnsi(name)) ?? fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+function parseDisplayDiffLine(line) {
+    const match = line.match(/^([+-\s])(\s*\d*)\s(.*)$/);
+    if (!match)
+        return null;
+    return { prefix: match[1], lineNum: match[2], content: match[3] };
+}
+/** Count only changed rows in pi's display diff; context and ellipsis rows do
+ *  not contribute to the folded file summary. */
+export function countDisplayDiffLines(diff) {
+    let added = 0;
+    let removed = 0;
+    for (const line of diff.split('\n')) {
+        const parsed = parseDisplayDiffLine(line);
+        if (parsed?.prefix === '+')
+            added++;
+        if (parsed?.prefix === '-')
+            removed++;
+    }
+    return { added, removed };
+}
+/** Extract every complete replacement pair currently present in the streamed
+ *  arguments. A pair becomes previewable as soon as both strings exist. */
+function editPairs(args) {
+    const value = args;
+    if (Array.isArray(value?.edits)) {
+        return value.edits.flatMap((edit) => {
+            const pair = edit;
+            return typeof pair?.oldText === 'string' && typeof pair?.newText === 'string'
+                ? [{ oldText: pair.oldText, newText: pair.newText }]
+                : [];
+        });
+    }
+    return typeof value?.oldText === 'string' && typeof value?.newText === 'string'
+        ? [{ oldText: value.oldText, newText: value.newText }]
+        : [];
+}
+/** The pre-execution preview is deliberately replacement-local: it can update
+ *  synchronously as arguments stream and never races filesystem mutation. */
+function streamedArgumentDiff(args) {
+    const diffs = editPairs(args)
+        .map(({ oldText, newText }) => generateDiffString(oldText, newText).diff)
+        .filter((diff) => diff.trim().length > 0);
+    return diffs.length > 0 ? diffs.join('\n') : undefined;
+}
+function replaceTabs(text) {
+    return text.replace(/\t/g, '   ');
+}
+/** Common prefix/suffix char-span diff for a single-line 1↔1 modification. */
+function changedSpans(oldS, newS) {
+    const maxP = Math.min(oldS.length, newS.length);
+    let p = 0;
+    while (p < maxP && oldS[p] === newS[p])
+        p++;
+    let s = 0;
+    while (s < maxP - p && oldS[oldS.length - 1 - s] === newS[newS.length - 1 - s])
+        s++;
+    return { old: [p, oldS.length - s], new: [p, newS.length - s] };
+}
+/** Wrap the changed span in a brighter tint, restoring the line tint after. */
+function emphasize(content, span, emphOpen, lineOpen) {
+    const [start, end] = span;
+    if (end <= start)
+        return content;
+    return content.slice(0, start) + emphOpen + content.slice(start, end) + lineOpen + content.slice(end);
+}
+/**
+ * Build the Claude-Code-style diff body: one full-width background-tinted
+ * Text per added/removed line (continuation lines of a wrapped long line keep
+ * the tint, exactly like Claude Code), plain context lines in between.
+ *
+ * `restoreBg` is the SGR that must follow each tinted line so the host Box's
+ * own background resumes on its right padding column (a bare `\x1b[49m` would
+ * punch a default-bg notch into the card edge).
+ */
+function buildDiffBody(diffText, theme, restoreBg) {
+    const mode = theme.getColorMode();
+    const cardBg = themeBgRgb(theme, 'toolSuccessBg', FALLBACK_CARD_BG);
+    const addedFg = themeFgRgb(theme, 'toolDiffAdded', FALLBACK_ADDED);
+    const removedFg = themeFgRgb(theme, 'toolDiffRemoved', FALLBACK_REMOVED);
+    const addedLineBg = bgOpen(mix(addedFg, cardBg, 0.24), mode);
+    const addedEmphBg = bgOpen(mix(addedFg, cardBg, 0.48), mode);
+    const removedLineBg = bgOpen(mix(removedFg, cardBg, 0.24), mode);
+    const removedEmphBg = bgOpen(mix(removedFg, cardBg, 0.48), mode);
+    const container = new Container();
+    const pushLine = (styled, lineBg) => {
+        const bgFn = lineBg === undefined ? undefined : (padded) => lineBg + padded + restoreBg;
+        container.addChild(new Text(styled, 0, 0, bgFn));
+    };
+    const pushRemoved = (lineNum, content) => {
+        pushLine(`${theme.fg('toolDiffRemoved', `-${lineNum}`)} ${content}`, removedLineBg);
+    };
+    const pushAdded = (lineNum, content) => {
+        pushLine(`${theme.fg('toolDiffAdded', `+${lineNum}`)} ${content}`, addedLineBg);
+    };
+    const lines = diffText.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const parsed = parseDisplayDiffLine(lines[i]);
+        if (!parsed) {
+            pushLine(theme.fg('toolDiffContext', lines[i]));
+            i++;
+            continue;
+        }
+        if (parsed.prefix === '-') {
+            const removed = [];
+            while (i < lines.length) {
+                const p = parseDisplayDiffLine(lines[i]);
+                if (!p || p.prefix !== '-')
+                    break;
+                removed.push({ lineNum: p.lineNum, content: replaceTabs(p.content) });
+                i++;
+            }
+            const added = [];
+            while (i < lines.length) {
+                const p = parseDisplayDiffLine(lines[i]);
+                if (!p || p.prefix !== '+')
+                    break;
+                added.push({ lineNum: p.lineNum, content: replaceTabs(p.content) });
+                i++;
+            }
+            // Single-line modification → emphasize the changed span in a brighter tint.
+            if (removed.length === 1 && added.length === 1) {
+                const spans = changedSpans(removed[0].content, added[0].content);
+                pushRemoved(removed[0].lineNum, emphasize(removed[0].content, spans.old, removedEmphBg, removedLineBg));
+                pushAdded(added[0].lineNum, emphasize(added[0].content, spans.new, addedEmphBg, addedLineBg));
+            }
+            else {
+                for (const line of removed)
+                    pushRemoved(line.lineNum, line.content);
+                for (const line of added)
+                    pushAdded(line.lineNum, line.content);
+            }
+        }
+        else if (parsed.prefix === '+') {
+            pushAdded(parsed.lineNum, replaceTabs(parsed.content));
+            i++;
+        }
+        else {
+            pushLine(theme.fg('toolDiffContext', ` ${parsed.lineNum} ${replaceTabs(parsed.content)}`));
+            i++;
+        }
+    }
+    return container;
+}
+class EditCallComponent extends Box {
+    constructor() {
+        super(1, 1, (text) => text);
+    }
+    update(header, diff, state, theme) {
+        const background = state.settled
+            ? state.isError ? 'toolErrorBg' : 'toolSuccessBg'
+            : 'toolPendingBg';
+        this.setBgFn((text) => theme.bg(background, text));
+        this.clear();
+        this.addChild(new Text(header, 0, 0));
+        if (!diff)
+            return;
+        this.addChild(new Spacer(1));
+        this.addChild(buildDiffBody(diff, theme, theme.getBgAnsi(background)));
+    }
+}
+function editPath(args) {
+    const value = args;
+    return typeof value?.file_path === 'string' ? value.file_path : typeof value?.path === 'string' ? value.path : '';
+}
+function errorResultText(result) {
+    return (result.content ?? [])
+        .filter((part) => part.type === 'text' && typeof part.text === 'string')
+        .map((part) => part.text)
+        .join('\n');
+}
+/** Crouter owns edit presentation while the imported tool owns execution. The
+ *  card has two explicit phases: streamed argument diff, then executed result
+ *  diff. No asynchronous preview can write after settlement. */
+export function createCrtrEditToolDefinition(cwd, fold = new FoldedToolCallController()) {
+    const state = { settled: false, isError: false };
+    const call = new EditCallComponent();
+    const observeResult = (result, isPartial) => {
+        if (isPartial)
+            return;
+        state.settled = true;
+        state.isError = result.isError === true;
+        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 = {
+        name: 'edit',
+        label: 'edit',
+        description: 'Render streamed edit arguments and the executed full-file diff in the attach viewer.',
+        parameters: {},
+        renderShell: 'self',
+        renderCall(args, theme, context) {
+            const diff = state.settled ? state.diff : streamedArgumentDiff(args);
+            const changes = state.settled && !state.isError && state.diff ? countDisplayDiffLines(state.diff) : undefined;
+            const header = foldedFileCallLine('edit', editPath(args), theme, context.cwd ?? cwd, changes);
+            if (fold.folded)
+                return fold.capture(new Text(header, 0, 0));
+            call.update(header, diff, state, theme);
+            return fold.capture(call);
+        },
+        renderResult(result, _options, theme, context) {
+            const component = context.lastComponent instanceof Container ? context.lastComponent : new Container();
+            component.clear();
+            if (!context.isError)
+                return component;
+            const output = errorResultText(result);
+            if (output) {
+                component.addChild(new Spacer(1));
+                component.addChild(new Text(theme.fg('error', output), 1, 0));
+            }
+            return component;
+        },
+    };
+    return { definition, observeResult };
+}

package/dist/clients/attach/render/glyph-codepoints.d.ts

@@ -0,0 +1,3 @@
+/** Replace every private-use `U+XXXX` reference in `text` with the character it
+ *  names. Non-PUA references and malformed digits pass through untouched. */
+export declare function expandGlyphCodepoints(text: string): string;

package/dist/clients/attach/render/glyph-codepoints.js

@@ -0,0 +1,42 @@
+// glyph-codepoints.ts — render `U+XXXX` as the glyph it names, for the private-
+// use areas only.
+//
+// Nerd Font icons live in the Unicode private-use areas, and PUA codepoints are
+// effectively absent from model tokenizer vocabularies: an agent cannot type one
+// into its reply (the character never becomes tokens, so it is simply missing
+// from the message) and cannot even perceive one in a prompt. Agents CAN name a
+// codepoint accurately, so the viewer closes the gap at the other end — an agent
+// writes `U+F188` and the reader sees the bug glyph.
+//
+// Scoped to the private-use areas on purpose. Those are exactly the codepoints
+// an agent cannot write literally, so expanding them adds an ability rather than
+// taking one away; every other codepoint reference (`U+0041`, `U+241C`) is left
+// as text, because a message discussing Unicode wants the hex on screen and
+// could have contained the character itself if it meant the character.
+/** `U+` followed by 4-6 hex digits, not glued to a surrounding word. Case
+ *  insensitive on both the prefix and the digits. */
+const CODEPOINT = /\bU\+([0-9A-Fa-f]{4,6})\b/g;
+/** Private-use areas: the BMP block plus planes 15 and 16. Nerd Fonts use the
+ *  BMP block and, since v3, the supplementary block above U+F0000. */
+function isPrivateUse(cp) {
+    return ((cp >= 0xe000 && cp <= 0xf8ff) ||
+        (cp >= 0xf0000 && cp <= 0xffffd) ||
+        (cp >= 0x100000 && cp <= 0x10fffd));
+}
+/** Replace every private-use `U+XXXX` reference in `text` with the character it
+ *  names. Non-PUA references and malformed digits pass through untouched. */
+export function expandGlyphCodepoints(text) {
+    if (!text.includes('U+') && !text.includes('u+'))
+        return text;
+    return text.replace(CODEPOINT, (match, hex) => {
+        const cp = Number.parseInt(hex, 16);
+        if (!isPrivateUse(cp))
+            return match;
+        try {
+            return String.fromCodePoint(cp);
+        }
+        catch {
+            return match;
+        }
+    });
+}