@north-light/crouter 0.3.154

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

@@ -0,0 +1,14 @@
+/** 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;
+/** True when any text part of an assistant message carries a supported fence. */
+export declare function messageHasDiagram(message: {
+    content?: unknown;
+}): boolean;
+/** Return a shallow clone of an assistant message with every supported fence
+ *  rendered inline. Non-text parts (thinking, toolCall) pass through untouched,
+ *  and a message without a supported fence keeps the same reference. */
+export declare function transformMessageDiagrams<T extends {
+    content?: unknown;
+}>(message: T, width: number): T;

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

@@ -0,0 +1,135 @@
+// 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:
+//   • termrender renders mermaid to MONOCHROME box-drawing lines with zero ANSI
+//     escapes (verified: `--color on` output for a pure mermaid fence is
+//     byte-identical to `--color off`). So the rendered lines are safe to splice
+//     back into markdown inside a plain ``` code fence — pi's Markdown then shows
+//     them verbatim in monospace, no escape-code leakage, no re-wrapping.
+//   • `renderMarkdown` (humanloop — the sole org-wide termrender caller) 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 '@crouton-kit/humanloop';
+/** 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);
+    });
+}
+/** True when any text part of an assistant message carries a supported fence. */
+export function messageHasDiagram(message) {
+    const content = message.content;
+    if (typeof content === 'string')
+        return textHasDiagram(content);
+    if (!Array.isArray(content))
+        return false;
+    return content.some((p) => p?.type === 'text' && textHasDiagram(p.text ?? ''));
+}
+/** Return a shallow clone of an assistant message with every supported fence
+ *  rendered inline. Non-text parts (thinking, toolCall) pass through untouched,
+ *  and a message without a supported fence keeps the same reference. */
+export function transformMessageDiagrams(message, width) {
+    const content = message.content;
+    if (typeof content === 'string') {
+        if (!textHasDiagram(content))
+            return message;
+        return { ...message, content: transformDiagramFences(content, width) };
+    }
+    if (!Array.isArray(content) || !messageHasDiagram(message))
+        return message;
+    return {
+        ...message,
+        content: content.map((part) => {
+            const p = part;
+            if (p?.type === 'text' && typeof p.text === 'string' && textHasDiagram(p.text)) {
+                return { ...p, text: transformDiagramFences(p.text, width) };
+            }
+            return part;
+        }),
+    };
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Attach-viewer tool definition for `edit`: pi's builtin definition drives
+ * all state (preview computation, header, success/error bg), then the diff
+ * body is re-skinned Claude-Code-style after every render pass.
+ */
+export declare function createCrtrEditToolDefinition(cwd: string): unknown;

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

@@ -0,0 +1,263 @@
+// render/edit-diff.ts — Claude-Code-style diff rendering for the attach viewer.
+//
+// pi's builtin edit renderer (core/tools/edit.js → renderDiff) paints diff
+// lines with colored FOREGROUND text plus inverse-video on changed tokens.
+// This module re-skins that body the way Claude Code renders diffs: every
+// added line gets a full-width tinted green BACKGROUND, every removed line a
+// full-width tinted red background, with the changed span inside a 1↔1 line
+// modification emphasized in a brighter tint of the same color.
+//
+// We deliberately keep pi's builtin edit definition as the engine — it owns
+// the async preview computation (computeEditsDiff keyed off ctx.state) and
+// the header/status-bg lifecycle — and only swap the rendered diff body.
+// The raw diff string lives on the call component (`preview.diff`), so no
+// ANSI re-parsing of pi's output is ever needed.
+import { createEditToolDefinition } from '@earendil-works/pi-coding-agent';
+import { Container, Spacer, Text } from '@earendil-works/pi-tui';
+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;
+    }
+}
+// ---------------------------------------------------------------------------
+// Diff body rendering
+// ---------------------------------------------------------------------------
+/** pi's display-diff line format: "+123 content" / "-123 content" / " 123 content". */
+function parseDiffLine(line) {
+    const match = line.match(/^([+-\s])(\s*\d*)\s(.*)$/);
+    if (!match)
+        return null;
+    return { prefix: match[1], lineNum: match[2], content: match[3] };
+}
+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 = parseDiffLine(lines[i]);
+        if (!parsed) {
+            pushLine(theme.fg('toolDiffContext', lines[i]));
+            i++;
+            continue;
+        }
+        if (parsed.prefix === '-') {
+            const removed = [];
+            while (i < lines.length) {
+                const p = parseDiffLine(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 = parseDiffLine(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;
+}
+// ---------------------------------------------------------------------------
+// Tool definition wrapper
+// ---------------------------------------------------------------------------
+/** Replace the pi-rendered diff body inside the edit call Box (children:
+ *  [header, Spacer, body]) with the full-background rendering. No-op when
+ *  there is no successful preview (header-only or error states keep pi's
+ *  rendering untouched). */
+function restyleEditCallBox(box, theme) {
+    const preview = box.preview;
+    if (!preview || 'error' in preview || box.children.length < 2)
+        return;
+    const header = box.children[0];
+    box.clear();
+    box.addChild(header);
+    box.addChild(new Spacer(1));
+    // With a successful preview the edit card bg is always toolSuccessBg
+    // (mirrors pi's getEditHeaderBg), so tinted lines restore to that color.
+    box.addChild(buildDiffBody(preview.diff, theme, theme.getBgAnsi('toolSuccessBg')));
+}
+/**
+ * Attach-viewer tool definition for `edit`: pi's builtin definition drives
+ * all state (preview computation, header, success/error bg), then the diff
+ * body is re-skinned Claude-Code-style after every render pass.
+ */
+export function createCrtrEditToolDefinition(cwd) {
+    const builtin = createEditToolDefinition(cwd);
+    return {
+        name: 'edit',
+        label: 'edit',
+        description: 'Render edit diffs with full-line backgrounds in the attach viewer.',
+        parameters: {},
+        renderShell: 'self',
+        renderCall(args, theme, context) {
+            const component = builtin.renderCall(args, theme, context);
+            const callBox = context.state.callComponent;
+            if (callBox)
+                restyleEditCallBox(callBox, theme);
+            return component;
+        },
+        renderResult(result, options, theme, context) {
+            const component = builtin.renderResult(result, options, theme, context);
+            const callBox = context.state.callComponent;
+            if (callBox) {
+                // builtin renderResult re-ran buildEditCallComponent (pi styling) —
+                // restyle the refreshed body.
+                restyleEditCallBox(callBox, theme);
+                return component;
+            }
+            // Fallback path (no call box state, e.g. a bare result replay): render
+            // the result diff standalone. No host Box here, so restore to default bg.
+            const resultDiff = result?.details?.diff;
+            if (!context.isError && typeof resultDiff === 'string') {
+                const container = new Container();
+                container.addChild(new Spacer(1));
+                container.addChild(buildDiffBody(resultDiff, theme, '\x1b[49m'));
+                return container;
+            }
+            return component;
+        },
+    };
+}

package/dist/clients/attach/render/frozen-history.d.ts

@@ -0,0 +1,38 @@
+import { type Component } from '@earendil-works/pi-tui';
+import type { CondensedHistoryMode } from '../../../types.js';
+/** A message from the broker snapshot, structurally. */
+type Message = {
+    role?: string;
+    customType?: string;
+};
+export declare function isCycleDivider(message: Message): boolean;
+/** Does this message survive condensation into the frozen block? */
+export declare function keepWhenCondensed(message: Message, mode: CondensedHistoryMode): boolean;
+/**
+ * Index into `messages` at which the LIVE (fully rendered) region begins.
+ *
+ * The snapshot is `[cycle 0][divider][cycle 1][divider]…[current cycle]`, so a
+ * transcript with D dividers holds D+1 cycles. Keeping the trailing
+ * `liveCycles` of them means everything up to and including divider
+ * `D - liveCycles` is condensed. Returns 0 — condense nothing — when the node
+ * has not yielded often enough to have older cycles, so a fresh or
+ * single-yield node renders exactly as it always did.
+ */
+export declare function liveRegionStart(messages: readonly Message[], liveCycles: number): number;
+/**
+ * A settled block of pre-rendered transcript lines. Renders in O(1) at the width
+ * it was frozen at, and clips (never reflows) when the pane is narrower. Ctrl+O /
+ * Ctrl+T do not reach it: it holds no components to expand, only text.
+ */
+export declare class FrozenHistoryComponent implements Component {
+    private readonly lines;
+    private readonly frozenWidth;
+    /** Last clip result, so a stable narrow pane clips once rather than per frame. */
+    private clipped;
+    constructor(lines: readonly string[], frozenWidth: number);
+    get lineCount(): number;
+    /** Nothing to recompute — the block is text, already laid out. */
+    invalidate(): void;
+    render(width: number): string[];
+}
+export {};

package/dist/clients/attach/render/frozen-history.js

@@ -0,0 +1,100 @@
+// frozen-history.ts — condensed, frozen rendering of a node's OLD cycles.
+//
+// A node that has yielded several times carries every prior cycle in its welcome
+// snapshot (cycleAwareMessages, session-cycles.ts), and the viewer used to build a
+// live component for each message in all of them. Measured across six real
+// sessions (2788 entries, rendered at width 120 with tool output collapsed):
+//
+//     tool calls + results   20448 lines (62.9%)   1376 ms (69%) of build time
+//     user                    6078 lines (18.7%)    431 ms
+//     assistant prose         5960 lines (18.3%)    202 ms
+//
+// So the tool traffic of cycles you are no longer working in dominates both the
+// transcript's line count and the cost of attaching to it. Cycles older than the
+// trailing `live_cycles` (config, default 2) are therefore CONDENSED — reduced to
+// the cycle dividers plus whichever messages `condensed_history` (config, default
+// `none`) admits — and FROZEN: rendered once into a flat `string[]` that is handed
+// back verbatim on every subsequent frame.
+//
+// Freezing means the block never re-wraps. Widening the pane leaves the old lines
+// short (harmless); narrowing CLIPS them at the right edge rather than reflowing,
+// because emitting a line wider than the pane would desync pi-tui's line
+// accounting against the terminal's own wrapping and garble everything below it.
+//
+// The full detail of a condensed cycle is never lost — it is in the node's session
+// file, and `/tree` still navigates the real branches.
+import { sliceByColumn } from '@earendil-works/pi-tui';
+import { CRTR_CYCLE_DIVIDER_CUSTOM_TYPE } from '../../../core/runtime/session-cycles.js';
+/** Roles admitted by each `condensed_history` mode. `toolResult`,
+ *  `bashExecution`, and every non-divider `custom` message (crtr output,
+ *  injected context blocks) are never kept, nor are the tool-call components an
+ *  assistant message would otherwise spawn — only its prose. The cycle dividers
+ *  survive every mode, so `none` leaves the seams and nothing else. */
+const ROLES_BY_MODE = {
+    none: new Set(),
+    user: new Set(['user']),
+    agent: new Set(['assistant', 'compactionSummary', 'branchSummary']),
+    both: new Set(['user', 'assistant', 'compactionSummary', 'branchSummary']),
+};
+export function isCycleDivider(message) {
+    return message.role === 'custom' && message.customType === CRTR_CYCLE_DIVIDER_CUSTOM_TYPE;
+}
+/** Does this message survive condensation into the frozen block? */
+export function keepWhenCondensed(message, mode) {
+    if (isCycleDivider(message))
+        return true;
+    return (ROLES_BY_MODE[mode] ?? ROLES_BY_MODE.none).has(message.role ?? '');
+}
+/**
+ * Index into `messages` at which the LIVE (fully rendered) region begins.
+ *
+ * The snapshot is `[cycle 0][divider][cycle 1][divider]…[current cycle]`, so a
+ * transcript with D dividers holds D+1 cycles. Keeping the trailing
+ * `liveCycles` of them means everything up to and including divider
+ * `D - liveCycles` is condensed. Returns 0 — condense nothing — when the node
+ * has not yielded often enough to have older cycles, so a fresh or
+ * single-yield node renders exactly as it always did.
+ */
+export function liveRegionStart(messages, liveCycles) {
+    const keep = Math.max(1, Math.floor(liveCycles));
+    const dividers = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (isCycleDivider(messages[i]))
+            dividers.push(i);
+    }
+    const cycles = dividers.length + 1;
+    if (cycles <= keep)
+        return 0;
+    // The last divider that closes a condensed cycle; the live region opens just
+    // after it (the divider itself stays in the frozen block as the seam).
+    return dividers[cycles - keep - 1] + 1;
+}
+/**
+ * A settled block of pre-rendered transcript lines. Renders in O(1) at the width
+ * it was frozen at, and clips (never reflows) when the pane is narrower. Ctrl+O /
+ * Ctrl+T do not reach it: it holds no components to expand, only text.
+ */
+export class FrozenHistoryComponent {
+    lines;
+    frozenWidth;
+    /** Last clip result, so a stable narrow pane clips once rather than per frame. */
+    clipped;
+    constructor(lines, frozenWidth) {
+        this.lines = lines;
+        this.frozenWidth = frozenWidth;
+    }
+    get lineCount() {
+        return this.lines.length;
+    }
+    /** Nothing to recompute — the block is text, already laid out. */
+    invalidate() { }
+    render(width) {
+        if (width >= this.frozenWidth)
+            return this.lines;
+        if (this.clipped?.width === width)
+            return this.clipped.lines;
+        const lines = this.lines.map((line) => sliceByColumn(line, 0, width, true));
+        this.clipped = { width, lines };
+        return lines;
+    }
+}

package/dist/clients/attach/render/markdown-headings.d.ts

@@ -0,0 +1,11 @@
+/** Style ATX headings with a scan-friendly terminal hierarchy. The Markdown
+ * markers are syntax, not content, so omit them from the rendered line.
+ * Fenced examples remain literal Markdown, never decorated terminal output. */
+export declare function styleAttachMarkdownHeadings(markdown: string): string;
+/** Copy a pi message for terminal rendering and decorate only Markdown-bearing
+ * text/thinking blocks. The broker's source event is never mutated. */
+export declare function styleAttachMessageMarkdown<T>(message: T): T;
+/** Copy an expanded pi summary without changing its persisted source. */
+export declare function styleAttachSummaryMarkdown<T extends {
+    summary: string;
+}>(message: T): T;

package/dist/clients/attach/render/markdown-headings.js

@@ -0,0 +1,82 @@
+// Terminal-specific Markdown heading hierarchy for the attach viewer.
+//
+// pi-tui's MarkdownTheme exposes one `heading(text)` callback without the
+// heading depth. Its renderer does know the depth, but does not pass it to the
+// theme, so every heading otherwise receives the same yellow mdHeading paint.
+// Decorate only the source text of H3–H6 before it reaches pi-tui: pi still
+// owns parsing, wrapping, inline formatting, and H1/H2's established styling.
+// This stays attach-local — persisted messages and copied text remain ordinary
+// Markdown without terminal escape sequences.
+const ATX_HEADING = /^(\s{0,3})(#{3,6})(?:[ \t]+|$)(.*?)([ \t]+#+[ \t]*)?$/;
+const FENCE_OPEN = /^\s{0,3}(`{3,}|~{3,})/;
+// A constant-lightness ramp from warm yellow to cool blue, with saturation
+// deliberately reduced at each step so the hierarchy recedes rather than
+// becoming a tour of unrelated accent colors.
+const HEADING_COLORS = [
+    [232, 194, 104],
+    [207, 194, 145],
+    [181, 184, 174],
+    [157, 170, 180],
+    [135, 153, 164],
+    [116, 135, 147],
+];
+function headingColor(level) {
+    const [r, g, b] = HEADING_COLORS[level - 1];
+    return (text) => `\x1b[1;38;2;${r};${g};${b}m${text}\x1b[22;39m`;
+}
+/** Style ATX headings with a scan-friendly terminal hierarchy. The Markdown
+ * markers are syntax, not content, so omit them from the rendered line.
+ * Fenced examples remain literal Markdown, never decorated terminal output. */
+export function styleAttachMarkdownHeadings(markdown) {
+    let fence;
+    return markdown.split('\n').map((line) => {
+        const fenceMatch = FENCE_OPEN.exec(line);
+        if (fence !== undefined) {
+            if (fenceMatch?.[1][0] === fence)
+                fence = undefined;
+            return line;
+        }
+        if (fenceMatch) {
+            fence = fenceMatch[1][0];
+            return line;
+        }
+        const match = ATX_HEADING.exec(line);
+        if (!match)
+            return line;
+        const [, indent, hashes, body, closing = ''] = match;
+        if (body === '')
+            return line;
+        return `${indent}${headingColor(hashes.length)(body)}`;
+    }).join('\n');
+}
+/** Copy a pi message for terminal rendering and decorate only Markdown-bearing
+ * text/thinking blocks. The broker's source event is never mutated. */
+export function styleAttachMessageMarkdown(message) {
+    if (typeof message !== 'object' || message === null || !('content' in message))
+        return message;
+    const candidate = message;
+    if (typeof candidate.content === 'string') {
+        return { ...candidate, content: styleAttachMarkdownHeadings(candidate.content) };
+    }
+    if (!Array.isArray(candidate.content))
+        return message;
+    return {
+        ...candidate,
+        content: candidate.content.map((part) => {
+            if (typeof part !== 'object' || part === null)
+                return part;
+            const block = part;
+            if (block.type === 'text' && typeof block.text === 'string') {
+                return { ...block, text: styleAttachMarkdownHeadings(block.text) };
+            }
+            if (block.type === 'thinking' && typeof block.thinking === 'string') {
+                return { ...block, thinking: styleAttachMarkdownHeadings(block.thinking) };
+            }
+            return part;
+        }),
+    };
+}
+/** Copy an expanded pi summary without changing its persisted source. */
+export function styleAttachSummaryMarkdown(message) {
+    return { ...message, summary: styleAttachMarkdownHeadings(message.summary) };
+}

package/dist/clients/attach/session/banner.d.ts

@@ -0,0 +1,9 @@
+export interface BannerInfo {
+    version?: string;
+    profile?: string;
+    cwd?: string;
+}
+export declare function buildBannerInfo(meta: {
+    cwd?: string;
+    profile_id?: string | null;
+}): BannerInfo;