@north-light/crouter 0.3.197 → 0.3.199

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

@@ -24,12 +24,12 @@ import { Container, Loader, Spacer, Text } from '@earendil-works/pi-tui';
 import { AssistantMessageComponent, BashExecutionComponent, BranchSummaryMessageComponent, CompactionSummaryMessageComponent, CustomMessageComponent, parseSkillBlock, SkillInvocationMessageComponent, ToolExecutionComponent, UserMessageComponent, } from '@earendil-works/pi-coding-agent';
 import { attachMarkdownTheme } from '../config.js';
 import { ContextMessageComponent } from './context-message.js';
+import { detectInlinePageResult, PageBlockComponent } from './page-block.js';
 import { CRTR_OUTPUT_CUSTOM_TYPE, CrtrOutputMessageComponent, createCrtrBashToolDefinition, } from './crtr-output.js';
-import { CRTR_CYCLE_DIVIDER_CUSTOM_TYPE } from '../../../core/runtime/session-cycles.js';
+import { CRTR_CYCLE_DIVIDER_CUSTOM_TYPE, endedByAbort } from '../../../core/runtime/session-cycles.js';
 import { generatedContextExpandedBody, generatedContextPresentation, isRuntimeRestartContinuation, } from '../../../shared/generated-context.js';
 import { assistantVisibleText, isTrueUserMessage, } from '../../../shared/tool-groups.js';
 import { transformDiagramFences } from './diagram.js';
-import { transformHtmlMarkdown } from './html-markdown.js';
 import { styleAttachAgentMarkdown, styleAttachMarkdownSource, styleAttachMessageMarkdown, styleAttachSummaryMarkdown, } from './markdown-source.js';
 import { createCrtrEditToolDefinition } from './edit-diff.js';
 import { GroupActivityRecorder } from './group-activity.js';
@@ -267,6 +267,11 @@ export class ChatView {
      *  a nested container while condensed history is being built, so the same
      *  message-rendering path serves both regions. */
     appendTarget = this.historyContainer;
+    /** Inline page blocks placed in this transcript, by page id — one block per
+     *  page, so a `--replace` revision refreshes the block already on screen. */
+    pageBlocks = new Map();
+    inlinePageBlocks;
+    pageOpenHint;
     /** Trailing cycles kept at full fidelity (config `live_cycles`). */
     liveCycles;
     /** Messages kept from a condensed cycle (config `condensed_history`). */
@@ -305,27 +310,13 @@ export class ChatView {
     recapPalette;
     /** Bold accent for the expanded crtr-context label. */
     labelStyle = (s) => `\x1b[1m${s}\x1b[22m`;
-    /** Undefined honors each `<details open>` attribute until Ctrl+O establishes
-     *  one viewer-wide disclosure state. */
-    detailsExpandedOverride;
     /** Viewer-local Markdown projection, handed to pi's message components so
      *  THEY apply it at render time with the exact content width. The viewer keeps
      *  no projected copy: the components hold canonical source, and each
-     *  transformer reads live viewer state (disclosure, palette) on every call.
-     *  Diagrams and the HTML allowlist apply only to assistant-authored
-     *  Markdown. */
+     *  transformer reads live viewer state on every call. Diagrams apply only to
+     *  assistant-authored Markdown. */
     markdownTransformers = [
         (markdown, { messageType, availableWidth }) => (messageType === 'assistant' ? transformDiagramFences(markdown, availableWidth) : markdown),
-        (markdown, { messageType }) => (messageType === 'assistant'
-            ? transformHtmlMarkdown(markdown, {
-                detailsExpanded: this.detailsExpandedOverride,
-                styles: {
-                    kbd: (text) => this.recapPalette.active(this.recapPalette.bold(`‹${text}›`)),
-                    mark: (text) => `\x1b[7m${this.recapPalette.bold(this.recapPalette.accent(text))}\x1b[27m`,
-                    hint: this.dimStyle,
-                },
-            })
-            : markdown),
         (markdown, { messageType }) => (messageType === 'user' ? styleAttachMarkdownSource(markdown) : styleAttachAgentMarkdown(markdown)),
     ];
     /** The assistant message component currently being streamed (between
@@ -394,6 +385,8 @@ export class ChatView {
         this.condensedHistory = opts.condensedHistory ?? readCondensedHistory();
         this.onFooterEvent = opts.onFooterEvent;
         this.onActivityChange = opts.onActivityChange;
+        this.inlinePageBlocks = opts.inlinePageBlocks ?? false;
+        this.pageOpenHint = opts.pageOpenHint ?? (() => 'crtr human list');
         this.recapPalette = opts.palette ?? defaultAttachPalette;
         this.spinnerStyle = this.recapPalette.active;
         this.dimStyle = this.recapPalette.muted;
@@ -497,9 +490,7 @@ export class ChatView {
                 const hasProse = assistantVisibleText(message).trim() !== '';
                 const toolCalls = this.assistantToolCalls(message);
                 const endedWithFailure = message.stopReason === 'aborted' || message.stopReason === 'error';
-                const terminalErrorMessage = message.stopReason === 'aborted'
-                    ? 'Interrupted'
-                    : (message.errorMessage ?? 'Error');
+                const terminalErrorMessage = endedByAbort(message) ? 'Interrupted' : (message.errorMessage ?? 'Error');
                 // A terminal assistant failure remains visible as its own boundary. Settle
                 // any interrupted calls so the completed span before it can still recap.
                 if (endedWithFailure) {
@@ -554,6 +545,7 @@ export class ChatView {
                     this.historyContainer.markDirty(component);
                     this.settleGroupTool(component, message, message.isError === true);
                     renderedPendingTools.delete(message.toolCallId);
+                    this.maybeAppendPageBlock(message);
                 }
             }
             else {
@@ -674,8 +666,7 @@ export class ChatView {
     // `setToolsExpanded` / `toggleThinkingBlockVisibility`.
     // -------------------------------------------------------------------------
     /** Ctrl+O prefers summaries when the user enabled both folding and summary
-     * generation. The same disclosure state drives assistant-authored `<details>`
-     * sections, so the transcript has one reveal-more action rather than two. */
+     * generation. */
     toggleToolsExpanded() {
         let result;
         if (this.summarizeToolCalls && this.foldSettledTools) {
@@ -687,11 +678,6 @@ export class ChatView {
             this.toolOutputExpanded = !this.toolOutputExpanded;
             result = { kind: 'output', expanded: this.toolOutputExpanded };
         }
-        this.detailsExpandedOverride = this.toolOutputExpanded;
-        // The disclosure state lives in the transformer closure, so the transcript
-        // only has to drop its projections: pi's message components rebuild their
-        // Markdown on invalidate() and re-run the transformer on the next render.
-        this.historyContainer.invalidate();
         this.applyToolDisplay();
         return result;
     }
@@ -850,15 +836,21 @@ export class ChatView {
                 if (this.streamingComponent) {
                     const stopReason = event.message.stopReason;
                     let errorMessage = event.message.errorMessage;
-                    // An aborted turn may be a user interrupt or a lifecycle interruption.
-                    // The provider tends to attach its own generic text ("Request was
-                    // aborted."), so override it outright with one plain, human label.
-                    if (stopReason === 'aborted') {
+                    // An aborted turn may be a user interrupt or a lifecycle interruption
+                    // (a refresh-yield aborts its own turn). Providers spell it several
+                    // ways — including `stopReason: 'error'` carrying a bare AbortError,
+                    // which would otherwise render as a red `Error: This operation was
+                    // aborted` for a perfectly healthy yield — so override it outright
+                    // with one plain, human label.
+                    if (endedByAbort(event.message)) {
                         errorMessage = 'Interrupted';
                         // Surface the abort on the assistant bubble itself, mirroring pi
                         // (interactive-mode.js:2280 sets streamingMessage.errorMessage before
-                        // updateContent) so the rendered message shows the annotation.
+                        // updateContent) so the rendered message shows the annotation. The
+                        // stopReason moves with it: pi's component reserves its red
+                        // `Error: …` line for stopReason 'error', and an abort is not one.
                         event.message.errorMessage = errorMessage;
+                        event.message.stopReason = 'aborted';
                     }
                     this.streamingComponent.updateContent(event.message);
                     if (stopReason === 'aborted' || stopReason === 'error') {
@@ -926,6 +918,7 @@ export class ChatView {
                     this.settleGroupTool(component, result, event.isError);
                     this.applyToolDisplay();
                     this.historyContainer.markDirty(component);
+                    this.maybeAppendPageBlock(result);
                 }
                 break;
             }
@@ -1162,10 +1155,16 @@ export class ChatView {
     // -------------------------------------------------------------------------
     // Helpers
     // -------------------------------------------------------------------------
-    /** Render an assistant reply plus its initially-hidden boundary separator. */
+    /** Render an assistant reply plus its initially-hidden boundary separator.
+     *  A turn that ended on its own abort is rendered as the interrupt it is,
+     *  matching the live seam above, so re-reading the transcript later never
+     *  turns a healthy interrupt into a red `Error:` line. */
     appendAssistantMessage(message, groupMember = false) {
         const component = new ViewerAssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel, this.markdownTransformers);
-        component.updateContent(message);
+        const rendered = endedByAbort(message)
+            ? { ...message, stopReason: 'aborted', errorMessage: 'Interrupted' }
+            : message;
+        component.updateContent(rendered);
         this.appendAssistantPart(component, groupMember);
         this.registerCopyBlock(component, 'assistant', assistantVisibleText(message));
         const separator = this.appendAssistantSeparator(groupMember);
@@ -1421,8 +1420,38 @@ export class ChatView {
         this.copyBlockRecords.length = 0;
         this.copyIndex.clear();
         this.transcriptFilePaths.length = 0;
+        this.pageBlocks.clear();
         this.historyContainer.clear();
     }
+    /** Place the transcript block for an inline page a `human send` just raised.
+     *  The block is a plain history child, NOT a tool-group member: collapsing the
+     *  tool group folds the command away and leaves the page itself on screen, the
+     *  way assistant prose stays. Condensed history is skipped deliberately — old
+     *  cycles keep only prose and cycle seams. */
+    maybeAppendPageBlock(result) {
+        if (!this.inlinePageBlocks || this.appendTarget !== this.historyContainer)
+            return;
+        const page = detectInlinePageResult(result);
+        if (page === undefined || this.pageBlocks.has(page.pageId))
+            return;
+        const block = new PageBlockComponent(page.pageId, page.dir, this.pageOpenHint);
+        this.pageBlocks.set(page.pageId, block);
+        this.append(block);
+    }
+    /** Re-read every placed page from disk. Driven by the viewer's ticket-activity
+     *  watcher, so an answer, a cancellation, or a `--replace` revision lands on
+     *  the block already anchored in the transcript. */
+    refreshPageBlocks() {
+        let changed = false;
+        for (const block of this.pageBlocks.values()) {
+            if (!block.refresh())
+                continue;
+            changed = true;
+            this.historyContainer.markDirty(block);
+        }
+        if (changed)
+            this.tui.requestRender();
+    }
     makeLoader(message) {
         // Loader updates itself on an interval. Its TUI callback has to evict the
         // status block's cached frame before requesting the next render.

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

@@ -30,10 +30,6 @@ const FENCE_OPEN = /^\s{0,3}(`{3,}|~{3,})/;
  *  a literal `>` stays untouched rather than being mis-split. */
 const XML_TAG_LINE = /^([ \t]{0,3})(<\/?)([A-Za-z][\w.:-]*)((?:[ \t]+[^<>]*?)?)(\/?)>[ \t]*$/;
 const XML_ATTRIBUTE = /([^\s=]+)(?:=("[^"]*"|'[^']*'|[^\s]*))?/g;
-/** Tags the HTML allowlist owns (see html-markdown.ts). A `<details>` block
- *  that reaches this pass is one that failed validation there and is meant to
- *  stay literal. */
-const HTML_ALLOWLIST_TAGS = new Set(['details', 'summary', 'kbd', 'mark']);
 // 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.
@@ -85,8 +81,6 @@ function styleXmlTagLine(line) {
     if (!match)
         return undefined;
     const [, indent, open, name, attributes, selfClose] = match;
-    if (HTML_ALLOWLIST_TAGS.has(name.toLowerCase()))
-        return undefined;
     return indent
         + paint(XML_PUNCTUATION, open)
         + paint(XML_NAME, name)

package/dist/clients/attach/render/page-block.d.ts

@@ -0,0 +1,34 @@
+import type { Component } from '@earendil-works/pi-tui';
+export interface InlinePageRef {
+    pageId: string;
+    dir: string;
+}
+/**
+ * The inline page a `human send` tool result announces, or undefined for every
+ * other result. Read from the structured CLI record the canvas-preview extension
+ * attaches (`details.crtrPreview`), which is present on both live tool events and
+ * rebuilt snapshot messages — never from the rendered bash text.
+ */
+export declare function detectInlinePageResult(result: unknown): InlinePageRef | undefined;
+export declare class PageBlockComponent implements Component {
+    readonly pageId: string;
+    private readonly dir;
+    private readonly openHint;
+    private expanded;
+    private generation;
+    private stamp;
+    private snapshot;
+    private cache;
+    constructor(pageId: string, dir: string, openHint: () => string);
+    /** Re-read the ticket when its request or its result changed on disk. */
+    refresh(): boolean;
+    /** Ctrl+O global expansion (ChatView.isExpandable duck-type). */
+    setExpanded(expanded: boolean): void;
+    render(width: number): string[];
+    invalidate(): void;
+    private diskStamp;
+    private reload;
+    private compose;
+    private bodyLines;
+    private footerLine;
+}

package/dist/clients/attach/render/page-block.js

@@ -0,0 +1,226 @@
+// render/page-block.ts — the transcript home for an inline page.
+//
+// `crtr human send --placement inline` puts a page in THIS conversation, and in
+// crouter the conversation is the attach viewer's transcript. So the page gets a
+// durable block anchored where it was sent, exactly as the assistant's prose is
+// anchored: the inbox stays purely the queue (a page sent `--no-inbox` has no
+// queue entry at all and would otherwise be invisible here), while this block is
+// what the person actually reads.
+//
+// The block renders from the ticket directory on disk, never from the tool
+// result text, so `--replace` revisions and the answer that settles a page both
+// land on the already-placed block when `refresh()` is driven by the viewer's
+// inbox-activity watcher.
+import { statSync } from 'node:fs';
+import { parsePage } from '../../../core/human/page.js';
+import { pageManifestPath, responsePath } from '../../../core/human/convention.js';
+import { pageTicketState, readTicketResult } from '../../../core/human/tickets.js';
+import { renderMarkdownBlockAwareLines } from '../../../core/termrender/termrender.js';
+import { describeSlot, tableMarkdown, terminalAnswerable } from '../../inbox/tui/slots.js';
+import { BOLD, CYAN, DIM, GREEN, RESET, YELLOW, sanitize, singleLine, truncate, wrap } from '../../inbox/tui/ansi.js';
+/** Rows of page body shown while the block is folded; Ctrl+O expands it. */
+const FOLDED_BODY_LINES = 16;
+/**
+ * The inline page a `human send` tool result announces, or undefined for every
+ * other result. Read from the structured CLI record the canvas-preview extension
+ * attaches (`details.crtrPreview`), which is present on both live tool events and
+ * rebuilt snapshot messages — never from the rendered bash text.
+ */
+export function detectInlinePageResult(result) {
+    if (result === null || typeof result !== 'object')
+        return undefined;
+    const details = result['details'];
+    if (details === null || typeof details !== 'object')
+        return undefined;
+    const preview = details['crtrPreview'];
+    if (preview === null || typeof preview !== 'object')
+        return undefined;
+    const record = preview;
+    if (record['path'] !== 'human send')
+        return undefined;
+    const payload = record['result'];
+    if (payload === null || typeof payload !== 'object')
+        return undefined;
+    const fields = payload;
+    const pageId = fields['page_id'];
+    const dir = fields['dir'];
+    if (typeof pageId !== 'string' || typeof dir !== 'string')
+        return undefined;
+    if (fields['placement'] !== 'inline')
+        return undefined;
+    return { pageId, dir };
+}
+function mtimeOf(path) {
+    try {
+        return String(statSync(path).mtimeMs);
+    }
+    catch {
+        return '-';
+    }
+}
+export class PageBlockComponent {
+    pageId;
+    dir;
+    openHint;
+    expanded = false;
+    generation = 0;
+    stamp = '';
+    snapshot;
+    cache;
+    constructor(pageId, dir, openHint) {
+        this.pageId = pageId;
+        this.dir = dir;
+        this.openHint = openHint;
+        this.reload();
+    }
+    /** Re-read the ticket when its request or its result changed on disk. */
+    refresh() {
+        if (this.diskStamp() === this.stamp)
+            return false;
+        this.reload();
+        return true;
+    }
+    /** Ctrl+O global expansion (ChatView.isExpandable duck-type). */
+    setExpanded(expanded) {
+        if (expanded === this.expanded)
+            return;
+        this.expanded = expanded;
+        this.cache = undefined;
+    }
+    render(width) {
+        const w = width > 0 ? width : 80;
+        const cached = this.cache;
+        if (cached !== undefined && cached.width === w && cached.generation === this.generation && cached.expanded === this.expanded) {
+            return cached.lines;
+        }
+        const lines = this.compose(w);
+        this.cache = { width: w, generation: this.generation, expanded: this.expanded, lines };
+        return lines;
+    }
+    invalidate() {
+        this.cache = undefined;
+    }
+    diskStamp() {
+        return `${mtimeOf(pageManifestPath(this.dir))}|${mtimeOf(responsePath(this.dir))}`;
+    }
+    reload() {
+        this.stamp = this.diskStamp();
+        this.generation++;
+        this.cache = undefined;
+        try {
+            const manifest = parsePage(this.dir);
+            const state = pageTicketState(this.dir);
+            const digest = state === 'resolved' ? readTicketResult(this.dir) : null;
+            this.snapshot = {
+                manifest,
+                state,
+                ...(digest?.kind === 'page' ? { answerDigest: digest.summary.replace(/\s+/g, ' ').trim() } : {}),
+            };
+        }
+        catch {
+            // A removed or half-written ticket keeps whatever was last read; a block
+            // that never read one renders its unavailable line instead.
+            if (this.snapshot === undefined)
+                this.snapshot = undefined;
+        }
+    }
+    compose(width) {
+        const snapshot = this.snapshot;
+        if (snapshot === undefined)
+            return ['', `  ${DIM}[page] no longer available${RESET}`, ''];
+        const maxW = Math.min(Math.max(20, width - 4), 100);
+        const out = ['', `  ${BOLD}${CYAN}${truncate(sanitize(singleLine(snapshot.manifest.title)), maxW)}${RESET}`];
+        if (snapshot.manifest.subtitle) {
+            for (const line of wrap(sanitize(snapshot.manifest.subtitle), maxW))
+                out.push(`  ${DIM}${line}${RESET}`);
+        }
+        const body = this.bodyLines(snapshot.manifest, maxW, Math.max(20, width - 4));
+        if (body.length > 0) {
+            out.push('');
+            const shown = this.expanded || body.length <= FOLDED_BODY_LINES ? body : body.slice(0, FOLDED_BODY_LINES);
+            for (const line of shown)
+                out.push(`  ${line}`);
+            if (shown.length < body.length)
+                out.push(`  ${DIM}… +${body.length - shown.length} lines — ctrl+o to expand${RESET}`);
+        }
+        const footer = this.footerLine(snapshot, maxW);
+        if (footer !== undefined)
+            out.push('', `  ${footer}`);
+        out.push('');
+        return out;
+    }
+    bodyLines(manifest, maxW, paneW) {
+        const md = (text) => renderMarkdownBlockAwareLines(text, maxW, paneW);
+        if (manifest.dialect === 'html')
+            return [`${DIM}HTML page — opens in a browser surface${RESET}`];
+        // Display components (Card, Alert, the rest of the shadcn set) are page markup,
+        // not manifest slots, so a page built only from them keeps nothing here a
+        // terminal could draw. Say so rather than paint a title over an empty body.
+        if (manifest.slots.length === 0)
+            return [`${DIM}display-only page — its content renders in Northlight${RESET}`];
+        const lines = [];
+        let priorStep = -1;
+        for (const slot of manifest.slots) {
+            if (manifest.steps > 1 && slot.step !== priorStep) {
+                if (lines.length > 0)
+                    lines.push('');
+                lines.push(`${BOLD}Step ${slot.step + 1}/${manifest.steps}${RESET}`);
+                priorStep = slot.step;
+            }
+            if (lines.length > 0)
+                lines.push('');
+            lines.push(`${BOLD}${truncate(sanitize(singleLine(describeSlot(slot))), maxW)}${RESET}`);
+            const body = slot.config.body;
+            if (typeof body === 'string' && body !== '')
+                lines.push(...md(body));
+            if (!terminalAnswerable(slot)) {
+                lines.push(`${DIM}${sanitize(slot.kind)} — open in Northlight to answer this${RESET}`);
+                continue;
+            }
+            if (slot.kind === 'text') {
+                lines.push(...md(slot.config.initialText));
+            }
+            else if (slot.kind === 'table') {
+                lines.push(...md(tableMarkdown(slot.config)));
+            }
+            else if (slot.kind === 'cards') {
+                for (const card of slot.config.cards ?? []) {
+                    lines.push(`  • ${truncate(sanitize(singleLine(card.subtitle === undefined ? card.title : `${card.title} — ${card.subtitle}`)), Math.max(10, maxW - 4))}`);
+                    if (card.body !== undefined)
+                        for (const line of wrap(sanitize(card.body), Math.max(10, maxW - 6)))
+                            lines.push(`    ${DIM}${line}${RESET}`);
+                }
+            }
+            else if (slot.kind === 'options') {
+                for (const option of slot.config.options) {
+                    lines.push(`  • ${truncate(sanitize(singleLine(option.label)), Math.max(10, maxW - 4))}`);
+                    if (option.description !== undefined)
+                        for (const line of wrap(sanitize(option.description), Math.max(10, maxW - 6)))
+                            lines.push(`    ${DIM}${line}${RESET}`);
+                }
+            }
+            else if (slot.kind === 'chart') {
+                const config = slot.config;
+                const title = config.title ?? `${config.x ?? ''} vs ${(config.y ?? []).map((y) => y.label ?? y.field).join(', ')}`;
+                lines.push(`${DIM}chart — ${sanitize(config.kind ?? 'chart')}: ${sanitize(title)}${RESET}`);
+            }
+        }
+        return lines;
+    }
+    footerLine(snapshot, maxW) {
+        switch (snapshot.state) {
+            case 'pending':
+                return snapshot.manifest.delivery.reply
+                    ? `${YELLOW}▸ awaiting your answer${RESET} ${DIM}— ${sanitize(this.openHint())}${RESET}`
+                    : `${DIM}◦ queued in your inbox — ${sanitize(this.openHint())}${RESET}`;
+            case 'resolved':
+                return snapshot.answerDigest === undefined
+                    ? `${GREEN}✓ answered${RESET}`
+                    : `${GREEN}✓ answered${RESET} ${DIM}— ${truncate(sanitize(snapshot.answerDigest), Math.max(10, maxW - 12))}${RESET}`;
+            case 'canceled':
+                return `${DIM}⊘ canceled${RESET}`;
+            case 'passive':
+                return undefined;
+        }
+    }
+}

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

@@ -15,6 +15,7 @@ import { Text, getCapabilities, hyperlink, truncateToWidth, visibleWidth, wrapTe
 import { homedir } from 'node:os';
 import { isAbsolute, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { normalizeBashJobPurpose } from '../../../core/bash-jobs.js';
 import { TOOL_ICON } from '../../../core/preview-registry.js';
 function str(value) {
     return typeof value === 'string' ? value : '';
@@ -216,18 +217,25 @@ function styleCommandLine(line, theme) {
  *  there is more. Expanded (ctrl+o) it prints every line of the command, wrapped
  *  (never clipped — expanded is the raw truth) into the pane with continuations
  *  hanging under the icon. A line wider than the pane would desync pi-tui's line
- *  accounting against the terminal's own wrapping and garble the frame. */
+ *  accounting against the terminal's own wrapping and garble the frame.
+ *
+ *  FOLDED, a call that supplied a `purpose` shows that clause INSTEAD of the
+ *  command: the fold is a dense index of what the turn did, and the agent's own
+ *  words for why it ran this read better there than `rg -n … | head -30`. The
+ *  command itself is never lost — unfolding (or ctrl+o) shows it verbatim. */
 class BashCallComponent {
     command = '';
+    purpose;
     expanded = false;
     timeout;
     theme;
     /** Nothing is cached across paints (render recomputes from the fields), so
      *  pi's cache-drop hook has nothing to do here. */
     invalidate() { }
-    update(theme, command, expanded, timeout) {
+    update(theme, command, purpose, expanded, timeout) {
         this.theme = theme;
         this.command = command;
+        this.purpose = purpose;
         this.expanded = expanded;
         this.timeout = timeout;
     }
@@ -236,6 +244,9 @@ class BashCallComponent {
         if (!theme)
             return [];
         const icon = theme.fg('accent', TOOL_ICON.bash);
+        if (this.purpose !== undefined) {
+            return [truncateToWidth(`${icon} ${theme.fg('toolOutput', this.purpose)}`, width, '…')];
+        }
         const lines = this.command.split('\n').map((line) => line.trim()).filter((line) => line.length > 0);
         const suffix = this.timeout ? theme.fg('muted', ` (timeout ${this.timeout}s)`) : '';
         if (lines.length === 0)
@@ -286,6 +297,9 @@ export function createCrtrPlainBashToolDefinition(cwd, fold = new FoldedToolCall
             }
             const component = context.lastComponent instanceof BashCallComponent ? context.lastComponent : new BashCallComponent();
             component.update(theme, str(a?.command), 
+            // The purpose stands in for the command only while folded; it is normalized
+            // here because it is model-supplied text painted straight into the frame.
+            fold.folded ? normalizeBashJobPurpose(a?.purpose) ?? undefined : undefined, 
             // Folded wins over ctrl+o expansion: a folded bash is always its one-line form.
             Boolean(context.expanded) && !fold.folded, typeof a?.timeout === 'number' ? a.timeout : undefined);
             return fold.capture(component);

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

@@ -1,5 +1,7 @@
 import { type Component, type TUI } from '@earendil-works/pi-tui';
 import type { AttachPalette } from '../config.js';
+/** The fixed line the plain whip sends — not drawn from `whip_messages`. */
+export declare const GO_FASTER_WHIP_MESSAGE = "Go faster";
 /** A random line, never the one the previous whip used. */
 export declare function randomWhipMessage(messages: readonly string[]): string;
 /** A 20-frame, 12-row header animation that gives the focused agent a playful nudge. */

package/dist/clients/attach/session/whip.js

@@ -306,6 +306,8 @@ const WHIP_FRAMES = [
         ""
     ]
 ];
+/** The fixed line the plain whip sends — not drawn from `whip_messages`. */
+export const GO_FASTER_WHIP_MESSAGE = 'Go faster';
 let lastMessage;
 /** A random line, never the one the previous whip used. */
 export function randomWhipMessage(messages) {