@crouton-kit/crouter 0.3.27 → 0.3.29

package/dist/clients/attach/auth-pickers.js

@@ -0,0 +1,194 @@
+// auth-pickers.ts — native /login and /logout overlays for `crtr attach`.
+//
+// Runs pi's REAL OAuth/API-key login flow locally in the viewer process.
+// Since crtr attach is tmux-local only (viewer + broker = same machine, same
+// filesystem), we can construct a local AuthStorage pointing at the SAME
+// auth.json the broker uses — no socket round-trip needed for auth mutations.
+//
+// The OAuthSelectorComponent (provider picker) and LoginDialogComponent (the
+// actual login flow UI) are pi's own exported components, used verbatim.
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { AuthStorage, ModelRegistry, OAuthSelectorComponent, LoginDialogComponent, } from '@earendil-works/pi-coding-agent';
+/** Build an AuthStorage + ModelRegistry from the broker's agentDir (or pi's
+ *  default). Both point at the SAME auth.json the broker uses — the viewer and
+ *  broker share the filesystem (tmux-local invariant). */
+function buildLocalAuth(agentDir) {
+    const authPath = join(agentDir, 'auth.json');
+    const modelsPath = join(agentDir, 'models.json');
+    const authStorage = AuthStorage.create(authPath);
+    const registry = ModelRegistry.create(authStorage, modelsPath);
+    return { authStorage, registry };
+}
+/** Assemble the AuthSelectorProvider list for the OAuth selector: OAuth providers
+ *  from authStorage.getOAuthProviders() (authType 'oauth') + API-key providers
+ *  derived from the registry's known providers that aren't OAuth (authType 'api_key').
+ *  Mirrors how pi's interactive mode composes its login list. */
+function buildProviderList(authStorage, registry) {
+    const oauthProviders = authStorage.getOAuthProviders();
+    const oauthIds = new Set(oauthProviders.map((p) => p.id));
+    const providers = oauthProviders.map((p) => ({
+        id: p.id,
+        name: p.name,
+        authType: 'oauth',
+    }));
+    // Add API-key providers from the registry that aren't OAuth providers.
+    const allModels = registry.getAll();
+    const seenProviders = new Set(oauthIds);
+    for (const m of allModels) {
+        if (!seenProviders.has(m.provider)) {
+            seenProviders.add(m.provider);
+            providers.push({
+                id: m.provider,
+                name: registry.getProviderDisplayName(m.provider),
+                authType: 'api_key',
+            });
+        }
+    }
+    return providers;
+}
+/** Open the browser with a URL (best-effort; platform-specific). */
+function openBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    execFile(cmd, [url], { timeout: 5_000 }, () => {
+        /* best-effort: browser open is fire-and-forget */
+    });
+}
+/** `/login` — show the provider selector, then run pi's native login flow in
+ *  the viewer. On success, notifies the broker to reload auth via reload_auth.
+ *  Returns a Picker (OAuthSelectorComponent as the overlay). */
+export function buildLoginPicker(tui, agentDir, onAuthReloaded, notify, controls) {
+    const { close, replace } = controls;
+    const { authStorage, registry } = buildLocalAuth(agentDir);
+    const providers = buildProviderList(authStorage, registry);
+    const getAuthStatus = (id) => authStorage.getAuthStatus(id);
+    const onSelect = (providerId) => {
+        const provider = providers.find((p) => p.id === providerId);
+        if (provider === undefined) {
+            notify(`Unknown provider: ${providerId}`);
+            close();
+            return;
+        }
+        // `finish()` is the single idempotent exit for the login dialog: tear the
+        // whole picker down (which restores editor focus), exactly once, no matter
+        // which path (success, failure, or an Esc-cancel that aborts mid-flow) gets
+        // there first. The OAuth/cancel paths resolve through DIFFERENT channels (the
+        // login() promise vs the dialog's onComplete), so the guard prevents a double
+        // close + double notify.
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            close();
+        };
+        const dialog = new LoginDialogComponent(tui, providerId, (success, message) => {
+            // The dialog's own completion (chiefly an Esc-cancel). On a real OAuth
+            // success the login() promise below already finished + notified, so the
+            // settled guard makes this a no-op then.
+            if (settled)
+                return;
+            if (success) {
+                notify(`Logged in to ${provider.name}`);
+                onAuthReloaded();
+            }
+            else {
+                notify(message ? `Login failed: ${message}` : `Login to ${provider.name} was cancelled`);
+            }
+            finish();
+        }, provider.name);
+        // Swap the provider selector for the login dialog IN PLACE — it renders
+        // inline under the editor (same slot as the model picker), not as a centered
+        // overlay. `replace` focuses the dialog; `close()` (via finish) unmounts it.
+        replace(dialog, dialog);
+        if (provider.authType === 'oauth') {
+            const isKnownOAuth = authStorage.getOAuthProviders().some((p) => p.id === providerId);
+            if (!isKnownOAuth) {
+                // An extension-registered provider: its OAuth impl lives in the broker's
+                // registry, not the viewer's local one, so we cannot drive the flow here.
+                dialog.showInfo([
+                    `Provider "${provider.name}" is extension-registered and cannot be logged in`,
+                    `from the viewer (the extension runs in the broker, not here).`,
+                    `Run /login directly in the node's terminal, or log in via the pi CLI.`,
+                ]);
+                // The dialog stays up; an Esc routes through onComplete → finish().
+                return;
+            }
+            authStorage
+                .login(providerId, {
+                onAuth: (info) => {
+                    dialog.showAuth(info.url, info.instructions);
+                    openBrowser(info.url);
+                },
+                onDeviceCode: (info) => {
+                    dialog.showDeviceCode(info);
+                    openBrowser(info.verificationUri);
+                },
+                onPrompt: (prompt) => dialog.showPrompt(prompt.message, prompt.placeholder),
+                onProgress: (message) => {
+                    dialog.showProgress(message);
+                },
+                onManualCodeInput: () => dialog.showManualInput('Paste the code or URL:'),
+                onSelect: async (prompt) => {
+                    const labels = prompt.options.map((o, i) => `${i + 1}. ${o.label}`).join('\n');
+                    const answer = await dialog.showPrompt(`${prompt.message}\n${labels}`, '1');
+                    const idx = parseInt(answer, 10) - 1;
+                    return prompt.options[idx]?.id;
+                },
+                signal: dialog.signal,
+            })
+                .then(() => {
+                if (settled)
+                    return; // a cancel/abort already closed it
+                notify(`Logged in to ${provider.name}`);
+                onAuthReloaded();
+                finish();
+            })
+                .catch((err) => {
+                // An Esc-cancel aborts the flow; the dialog's onComplete already
+                // notified + finished, so only report a genuine error here.
+                if (err?.name !== 'AbortError') {
+                    notify(`Login error: ${String(err?.message ?? err)}`);
+                }
+                finish();
+            });
+        }
+        else {
+            // API-key provider: prompt for the key and persist it locally.
+            dialog
+                .showPrompt(`Enter API key for ${provider.name}:`, 'sk-...')
+                .then((key) => {
+                if (settled)
+                    return;
+                if (key.trim()) {
+                    authStorage.set(providerId, { type: 'api_key', key: key.trim() });
+                    notify(`API key saved for ${provider.name}`);
+                    onAuthReloaded();
+                }
+                else {
+                    notify('No key entered — login cancelled');
+                }
+                finish();
+            })
+                .catch(() => finish());
+        }
+    };
+    const component = new OAuthSelectorComponent('login', authStorage, providers, onSelect, () => close(), getAuthStatus);
+    return { component, focus: component };
+}
+/** `/logout` — show the provider selector in logout mode. On select, calls
+ *  authStorage.logout(providerId) directly, then notifies the broker to reload. */
+export function buildLogoutPicker(agentDir, onAuthReloaded, notify, close) {
+    const { authStorage, registry } = buildLocalAuth(agentDir);
+    const providers = buildProviderList(authStorage, registry);
+    const getAuthStatus = (id) => authStorage.getAuthStatus(id);
+    const onSelect = (providerId) => {
+        const provider = providers.find((p) => p.id === providerId);
+        authStorage.logout(providerId);
+        close();
+        notify(`Logged out of ${provider?.name ?? providerId}`);
+        onAuthReloaded();
+    };
+    const component = new OAuthSelectorComponent('logout', authStorage, providers, onSelect, () => close(), getAuthStatus);
+    return { component, focus: component };
+}

package/dist/clients/attach/canvas-panels.d.ts

@@ -0,0 +1,12 @@
+import type { AttachPalette } from './config-load.js';
+export interface CanvasPanelLines {
+    /** Above-editor manager line(s) — empty for a root node (no manager). */
+    managers: string[];
+    /** Below-editor report row(s) + self's trailing ⚑ asks line — empty when none. */
+    reports: string[];
+}
+/** Build the BASE panel line stacks for `nodeId` from canvas.db (ported verbatim
+ *  from canvas-nav.ts renderBase). `asks` is the per-node pending-ask map the
+ *  caller polls; pass `{}` to omit the ⚑ badges. `palette` (the live theme)
+ *  drives the headers + dim cells; omit it and the panels render uncolored. */
+export declare function buildCanvasPanelLines(nodeId: string, asks: Record<string, number>, palette?: AttachPalette): CanvasPanelLines;

package/dist/clients/attach/canvas-panels.js

@@ -0,0 +1,78 @@
+// canvas-panels.ts — the subscribed-node panel for `crtr attach` (Unit Q).
+//
+// Native reimplementation of canvas-nav.ts's BASE chrome (renderBase), reading
+// the subscription graph DIRECTLY from canvas.db via the shared nav-model layer
+// (no pi extension host, no broker frame). Produces the two line stacks the
+// viewer paints into Containers around the editor:
+//   managers  → ABOVE the editor: this node's manager (its first subscriber).
+//   reports   → BELOW the editor: this node's live reports (active|idle
+//               subscriptions), plus a trailing ⚑ line for self's own asks.
+//
+// Pure: given a node id + the per-node ask map it returns ANSI strings; the
+// caller owns the Containers and the refresh trigger. beginFrame() memoizes the
+// canvas.db reads for this one build pass (mirrors canvas-nav's per-frame cache),
+// so a whole panel rebuild is a single fan-out of disk/db reads.
+import { beginFrame, cNode, managerOf, liveReports, climbRoot, computeSubtreeActivity, navLabel, coloredGlyph, truncate, tokensCell, cycleBadge, childBadge, liveBelowBadge, askBadge, activityCell, YELLOW, RESET, } from '../../core/canvas/nav-model.js';
+/** Column widths for the aligned panel rows (visible columns). name is sized to
+ *  the widest label across BOTH panels (capped); kind is wide enough for the
+ *  longest persona kind (`orchestrator` = 12) so real kinds never truncate;
+ *  tokens is fixed. Both panels share one grid. */
+const KIND_W = 12;
+const TOK_W = 6;
+const NAME_CAP = 22;
+/** Pad to `w`, or ellipsize with `…` when longer (plain text — callers pass
+ *  un-styled labels). */
+function nameCell(s, w) {
+    return s.length > w ? `${s.slice(0, w - 1)}…` : s + ' '.repeat(w - s.length);
+}
+function padStartVisible(s, w) {
+    return s.length >= w ? s.slice(0, w) : ' '.repeat(w - s.length) + s;
+}
+/** Build the BASE panel line stacks for `nodeId` from canvas.db (ported verbatim
+ *  from canvas-nav.ts renderBase). `asks` is the per-node pending-ask map the
+ *  caller polls; pass `{}` to omit the ⚑ badges. `palette` (the live theme)
+ *  drives the headers + dim cells; omit it and the panels render uncolored. */
+export function buildCanvasPanelLines(nodeId, asks, palette) {
+    // Fresh snapshot: drop the previous build's memoized reads so this pass sees
+    // current disk+db state, then read-once within it.
+    beginFrame();
+    // Styling: theme-driven when a palette is passed, plain otherwise (so the
+    // panels still build for a non-attach caller / a test).
+    const muted = palette?.muted ?? ((s) => s);
+    const faint = palette?.faint ?? ((s) => s);
+    // One subtree-activity pass (rooted at the ancestry root) feeds the ⇣N
+    // live-work-below badge on both the manager line and every report row.
+    const activity = computeSubtreeActivity(climbRoot(nodeId), nodeId);
+    // One shared name-column width across BOTH panels so the grids line up.
+    const mgr = managerOf(nodeId);
+    const live = liveReports(nodeId);
+    const gridIds = [...(mgr !== undefined ? [mgr] : []), ...live];
+    const nameW = gridIds.length > 0
+        ? Math.min(NAME_CAP, Math.max(...gridIds.map((id) => navLabel(cNode(id), id).length)))
+        : NAME_CAP;
+    // A node row laid out on the shared grid: glyph · name · kind · tokens · badges.
+    const row = (id) => {
+        const n = cNode(id);
+        const name = nameCell(navLabel(n, id), nameW);
+        const kind = faint(nameCell(n?.kind ?? '', KIND_W));
+        const tokens = muted(padStartVisible(tokensCell(id), TOK_W));
+        const badges = `${cycleBadge(n)}${childBadge(n)}${liveBelowBadge(n, activity.activeBelow)}${askBadge(id, asks)}${activityCell(id, n)}`;
+        return truncate(` ${coloredGlyph(n)} ${name}  ${kind} ${tokens}${badges}`);
+    };
+    // --- managers panel (↑) ---
+    const managers = [];
+    if (mgr !== undefined) {
+        managers.push(row(mgr));
+    }
+    // --- reports panel (↓) ---
+    const reports = [];
+    if (live.length > 0) {
+        for (const id of live)
+            reports.push(row(id));
+    }
+    // Self's own pending asks (no self row in BASE) → a trailing inline line.
+    const selfAsks = asks[nodeId] ?? 0;
+    if (selfAsks > 0)
+        reports.push(` ${YELLOW}⚑ ${selfAsks} pending${RESET}`);
+    return { managers, reports };
+}

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

@@ -1,6 +1,7 @@
 import { Container, type TUI } from '@earendil-works/pi-tui';
 import { type AgentSessionEvent } from '@earendil-works/pi-coding-agent';
 import type { BrokerSnapshot } from '../../core/runtime/broker-protocol.js';
+import type { AttachPalette } from './config-load.js';
 export interface ChatViewOptions {
     /** Working dir used by `ToolExecutionComponent` for path/diff display. Defaults
      *  to the viewer's cwd; T7 may pass the node's working dir for nicer paths. */
@@ -19,6 +20,9 @@ export interface ChatViewOptions {
      *  (queue_update, session_info_changed, thinking_level_changed). The attach
      *  command (T7) wires a footer here; absent → these events are no-ops. */
     onFooterEvent?: (event: AgentSessionEvent) => void;
+    /** Theme palette for the activity spinner / dim status / error lines. Absent →
+     *  the module defaults (faint + ANSI red) are used. */
+    palette?: AttachPalette;
 }
 export declare class ChatView {
     private readonly tui;
@@ -31,10 +35,16 @@ export declare class ChatView {
     private readonly cwd;
     private readonly showImages;
     private readonly imageWidthCells;
-    private readonly hideThinking;
+    private hideThinking;
     private readonly hiddenThinkingLabel;
-    private readonly toolOutputExpanded;
+    private toolOutputExpanded;
     private readonly onFooterEvent;
+    /** Theme-derived colorizers for the activity/status area. */
+    private readonly spinnerStyle;
+    private readonly dimStyle;
+    private readonly errorStyle;
+    /** Bold accent for the expanded crtr-context label. */
+    private readonly labelStyle;
     /** The assistant message component currently being streamed (between
      *  message_start and message_end for an assistant turn). */
     private streamingComponent;
@@ -44,6 +54,10 @@ export declare class ChatView {
     private activityLoader;
     /** While true, `append` skips re-pinning the status container (bulk rebuild). */
     private bulkMode;
+    /** Text of the most recent assistant message, kept current from the welcome
+     *  snapshot AND the live event stream so `/copy` (getLastAssistantText) works
+     *  whether the message arrived before or after attach. */
+    private lastAssistantText;
     constructor(tui: TUI, container: Container, opts?: ChatViewOptions);
     /** Render the full message history from a `welcome` snapshot. Ports pi's
      *  `renderSessionContext` (interactive-mode.js:2553): assistant messages spawn
@@ -55,6 +69,14 @@ export declare class ChatView {
      *  timers die with the process, but if T7 reuses a ChatView across reconnects in
      *  one process it should call this on detach to avoid a leaked interval. */
     dispose(): void;
+    /** Ctrl+O / app.tools.expand — flip global tool-output expansion and apply it to
+     *  every rendered component that supports it. Returns the new expanded state so
+     *  the caller can surface a notice. */
+    toggleToolsExpanded(): boolean;
+    /** Ctrl+T / app.thinking.toggle — flip thinking-block visibility and apply it to
+     *  every assistant message (the in-flight streaming bubble is itself a child of
+     *  the container, so the loop covers it too). Returns the new HIDDEN state. */
+    toggleThinking(): boolean;
     handleEvent(event: AgentSessionEvent): void;
     private addMessageToChat;
     /** Default-path tool component (toolDef undefined → builtin/default rendering). */
@@ -72,6 +94,9 @@ export declare class ChatView {
     private showError;
     /** Extract the tool-call content items from an assistant message. */
     private assistantToolCalls;
+    /** The text of the most recent assistant message, for `/copy`. Undefined when
+     *  no assistant message has been seen (or it had no text content). */
+    getLastAssistantText(): string | undefined;
     /** Concatenate the text blocks of a user message (string or content array). */
     private userMessageText;
 }

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

@@ -22,12 +22,31 @@
 // extensions degrade to the default, which is the decided Phase-4 behavior.
 import { Container, Loader, Spacer, Text } from '@earendil-works/pi-tui';
 import { AssistantMessageComponent, BashExecutionComponent, BranchSummaryMessageComponent, CompactionSummaryMessageComponent, CustomMessageComponent, getMarkdownTheme, parseSkillBlock, SkillInvocationMessageComponent, ToolExecutionComponent, UserMessageComponent, } from '@earendil-works/pi-coding-agent';
-/** `theme` (the live instance) is NOT re-exported by pi's strict `.` map, so the
- *  loaders use small local ANSI styling rather than `theme.fg(...)`. Theme parity
- *  for activity spinners is cosmetic; the message components themselves still use
- *  `getMarkdownTheme()` for full-fidelity rendering. */
-const spinnerStyle = (s) => `\x1b[36m${s}\x1b[39m`; // cyan
-const dimStyle = (s) => `\x1b[2m${s}\x1b[22m`; // dim
+import { ContextMessageComponent } from './context-message.js';
+/** customType stamped on the injected `<crtr-context>` bearings block (mirrors
+ *  CONTEXT_INTRO_CUSTOM_TYPE in canvas-context-intro.ts — kept as a local literal
+ *  so the viewer never imports the in-process extension). */
+const CONTEXT_INTRO_CUSTOM_TYPE = 'crtr-context';
+/** Theme-derived chrome colors (spinner / dim / error) are supplied by the
+ *  attach command via `ChatViewOptions.palette` (built from the live theme in
+ *  config-load.ts). pi does not re-export the raw `theme` instance, so when no
+ *  palette is passed (ChatView used standalone) these defaults stand in: a faint
+ *  dim and ANSI red, matching the palette's own fallbacks. The message components
+ *  themselves still use `getMarkdownTheme()` for full-fidelity rendering. */
+const defaultSpinnerStyle = (s) => `\x1b[2m${s}\x1b[22m`;
+const defaultDimStyle = (s) => `\x1b[2m${s}\x1b[22m`;
+/** A component supports the Ctrl+O global tool-output toggle. Mirrors pi's
+ *  `isExpandable` duck-type (interactive-mode.js): any rendered child carrying a
+ *  `setExpanded(boolean)` method — tool executions, custom/compaction/branch/skill
+ *  message components — participates; everything else (the status container, plain
+ *  text, assistant/user bubbles) is skipped. */
+function isExpandable(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        'setExpanded' in obj &&
+        typeof obj.setExpanded === 'function');
+}
+const defaultErrorStyle = (s) => `\x1b[31m${s}\x1b[39m`;
 export class ChatView {
     tui;
     /** The chat scroll area handed in by the attach command. */
@@ -43,6 +62,12 @@ export class ChatView {
     hiddenThinkingLabel;
     toolOutputExpanded;
     onFooterEvent;
+    /** Theme-derived colorizers for the activity/status area. */
+    spinnerStyle;
+    dimStyle;
+    errorStyle;
+    /** Bold accent for the expanded crtr-context label. */
+    labelStyle = (s) => `\x1b[1m${s}\x1b[22m`;
     /** The assistant message component currently being streamed (between
      *  message_start and message_end for an assistant turn). */
     streamingComponent;
@@ -52,6 +77,10 @@ export class ChatView {
     activityLoader;
     /** While true, `append` skips re-pinning the status container (bulk rebuild). */
     bulkMode = false;
+    /** Text of the most recent assistant message, kept current from the welcome
+     *  snapshot AND the live event stream so `/copy` (getLastAssistantText) works
+     *  whether the message arrived before or after attach. */
+    lastAssistantText;
     constructor(tui, container, opts = {}) {
         this.tui = tui;
         this.container = container;
@@ -62,6 +91,9 @@ export class ChatView {
         this.hiddenThinkingLabel = opts.hiddenThinkingLabel ?? 'Thinking...';
         this.toolOutputExpanded = opts.toolOutputExpanded ?? false;
         this.onFooterEvent = opts.onFooterEvent;
+        this.spinnerStyle = opts.palette?.active ?? defaultSpinnerStyle;
+        this.dimStyle = opts.palette?.muted ?? defaultDimStyle;
+        this.errorStyle = opts.palette?.error ?? defaultErrorStyle;
         this.container.addChild(this.statusContainer);
     }
     // -------------------------------------------------------------------------
@@ -86,6 +118,11 @@ export class ChatView {
             for (let i = 0; i < messages.length; i++) {
                 const message = messages[i];
                 if (message.role === 'assistant') {
+                    // Keep the `/copy` source current from the catch-up transcript too, not
+                    // only the live stream (you usually attach AFTER the last reply landed).
+                    const text = this.userMessageText(message);
+                    if (text.trim())
+                        this.lastAssistantText = text;
                     // If the snapshot caught an IN-FLIGHT assistant turn (state.isStreaming
                     // and this is the trailing, non-terminal assistant message), bind it as
                     // the live streaming component so the relayed message_update/message_end
@@ -148,6 +185,35 @@ export class ChatView {
         this.setActivity(undefined);
     }
     // -------------------------------------------------------------------------
+    // Global display toggles (Ctrl+O / Ctrl+T), driven by the input controller.
+    // Pure client-side render state — no broker round-trip — ported from pi's
+    // `setToolsExpanded` / `toggleThinkingBlockVisibility`.
+    // -------------------------------------------------------------------------
+    /** Ctrl+O / app.tools.expand — flip global tool-output expansion and apply it to
+     *  every rendered component that supports it. Returns the new expanded state so
+     *  the caller can surface a notice. */
+    toggleToolsExpanded() {
+        this.toolOutputExpanded = !this.toolOutputExpanded;
+        for (const child of this.container.children) {
+            if (isExpandable(child))
+                child.setExpanded(this.toolOutputExpanded);
+        }
+        this.tui.requestRender();
+        return this.toolOutputExpanded;
+    }
+    /** Ctrl+T / app.thinking.toggle — flip thinking-block visibility and apply it to
+     *  every assistant message (the in-flight streaming bubble is itself a child of
+     *  the container, so the loop covers it too). Returns the new HIDDEN state. */
+    toggleThinking() {
+        this.hideThinking = !this.hideThinking;
+        for (const child of this.container.children) {
+            if (child instanceof AssistantMessageComponent)
+                child.setHideThinkingBlock(this.hideThinking);
+        }
+        this.tui.requestRender();
+        return this.hideThinking;
+    }
+    // -------------------------------------------------------------------------
     // Live stream: the 15-of-17-case handleEvent port (turn_start/turn_end no-op,
     // exactly as interactive pi falls through default for those two).
     // -------------------------------------------------------------------------
@@ -199,6 +265,13 @@ export class ChatView {
             case 'message_end': {
                 if (event.message.role !== 'assistant')
                     break;
+                // Stash the completed reply's text for `/copy` (skip aborted/error turns,
+                // whose text is partial or absent).
+                if (event.message.stopReason !== 'aborted' && event.message.stopReason !== 'error') {
+                    const text = this.userMessageText(event.message);
+                    if (text.trim())
+                        this.lastAssistantText = text;
+                }
                 if (this.streamingComponent) {
                     const stopReason = event.message.stopReason;
                     let errorMessage = event.message.errorMessage;
@@ -328,6 +401,15 @@ export class ChatView {
             }
             case 'custom': {
                 if (message.display) {
+                    // The <crtr-context> bearings block folds to a one-liner under Ctrl+O
+                    // (the broker runs its renderer extension, so reimplement it natively).
+                    if (message.customType === CONTEXT_INTRO_CUSTOM_TYPE) {
+                        this.append(new ContextMessageComponent(this.userMessageText(message), this.toolOutputExpanded, this.dimStyle, 
+                        // Bold + active accent, so the [crtr context] label reads as a
+                        // distinct color against the dim rest of the line.
+                        (s) => this.spinnerStyle(this.labelStyle(s))));
+                        break;
+                    }
                     // No extension renderer in the viewer → default custom-message render.
                     const component = new CustomMessageComponent(message, undefined, getMarkdownTheme());
                     component.setExpanded(this.toolOutputExpanded);
@@ -406,11 +488,12 @@ export class ChatView {
         this.setActivity(undefined);
         this.streamingComponent = undefined;
         this.pendingTools.clear();
+        this.lastAssistantText = undefined;
         this.container.clear();
         this.container.addChild(this.statusContainer);
     }
     makeLoader(message) {
-        return new Loader(this.tui, spinnerStyle, dimStyle, message);
+        return new Loader(this.tui, this.spinnerStyle, this.dimStyle, message);
     }
     /** Swap the single active activity indicator (working/compaction/retry). */
     setActivity(loader) {
@@ -422,11 +505,11 @@ export class ChatView {
     }
     showStatus(message) {
         this.append(new Spacer(1));
-        this.append(new Text(dimStyle(message), 1, 0));
+        this.append(new Text(this.dimStyle(message), 1, 0));
     }
     showError(message) {
         this.append(new Spacer(1));
-        this.append(new Text(`\x1b[31m${message}\x1b[39m`, 1, 0));
+        this.append(new Text(this.errorStyle(message), 1, 0));
     }
     /** Extract the tool-call content items from an assistant message. */
     assistantToolCalls(message) {
@@ -435,6 +518,12 @@ export class ChatView {
             return [];
         return content.filter((c) => typeof c === 'object' && c !== null && c.type === 'toolCall');
     }
+    /** The text of the most recent assistant message, for `/copy`. Undefined when
+     *  no assistant message has been seen (or it had no text content). */
+    getLastAssistantText() {
+        const t = this.lastAssistantText?.trim();
+        return t ? t : undefined;
+    }
     /** Concatenate the text blocks of a user message (string or content array). */
     userMessageText(message) {
         const content = message.content;

package/dist/clients/attach/clipboard-image.d.ts

@@ -1,16 +1,55 @@
 import type { ImageContent } from '@earendil-works/pi-ai';
-/** A clipboard image ready to attach, plus an optional human-readable note about
- *  the resize (from pi's `formatDimensionNote`) for the controller to surface. */
+/** A clipboard image ready to attach, plus an optional note for the controller
+ *  to surface — either a resize note (from pi's `formatDimensionNote`) or, when
+ *  no image was attached, the reason (dropped over the cap, or no clipboard
+ *  tool / read failure). */
 export interface ClipboardImageResult {
     /** Ready to push into a `prompt`/`steer`/`follow_up` frame's `images?`. ABSENT
-     *  when the image was read but DROPPED (a fallback exceeded MAX_BYTES base64);
-     *  `note` then carries the drop reason and the caller attaches nothing. */
+     *  when the image was read but DROPPED (a fallback exceeded MAX_BYTES base64),
+     *  or when there was no image to read but a precise reason is worth surfacing;
+     *  `note` then carries that reason and the caller attaches nothing. */
     image?: ImageContent;
     /** Either a resize note ("Resized from 4032×3024 to 1568×1176", present only
-     *  when resized) or, when `image` is absent, the reason the image was dropped. */
+     *  when resized) or, when `image` is absent, the reason no image was attached. */
     note?: string;
 }
-/** Read + resize the current clipboard image. Returns `null` when there is no
- *  image, no clipboard tool, or the read fails (all best-effort — the caller
- *  shows a brief notice and carries on). */
+/** Persist a (already-resized) clipboard image to a stable temp file and return
+ *  its absolute path, so the attach editor can drop the PATH inline into the
+ *  prompt instead of inlining base64 the agent can't see. The broker runs on the
+ *  same host, so a tmpdir path is readable by the engine. */
+export declare function writeClipboardImageToFile(image: ImageContent): string;
+/** Read + resize the current clipboard image. Returns `null` ONLY when the
+ *  clipboard genuinely holds no image; a `note`-only result means there is a
+ *  precise reason to surface (no clipboard tool, read failure, or an over-cap
+ *  drop). All best-effort — the caller shows a brief notice and carries on. */
 export declare function readClipboardImage(): Promise<ClipboardImageResult | null>;
+interface RawImage {
+    bytes: Buffer;
+    mimeType: string;
+}
+/** Outcome of the raw clipboard read, distinguishing the three cases the caller
+ *  must tell apart: `image` present → got bytes; `note` present → no image AND a
+ *  precise reason to surface (no clipboard tool / read failure); both absent →
+ *  the clipboard genuinely holds no image. */
+export interface RawReadOutcome {
+    image?: RawImage;
+    note?: string;
+}
+/** Result of probing one clipboard tool, distinguishing a MISSING binary (so the
+ *  caller can say "no clipboard tool") from a tool that ran but produced no image
+ *  (`bytes` absent, `missing` false → genuinely empty). */
+export interface RunResult {
+    /** Tool stdout when it produced non-empty output. */
+    bytes?: Buffer;
+    /** The binary was not found on PATH (ENOENT). */
+    missing?: boolean;
+}
+/** Pure macOS dispatch (the regression-test seam): try `pngpaste` if present,
+ *  else fall through to the native osascript read — a missing `pngpaste` must
+ *  NOT collapse to "no image", which was the stock-Mac bug. */
+export declare function selectMacOutcome(runTool: (command: string, args: string[]) => RunResult, readNative: () => RawReadOutcome): RawReadOutcome;
+/** Pure Linux dispatch (the regression-test seam): Wayland (`wl-paste`) first,
+ *  then X11 (`xclip`), PNG then JPEG. If NO tool binary was found, surface a
+ *  precise "install …" note; if a tool ran but found no image, report empty. */
+export declare function selectLinuxOutcome(runTool: (command: string, args: string[]) => RunResult, wayland: boolean): RawReadOutcome;
+export {};