@north-light/crouter 0.3.169 → 0.3.171

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

@@ -0,0 +1,160 @@
+/** Exactly one line retained for each clipped row of an inline-image block. */
+const CLIPPED_IMAGE_ROW = '\x1b[2m⌸ image — scroll to view\x1b[22m';
+const NO_VISIBLE_BLOCKS = { first: -1, last: -1, lastFullyVisible: -1 };
+function isInlineImageBlock(lines) {
+    return lines.some((line) => line.includes('\x1b_G') || line.includes('\x1b]1337;File='));
+}
+/** The first block whose rendered range extends beyond `line`. */
+function firstBlockAfter(source, line, width) {
+    let low = 0;
+    let high = source.blockCount();
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        const end = source.blockStart(middle, width) + source.blockHeight(middle, width);
+        if (end > line)
+            high = middle;
+        else
+            low = middle + 1;
+    }
+    return low;
+}
+export function createTranscriptViewport(source) {
+    const state = { follow: true, anchor: undefined };
+    let lastWidth;
+    let lastRows = 0;
+    let cachedVisibleBlocks = NO_VISIBLE_BLOCKS;
+    let cachedVisibleRevision;
+    /** Resolve the identity anchor only against the source's current measurements. */
+    function resolveTop(width, rows, total) {
+        const bottom = Math.max(0, total - rows);
+        if (state.follow)
+            return bottom;
+        if (!state.anchor) {
+            state.follow = true;
+            return bottom;
+        }
+        const anchoredTop = source.anchorLine(state.anchor, width);
+        if (anchoredTop === undefined) {
+            state.follow = true;
+            state.anchor = undefined;
+            return bottom;
+        }
+        return Math.min(Math.max(0, anchoredTop), bottom);
+    }
+    function visibleRange(width, rows, total, top) {
+        const bottom = Math.min(total, top + rows);
+        if (top >= bottom)
+            return { top, bottom, total, blocks: NO_VISIBLE_BLOCKS };
+        const count = source.blockCount();
+        let index = firstBlockAfter(source, top, width);
+        let first = -1;
+        let last = -1;
+        let lastFullyVisible = -1;
+        while (index < count) {
+            const start = source.blockStart(index, width);
+            if (start >= bottom)
+                break;
+            const height = source.blockHeight(index, width);
+            const end = start + height;
+            if (end > top) {
+                if (first === -1)
+                    first = index;
+                last = index;
+                if (start >= top && end <= bottom)
+                    lastFullyVisible = index;
+            }
+            index++;
+        }
+        return { top, bottom, total, blocks: first === -1 ? NO_VISIBLE_BLOCKS : { first, last, lastFullyVisible } };
+    }
+    function currentSlice() {
+        if (lastWidth === undefined || lastRows <= 0)
+            return undefined;
+        const total = source.totalHeight(lastWidth);
+        const top = resolveTop(lastWidth, lastRows, total);
+        return visibleRange(lastWidth, lastRows, total, top);
+    }
+    return {
+        renderSlice(width, rows) {
+            const viewportRows = Math.max(0, rows);
+            lastWidth = width;
+            lastRows = viewportRows;
+            if (viewportRows === 0) {
+                cachedVisibleBlocks = NO_VISIBLE_BLOCKS;
+                cachedVisibleRevision = source.revision();
+                return [];
+            }
+            const total = source.totalHeight(width);
+            const top = resolveTop(width, viewportRows, total);
+            const slice = visibleRange(width, viewportRows, total, top);
+            const content = [];
+            for (let index = slice.blocks.first; index !== -1 && index <= slice.blocks.last; index++) {
+                const start = source.blockStart(index, width);
+                const lines = source.blockLines(index, width);
+                const height = source.blockHeight(index, width);
+                const end = start + height;
+                const visibleStart = Math.max(0, slice.top - start);
+                const visibleEnd = Math.min(height, slice.bottom - start);
+                if (visibleStart >= visibleEnd)
+                    continue;
+                const partiallyClipped = start < slice.top || end > slice.bottom;
+                if (partiallyClipped && isInlineImageBlock(lines)) {
+                    content.push(...Array(visibleEnd - visibleStart).fill(CLIPPED_IMAGE_ROW));
+                }
+                else {
+                    content.push(...lines.slice(visibleStart, visibleEnd));
+                }
+            }
+            const padded = content.length >= viewportRows
+                ? content.slice(0, viewportRows)
+                : [...Array(viewportRows - content.length).fill(''), ...content];
+            cachedVisibleBlocks = slice.blocks;
+            cachedVisibleRevision = source.revision();
+            return padded;
+        },
+        scrollBy(lines) {
+            if (lastWidth === undefined || lastRows <= 0 || lines === 0)
+                return false;
+            const beforeFollow = state.follow;
+            const beforeAnchor = state.anchor;
+            const total = source.totalHeight(lastWidth);
+            const currentTop = resolveTop(lastWidth, lastRows, total);
+            const bottom = Math.max(0, total - lastRows);
+            const newTop = Math.min(Math.max(0, currentTop + lines), bottom);
+            if (newTop >= bottom) {
+                state.follow = true;
+                state.anchor = undefined;
+            }
+            else {
+                state.follow = false;
+                state.anchor = source.anchorAt(newTop, lastWidth);
+                if (!state.anchor)
+                    state.follow = true;
+            }
+            return state.follow !== beforeFollow || state.anchor !== beforeAnchor;
+        },
+        scrollPage(direction) {
+            const page = Math.max(0, lastRows - 1);
+            return this.scrollBy(direction === 'up' ? -page : page);
+        },
+        goLive() {
+            state.follow = true;
+            state.anchor = undefined;
+        },
+        isLive() {
+            return state.follow;
+        },
+        visibleBlocks() {
+            const revision = source.revision();
+            if (cachedVisibleRevision === revision)
+                return cachedVisibleBlocks;
+            const slice = currentSlice();
+            cachedVisibleBlocks = slice?.blocks ?? NO_VISIBLE_BLOCKS;
+            cachedVisibleRevision = revision;
+            return cachedVisibleBlocks;
+        },
+        invalidate() {
+            source.invalidate();
+        },
+    };
+}

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

@@ -2,10 +2,14 @@ import { type AttachBindingId, type BindingId, type BindingResolution } from '..
 export type { AttachBindingId } from '../../../core/keybindings/index.js';
 export type AttachBindings = BindingResolution<BindingId>;
 export type AttachActions = Record<AttachBindingId, () => void>;
+export declare const ATTACH_VIEWPORT_BINDINGS: readonly ["crtr.attach.scroll.up", "crtr.attach.scroll.down", "crtr.attach.scroll.page-up", "crtr.attach.scroll.page-down", "crtr.attach.scroll.live", "crtr.attach.mouse.toggle", "crtr.attach.copy.message"];
+export type AttachViewportBindingId = typeof ATTACH_VIEWPORT_BINDINGS[number];
+export type AttachViewportActions = Record<AttachViewportBindingId, () => void>;
 export { inboxOpenHint } from '../../../core/keybindings/index.js';
-export declare function matchesAttachBinding(bindings: AttachBindings, id: AttachBindingId, data: string): boolean;
+export declare function matchesAttachBinding(bindings: AttachBindings, id: BindingId, data: string): boolean;
 export declare function dispatchAttachAction(id: AttachBindingId, actions: AttachActions): void;
 export declare function dispatchAttachBinding(bindings: AttachBindings, data: string, actions: AttachActions): boolean;
+export declare function dispatchAttachViewportBinding(bindings: AttachBindings, data: string, actions: AttachViewportActions): boolean;
 export declare function detachHint(bindings: AttachBindings): string | undefined;
 /** Re-resolve the user's binding catalog and republish it to every consumer:
  *  the graph overlay's own snapshot and (in tmux) the crouter-owned tmux

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

@@ -6,6 +6,13 @@
 // literals, so a user's rebind is honored by the viewer and tmux alike.
 import { matchesKey } from '@earendil-works/pi-tui';
 import { ATTACH_CONTROL_BINDINGS, formatBinding, matchesPiTuiInput, } from '../../../core/keybindings/index.js';
+export const ATTACH_VIEWPORT_BINDINGS = [
+    'crtr.attach.scroll.up', 'crtr.attach.scroll.down',
+    'crtr.attach.scroll.page-up', 'crtr.attach.scroll.page-down',
+    'crtr.attach.scroll.live',
+    'crtr.attach.mouse.toggle',
+    'crtr.attach.copy.message',
+];
 export { inboxOpenHint } from '../../../core/keybindings/index.js';
 export function matchesAttachBinding(bindings, id, data) {
     return matchesPiTuiInput(bindings, id, data, (input, gesture) => matchesKey(input, gesture));
@@ -22,6 +29,15 @@ export function dispatchAttachBinding(bindings, data, actions) {
     }
     return false;
 }
+export function dispatchAttachViewportBinding(bindings, data, actions) {
+    for (const actionId of ATTACH_VIEWPORT_BINDINGS) {
+        if (matchesAttachBinding(bindings, actionId, data)) {
+            actions[actionId]();
+            return true;
+        }
+    }
+    return false;
+}
 export function detachHint(bindings) {
     for (const id of ['crtr.attach.clear-or-detach', 'crtr.attach.detach']) {
         if (bindings.gestures(id).length > 0)

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

@@ -5,12 +5,14 @@ import type { NodeMeta } from '../../../core/canvas/types.js';
 import type { BrokerClient } from '../../../core/broker-client/index.js';
 import type { AttachPalette } from '../config.js';
 import type { TitledEditor } from '../input/titled-editor.js';
-/** The bottom-anchored chrome stack plus the scrolling chat, in render order.
+/** The pinned cockpit plus transcript/header regions, in frame render order.
  *  Owned by the layout step; every painter writes into exactly one of these. */
 export interface AttachContainers {
-    /** Scrolling transcript — the only container above the chat/chrome divider. */
+    /** Scrolling transcript source, rendered by the virtualized viewport. */
     readonly chat: Container;
-    /** The themed divider itself (suppressed while the recap widget is present). */
+    /** Pinned recap above the transcript; empty when no recap widget exists. */
+    readonly header: Container;
+    /** The themed transcript/cockpit divider. */
     readonly chrome: Container;
     /** Extension widgets placed `aboveEditor`, including the inactivity brief. */
     readonly aboveWidgets: Container;

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

@@ -0,0 +1,34 @@
+import { type Component, type Terminal } from '@earendil-works/pi-tui';
+import type { TranscriptViewport } from '../render/viewport.js';
+export declare const MIN_TRANSCRIPT_ROWS = 3;
+export declare const HEADER_MAX_ROWS = 6;
+export declare const EDITOR_MIN_ROWS = 1;
+export declare const STATUS_ROWS = 1;
+export type BottomSlot = 'chrome' | 'queued' | 'aboveWidgets' | 'editor' | 'pickerPanel' | 'belowWidgets' | 'reports' | 'footer';
+/** Crop `lines` to `alloc` rows, guaranteeing the CURSOR_MARKER row survives
+ * (§2.1). No marker → the tail is kept. */
+export declare function cropAroundCursor(lines: readonly string[], alloc: number): string[];
+export interface ViewerFrameParts {
+    /** Rendered above the transcript; 0 rows when empty. */
+    header: Component;
+    viewport: TranscriptViewport;
+    /** The bottom slots, in VISUAL order, tagged with their allocation identity
+     * so the allocator can apply the §2.1 priority table. */
+    bottom: readonly {
+        slot: BottomSlot;
+        component: Component;
+    }[];
+}
+/** The TUI's ONE child. Renders exactly `terminal.rows` lines, every frame. */
+export declare class ViewerFrame implements Component {
+    private readonly terminal;
+    private readonly parts;
+    private viewportRows;
+    constructor(terminal: Terminal, parts: ViewerFrameParts);
+    render(width: number): string[];
+    invalidate(): void;
+    /** Rows the transcript viewport got in the last frame — the page size. */
+    lastViewportRows(): number;
+    /** Retain exactly one editor marker if the focused editor rendered one. */
+    private ensureCursorMarker;
+}

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

@@ -0,0 +1,173 @@
+// session/frame.ts — the attach viewer's single full-pane TUI child.
+//
+// The frame owns the pane rectangle: transcript rows are virtualized between a
+// bounded recap header and a cursor-first cockpit. Nothing mounted beneath this
+// component may reach pi-tui as a separate child, or it can reintroduce terminal
+// scrollback and lose the editor's hardware cursor.
+import { CURSOR_MARKER } from '@earendil-works/pi-tui';
+export const MIN_TRANSCRIPT_ROWS = 3;
+export const HEADER_MAX_ROWS = 6;
+export const EDITOR_MIN_ROWS = 1;
+export const STATUS_ROWS = 1;
+/** Crop `lines` to `alloc` rows, guaranteeing the CURSOR_MARKER row survives
+ * (§2.1). No marker → the tail is kept. */
+export function cropAroundCursor(lines, alloc) {
+    const rows = Math.max(0, Math.floor(alloc));
+    if (lines.length <= rows)
+        return lines.slice();
+    if (rows === 0)
+        return [];
+    const marker = lines.findIndex((line) => line.includes(CURSOR_MARKER));
+    if (marker === -1)
+        return lines.slice(-rows);
+    const start = clamp(marker - Math.floor((rows - 1) / 2), 0, lines.length - rows);
+    const cropped = lines.slice(start, start + rows);
+    if (!cropped.some((line) => line.includes(CURSOR_MARKER))) {
+        // This should be unreachable for a positive allocation. Keep the cursor
+        // row rather than silently making pi-tui lose the hardware cursor.
+        reportInvariant('cursor crop discarded CURSOR_MARKER');
+        return [lines[marker]];
+    }
+    return cropped;
+}
+const SLOT_PRIORITY = [
+    'queued',
+    'aboveWidgets',
+    'belowWidgets',
+    'reports',
+    'chrome',
+];
+const SLOT_VISUAL_ORDER = [
+    'chrome',
+    'queued',
+    'aboveWidgets',
+    'editor',
+    'pickerPanel',
+    'belowWidgets',
+    'reports',
+    'footer',
+];
+/** The TUI's ONE child. Renders exactly `terminal.rows` lines, every frame. */
+export class ViewerFrame {
+    terminal;
+    parts;
+    viewportRows = 0;
+    constructor(terminal, parts) {
+        this.terminal = terminal;
+        this.parts = parts;
+    }
+    render(width) {
+        const rows = Math.max(0, this.terminal.rows);
+        const rendered = new Map();
+        for (const { slot, component } of this.parts.bottom)
+            rendered.set(slot, component.render(width));
+        const allocations = new Map();
+        const linesFor = (slot) => rendered.get(slot) ?? [];
+        const allocate = (slot, lines) => {
+            allocations.set(slot, lines);
+        };
+        let remaining = Math.min(rows, Math.max(EDITOR_MIN_ROWS + STATUS_ROWS, rows - MIN_TRANSCRIPT_ROWS));
+        const footerLines = linesFor('footer');
+        const statusAlloc = footerLines.length > 0 && remaining > EDITOR_MIN_ROWS ? STATUS_ROWS : 0;
+        allocate('footer', statusAlloc === 0 ? [] : footerLines.slice(-statusAlloc));
+        remaining -= statusAlloc;
+        const pickerLines = linesFor('pickerPanel');
+        const pickerReserve = pickerLines.length === 0 ? 0 : Math.min(pickerLines.length, Math.floor(remaining / 2));
+        const editorLines = linesFor('editor');
+        const editorAlloc = clamp(editorLines.length, EDITOR_MIN_ROWS, Math.max(EDITOR_MIN_ROWS, remaining - pickerReserve));
+        const editorSlice = cropAroundCursor(editorLines, editorAlloc);
+        allocate('editor', editorSlice);
+        remaining -= editorAlloc;
+        const pickerAlloc = Math.min(pickerLines.length, remaining);
+        allocate('pickerPanel', pickerLines.slice(0, pickerAlloc));
+        remaining -= pickerAlloc;
+        for (const slot of SLOT_PRIORITY) {
+            const lines = linesFor(slot);
+            if (lines.length <= remaining) {
+                allocate(slot, lines);
+                remaining -= lines.length;
+            }
+            else {
+                allocate(slot, []);
+            }
+        }
+        const bottomLines = SLOT_VISUAL_ORDER.flatMap((slot) => allocations.get(slot) ?? []);
+        const editorBottomOffset = SLOT_VISUAL_ORDER
+            .slice(0, SLOT_VISUAL_ORDER.indexOf('editor'))
+            .reduce((count, slot) => count + (allocations.get(slot)?.length ?? 0), 0);
+        let headerLines = this.parts.header.render(width).slice(0, HEADER_MAX_ROWS);
+        if (rows - bottomLines.length - headerLines.length < MIN_TRANSCRIPT_ROWS)
+            headerLines = [];
+        const viewportRows = Math.max(0, rows - headerLines.length - bottomLines.length);
+        this.viewportRows = viewportRows;
+        let viewportLines = this.parts.viewport.renderSlice(width, viewportRows);
+        let frame = [...headerLines, ...viewportLines, ...bottomLines];
+        // A misbehaving viewport is repaired in its own region only: transcript
+        // padding goes directly beneath the header, while excess drops from its top.
+        // The cockpit, including the editor's marker row, is never sliced here.
+        if (frame.length !== rows) {
+            reportInvariant(`frame rendered ${frame.length} rows; expected ${rows}`);
+            viewportLines = fitTranscript(viewportLines, viewportRows);
+            frame = [...headerLines, ...viewportLines, ...bottomLines];
+        }
+        if (frame.length !== rows)
+            reportInvariant(`frame correction rendered ${frame.length} rows; expected ${rows}`);
+        return this.ensureCursorMarker(frame, editorLines, editorSlice, editorBottomOffset, bottomLines.length, rows);
+    }
+    invalidate() {
+        this.parts.header.invalidate();
+        for (const { component } of this.parts.bottom)
+            component.invalidate();
+        this.parts.viewport.invalidate();
+    }
+    /** Rows the transcript viewport got in the last frame — the page size. */
+    lastViewportRows() {
+        return this.viewportRows;
+    }
+    /** Retain exactly one editor marker if the focused editor rendered one. */
+    ensureCursorMarker(frame, editorLines, editorSlice, editorBottomOffset, bottomRows, rows) {
+        const editorMarker = editorLines.find((line) => line.includes(CURSOR_MARKER));
+        const markerCount = countMarkers(frame);
+        if (editorMarker === undefined ? markerCount <= 1 : markerCount === 1)
+            return frame;
+        reportInvariant(editorMarker === undefined
+            ? `frame contains ${markerCount} CURSOR_MARKER sequences without one from the editor`
+            : `frame contains ${markerCount} CURSOR_MARKER sequences; expected exactly one`);
+        const repaired = frame.map(stripCursorMarkers);
+        if (editorMarker === undefined)
+            return repaired;
+        const markerLine = editorSlice.findIndex((line) => line.includes(CURSOR_MARKER));
+        const frameIndex = rows - bottomRows + editorBottomOffset + markerLine;
+        if (markerLine === -1 || frameIndex < 0 || frameIndex >= repaired.length) {
+            reportInvariant('unable to restore editor CURSOR_MARKER in composed frame');
+            return repaired;
+        }
+        const markerAt = editorSlice[markerLine].indexOf(CURSOR_MARKER);
+        const line = repaired[frameIndex];
+        repaired[frameIndex] = `${line.slice(0, markerAt)}${CURSOR_MARKER}${line.slice(markerAt)}`;
+        return repaired;
+    }
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+/** Correct only the viewport allocation: top-pad short content or retain its tail. */
+function fitTranscript(lines, rows) {
+    if (rows === 0)
+        return [];
+    if (lines.length === rows)
+        return lines.slice();
+    if (lines.length > rows)
+        return lines.slice(-rows);
+    return [...Array(rows - lines.length).fill(''), ...lines];
+}
+function countMarkers(lines) {
+    return lines.reduce((count, line) => count + line.split(CURSOR_MARKER).length - 1, 0);
+}
+function stripCursorMarkers(line) {
+    return line.split(CURSOR_MARKER).join('');
+}
+/** Invariants must surface in development without taking down an attached pane. */
+function reportInvariant(message) {
+    console.error(`[attach frame] ${message}`);
+}

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

@@ -2,6 +2,7 @@ import type { AgentSessionEvent } from '@earendil-works/pi-coding-agent';
 import type { BrokerToClient, RpcExtensionUIRequest } from '../../../core/runtime/broker-protocol.js';
 import { type PreviewableCommand } from '../slash/prompt-preview.js';
 import type { AttachSession } from './context.js';
+import type { ToolGroupSummary } from '../../../shared/tool-groups.js';
 export interface FrameEffects {
     /** Fold the frame through the shared reducer and repaint whatever slice of
      *  chrome changed. Runs FIRST for every frame, before any case below. */
@@ -18,6 +19,7 @@ export interface FrameEffects {
         bashEnd: (frame: Extract<BrokerToClient, {
             type: 'bash_end';
         }>) => void;
+        applyToolGroupSummary: (key: string, summary: ToolGroupSummary) => void;
     };
     setNotice: (message: string) => void;
     /** Repaint the status line — for the frames whose footer effect is NOT

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

@@ -127,6 +127,9 @@ export function createFrameHandler(ctx, fx) {
                     fx.attachDialog(frame.pending_dialog);
                 break;
             }
+            case 'tool_group_summary':
+                fx.chat.applyToolGroupSummary(frame.key, frame.summary);
+                break;
             case 'model_changed': {
                 // The broker's own post-set_model/cycle_model announcement (pi emits no
                 // engine event for a model switch) already moved the footer's model

package/dist/clients/attach/session/input-wiring.d.ts

@@ -1,5 +1,7 @@
 import { InputController } from '../input/controller.js';
+import type { ToolDisplayToggle } from '../render/chat-view.js';
 import type { KeybindingsManager } from '@earendil-works/pi-tui';
+import type { CopyTarget } from '../render/transcript-copy.js';
 import type { AttachSession } from './context.js';
 /** What the input layer needs from the rest of the session. Everything here is
  *  a getter or a command — never a value — so nothing can go stale. */
@@ -11,10 +13,10 @@ export interface InputWiringHooks {
     agentDir: () => string | undefined;
     /** True while the reconnect supervisor has classified the node as dormant. */
     isDormant: () => boolean;
-    /** The last assistant message, for `/copy` (ChatView holds it). */
-    lastAssistantText: () => string | undefined;
-    /** Ctrl+O — flip global tool-output expansion; returns the new state. */
-    toggleToolsExpanded: () => boolean;
+    /** Copy a viewer-local transcript target and surface its confirmation. */
+    copyTarget: (target: CopyTarget) => void;
+    /** Ctrl+O — toggles either collapsed summaries or tool-output expansion. */
+    toggleToolsExpanded: () => ToolDisplayToggle;
     /** `/fold-tools` — flip the fold-finished-tool-calls view setting; returns the
      *  new state. */
     toggleFoldTools: () => boolean;
@@ -22,6 +24,10 @@ export interface InputWiringHooks {
     toggleThinking: () => boolean;
     /** `/graph` and the graph keybinding. */
     toggleGraph: () => void;
+    /** `/hotkeys` and the help keybinding. */
+    toggleHelp: () => void;
+    /** `/mouse` — flip mouse wheel reporting and return the new state. */
+    toggleMouse: () => boolean;
     /** `/node-metadata` — open the viewer-owned Inspector dossier popup. */
     openNodeMetadata: () => void;
     /** `/quit` — detach this viewer; the engine keeps running. Must tear down

package/dist/clients/attach/session/input-wiring.js

@@ -13,7 +13,6 @@
 // can only be closed over from inside).
 import { InputController } from '../input/controller.js';
 import { cliClient } from '../../../commands/api-client.js';
-import { writeClipboardText } from '../../../core/clipboard-text.js';
 import { buildLoginPicker, buildLogoutPicker } from '../overlays/auth.js';
 import { defaultAgentDir } from '../config.js';
 /** Build the viewer's InputController with every hook answered. */
@@ -25,16 +24,6 @@ export function createInputController(ctx, km, hooks) {
     // mutate. Every mutating hook below is wired only when this is true; the
     // read-op channel (`onRequest`) and the read-only getters stay wired for all.
     const writable = !remote && role === 'controller';
-    // `/copy` — the last assistant message (ChatView keeps it current from both
-    // the welcome snapshot and the live stream) → the system clipboard.
-    const copyLastAssistant = () => {
-        const text = hooks.lastAssistantText();
-        if (!text) {
-            setNotice('Nothing to copy — no assistant message yet');
-            return;
-        }
-        setNotice(writeClipboardText(text) ? 'Copied last message to clipboard' : 'Copy failed — no clipboard tool found');
-    };
     // Auth pickers — viewer-local OAuth/API-key flows against the SAME auth.json
     // the broker uses (broker + viewer share a filesystem in the tmux-local attach
     // model), so they run entirely in this process and then tell the broker to
@@ -72,14 +61,25 @@ export function createInputController(ctx, km, hooks) {
         remote,
         role,
         onGraph: hooks.toggleGraph,
+        onHelp: hooks.toggleHelp,
         onNodeMetadata: hooks.openNodeMetadata,
         onQuit: hooks.quit,
-        onCopy: copyLastAssistant,
+        onCopy: () => hooks.copyTarget('last-assistant'),
+        onCopyTarget: hooks.copyTarget,
+        onToggleMouse: () => {
+            const on = hooks.toggleMouse();
+            setNotice(on ? 'Mouse: wheel scrolling on' : 'Mouse: off — tmux drag-select and copy-mode restored');
+        },
         onColor: hooks.setChipColor,
         // Global display toggles (Ctrl+O tools / Ctrl+T thinking) — pure render
         // state owned by ChatView, surfaced as a footer notice mirroring pi's
         // status line.
-        onToggleToolsExpand: () => setNotice(hooks.toggleToolsExpanded() ? 'Tool output: expanded' : 'Tool output: collapsed'),
+        onToggleToolsExpand: () => {
+            const result = hooks.toggleToolsExpanded();
+            setNotice(result.kind === 'summaries'
+                ? result.shown ? 'Tool calls: summarized' : 'Tool calls: shown'
+                : result.expanded ? 'Tool output: expanded' : 'Tool output: collapsed');
+        },
         onFoldTools: () => setNotice(hooks.toggleFoldTools()
             ? 'Finished tool calls: folded to one line'
             : 'Finished tool calls: shown in full'),

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

@@ -1,4 +1,4 @@
-import { type AttachBindings } from './bindings.js';
+import { type AttachBindings, type AttachViewportActions } from './bindings.js';
 import type { AttachSession } from './context.js';
 export interface KeyHooks {
     /** The live binding snapshot — re-resolved by `/reload`, so read per key. */
@@ -7,12 +7,15 @@ export interface KeyHooks {
     detachHint: () => string | undefined;
     /** Terminal focus in/out — the roster owns the editor's cursor styling. */
     setPaneFocused: (focused: boolean) => void;
+    /** Scroll actions for this session's transcript viewport. */
+    viewportActions: () => AttachViewportActions;
     /** The roster's chance at a chunk; true when it consumed it. */
     rosterHandleKey: (data: string) => boolean;
     setNotice: (message: string) => void;
     detach: () => void;
     cycleMode: () => void;
     toggleGraph: () => void;
+    toggleHelp: () => void;
     cycleModelLadder: (direction: 'forward' | 'backward') => void;
     inspectLoadedCommand: () => void;
     /** The file-review chord — open the transcript-file picker + review surface. */

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

@@ -3,11 +3,12 @@
 // A TUI input listener fires BEFORE the focused component and before any dialog
 // overlay, so the configured attach actions work regardless of what has focus.
 // That privilege is also the hazard: anything consumed here never reaches the
-// editor. Only terminal focus reports, a private crouter control input, the
-// roster while it holds the cursor, and a configured crtr binding may claim a
-// chunk; each returns ordinary editor input untouched when it does not apply.
+// editor. Only terminal focus reports, a private crouter control input,
+// viewport scroll bindings while the editor has focus, the roster while it holds
+// the cursor, and a configured crtr binding may claim a chunk; each returns
+// ordinary editor input untouched when it does not apply.
 import { extractAttachControlInput } from '../../../core/keybindings/index.js';
-import { dispatchAttachAction, dispatchAttachBinding } from './bindings.js';
+import { dispatchAttachAction, dispatchAttachBinding, dispatchAttachViewportBinding, } from './bindings.js';
 import { FOCUS_IN, FOCUS_OUT } from './focus-events.js';
 /** Press the clear-or-detach binding twice inside this window to detach. */
 const CLEAR_OR_DETACH_MS = 1000;
@@ -31,6 +32,7 @@ export function installGlobalKeys(ctx, hooks) {
         },
         'crtr.mode.cycle': hooks.cycleMode,
         'crtr.attach.graph.toggle': hooks.toggleGraph,
+        'crtr.attach.help.toggle': hooks.toggleHelp,
         // A plain broker frame, so this works locally and remotely alike; the broker gates observers on controller role.
         'crtr.attach.model-ladder.next': () => hooks.cycleModelLadder('forward'),
         'crtr.attach.model-ladder.previous': () => hooks.cycleModelLadder('backward'),
@@ -51,6 +53,9 @@ export function installGlobalKeys(ctx, hooks) {
             dispatchAttachAction(control.actionId, actions);
             return control.remaining.length > 0 ? { data: control.remaining } : { consume: true };
         }
+        // Let focused pickers and overlays retain their native page navigation.
+        if (editor.focused && dispatchAttachViewportBinding(hooks.bindings(), data, hooks.viewportActions()))
+            return { consume: true };
         // Inline subagent scroll+swap: once the editor hands off at its ↓ boundary, ↑/↓ move over the manager/report roster and Enter dives into a node. An inactive roster never intercepts editor input.
         if (hooks.rosterHandleKey(data))
             return { consume: true };

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

@@ -1,8 +1,9 @@
-import { ProcessTerminal, TUI } from '@earendil-works/pi-tui';
-import type { KeybindingsManager } from '@earendil-works/pi-tui';
+import { Container, type KeybindingsManager, type ProcessTerminal, type TUI } from '@earendil-works/pi-tui';
 import type { AttachPalette } from '../config.js';
 import { TitledEditor } from '../input/titled-editor.js';
+import type { TranscriptViewport } from '../render/viewport.js';
 import type { AttachContainers } from './context.js';
+import { ViewerFrame } from './frame.js';
 export interface AttachLayout {
     /** The process terminal behind the TUI — also the owner of the window title
      *  and the negotiated keyboard protocol, both of which the orchestrator uses. */
@@ -10,11 +11,12 @@ export interface AttachLayout {
     readonly tui: TUI;
     readonly containers: AttachContainers;
     readonly editor: TitledEditor;
-    /** Attach the containers to the TUI in render order and focus the editor.
-     *  Deferred to just before `tui.start()` so a signal landing mid-construction
-     *  cannot leave a half-mounted tree on screen. */
+    readonly frame: ViewerFrame;
+    /** Attach the single frame to the TUI and focus the editor. Deferred to just
+     *  before `tui.start()` so a signal landing mid-construction cannot leave a
+     *  half-mounted tree on screen. */
     mount(): void;
 }
-/** Build the TUI, its containers, and the editor. No behavior is wired here;
- *  the orchestrator owns every callback. */
-export declare function createLayout(pal: AttachPalette, km: KeybindingsManager): AttachLayout;
+/** Build the layout around the transcript viewport. The viewer creates the
+ * terminal and chat first because the viewport measures that chat source. */
+export declare function createLayout(procTerminal: ProcessTerminal, tui: TUI, chat: Container, pal: AttachPalette, km: KeybindingsManager, viewport: TranscriptViewport): AttachLayout;