@crouton-kit/crouter 0.3.28 → 0.3.29

package/dist/clients/attach/pickers.js

@@ -0,0 +1,171 @@
+// pickers.ts — native interactive pickers for `crtr attach`, built against the
+// operator-view wire contract (broker read-op `data` frames). Each builder turns
+// a serialized picker payload into the REAL pi `*SelectorComponent`, wired so a
+// selection dispatches the SAME command frame the text-arg slash path sends and
+// `close()` tears the overlay down. InputController owns the overlay lifecycle
+// (showOverlay/dismiss/focus) and the async data fetch; these are pure builders.
+//
+// FOCUS (load-bearing): some selectors put `handleInput` on an INNER list, not
+// the outer Container (UserMessageSelectorComponent → getMessageList(),
+// SettingsSelectorComponent → getSettingsList()). pi-tui drops every keystroke
+// when the focused component has no `handleInput`, so each builder returns BOTH
+// the overlay `component` AND the `focus` target the caller must focus — exactly
+// as pi's own interactive-mode does (`{ component, focus }`).
+//
+// R1 (contract): the tree/fork/settings payloads are PURE DATA — their selectors
+// build verbatim, no reconstruction. The MODEL picker's `ModelSelectorComponent`
+// needs a live `ModelRegistry`/`SettingsManager`: we feed the REAL component a
+// minimal in-memory `SettingsManager` plus a tiny `ModelRegistry` adapter (the
+// component calls only refresh/getError/getAvailable/find — verified against
+// model-selector.js), preserving its full search + scope-toggle UI without
+// crossing engine state over the socket. The SESSION picker reconstructs
+// faithfully from async loaders (no shim). The SCOPED-MODELS component is NOT
+// re-exported by pi (through 0.79.1) AND has no mutation frame in the contract,
+// so it renders read-only via a pi-tui SelectList.
+//
+// pi pin is `^0.79.1` (a RANGE): the duck-typed registry adapter relies on the
+// component's current 4-method registry surface — a future 0.79.x adding a
+// registry call would surface at runtime (caught by live verification).
+import { SelectList, } from '@earendil-works/pi-tui';
+import { getSelectListTheme, ModelSelectorComponent, SessionSelectorComponent, SettingsSelectorComponent, TreeSelectorComponent, UserMessageSelectorComponent, SettingsManager, } from '@earendil-works/pi-coding-agent';
+/** A minimal `ModelRegistry` for `ModelSelectorComponent`: the component calls
+ *  only `refresh()`, `getError()`, `getAvailable()`, and `find()` (verified
+ *  against pi `model-selector.js`). We satisfy exactly those from the wire
+ *  payload — no auth/registry state crosses the socket — and cast to the nominal
+ *  class the ctor wants. */
+function modelRegistryAdapter(all, available) {
+    const adapter = {
+        refresh() { },
+        getError() {
+            return undefined;
+        },
+        getAvailable() {
+            return available;
+        },
+        find(provider, id) {
+            return all.find((m) => m.provider === provider && m.id === id);
+        },
+    };
+    return adapter;
+}
+/** `/model` (and ctrl+l) — the real model selector with search + scope toggle.
+ *  Select → `set_model` with the resolved `provider/id` (the broker's
+ *  `findModelSpec` requires that form). */
+export function buildModelPicker(tui, data, send, close) {
+    const all = data.models;
+    const availableSet = new Set(data.availableIds);
+    const available = all.filter((m) => availableSet.has(`${m.provider}/${m.id}`));
+    const current = data.current
+        ? all.find((m) => m.provider === data.current.provider && m.id === data.current.id)
+        : undefined;
+    const component = new ModelSelectorComponent(tui, current, SettingsManager.inMemory(), modelRegistryAdapter(all, available), data.scopedModels, (model) => {
+        send({ type: 'set_model', model: `${model.provider}/${model.id}` });
+        close();
+    }, () => close());
+    return { component, focus: component };
+}
+/** `/resume` — the real session selector. Reconstructs from async loaders that
+ *  fetch each scope on demand (cwd is pre-fetched so the current-session marker
+ *  shows immediately; the `all` scope loads only on toggle). Select →
+ *  `switch_session`. Rename/delete are out of scope (no command frame). */
+export function buildSessionPicker(tui, prefetchedCwd, request, keybindings, send, close) {
+    const revive = (d) => d.sessions.map((s) => ({ ...s, created: new Date(s.created), modified: new Date(s.modified) }));
+    let firstCwd = true;
+    const currentLoader = async () => {
+        if (firstCwd) {
+            firstCwd = false;
+            return revive(prefetchedCwd);
+        }
+        return revive((await request({ type: 'list_sessions', scope: 'cwd' })));
+    };
+    const allLoader = async () => revive((await request({ type: 'list_sessions', scope: 'all' })));
+    const component = new SessionSelectorComponent(currentLoader, allLoader, (path) => {
+        send({ type: 'switch_session', path });
+        close();
+    }, () => close(), () => close(), () => tui.requestRender(), { showRenameHint: false, keybindings: keybindings }, prefetchedCwd.currentSessionFile);
+    return { component, focus: component };
+}
+/** `/tree` — the real tree navigator (pure data). Select → `navigate_tree`.
+ *  Label-edit is out of scope (no command frame) → no `onLabelChange`. */
+export function buildTreePicker(tui, data, send, close) {
+    const terminalHeight = process.stdout.rows ?? 24;
+    const component = new TreeSelectorComponent(data.tree, data.currentLeafId, terminalHeight, (entryId) => {
+        send({ type: 'navigate_tree', targetId: entryId });
+        close();
+    }, () => close());
+    return { component, focus: component };
+}
+/** `/fork` — the real prior-user-message selector (pure data, from
+ *  `get_tree.forkPoints`). Select → `fork`. The outer component has no
+ *  `handleInput`; the inner `getMessageList()` does (focus target). */
+export function buildForkPicker(data, send, close) {
+    const component = new UserMessageSelectorComponent(data.forkPoints, (entryId) => {
+        send({ type: 'fork', entryId });
+        close();
+    }, () => close());
+    return { component, focus: component.getMessageList() };
+}
+/** `/settings` — the real settings menu (the wire `settings` IS a SettingsConfig
+ *  superset). Only the contract-enumerated mutations are wired: thinking level →
+ *  `set_thinking_level`, auto-compact → `set_auto_compaction`. Every other toggle
+ *  has no command frame (out of scope), so its callback notifies rather than
+ *  silently lying that the change took. The theme submenu is viewer-local (CTO).
+ *  The outer component has no `handleInput`; `getSettingsList()` is the focus
+ *  target. */
+export function buildSettingsPicker(data, send, close, notify) {
+    const out = () => notify('Only thinking level + auto-compaction are adjustable over view.sock');
+    const callbacks = {
+        onThinkingLevelChange: (level) => send({ type: 'set_thinking_level', level }),
+        onAutoCompactChange: (enabled) => send({ type: 'set_auto_compaction', enabled }),
+        onCancel: () => close(),
+        onShowImagesChange: out,
+        onImageWidthCellsChange: out,
+        onAutoResizeImagesChange: out,
+        onBlockImagesChange: out,
+        onEnableSkillCommandsChange: out,
+        onSteeringModeChange: out,
+        onFollowUpModeChange: out,
+        onTransportChange: out,
+        onHttpIdleTimeoutMsChange: out,
+        onThemeChange: out,
+        onHideThinkingBlockChange: out,
+        onCollapseChangelogChange: out,
+        onEnableInstallTelemetryChange: out,
+        onDoubleEscapeActionChange: out,
+        onTreeFilterModeChange: out,
+        onShowHardwareCursorChange: out,
+        onEditorPaddingXChange: out,
+        onAutocompleteMaxVisibleChange: out,
+        onQuietStartupChange: out,
+        onDefaultProjectTrustChange: out,
+        onClearOnShrinkChange: out,
+        onShowTerminalProgressChange: out,
+        onWarningsChange: out,
+    };
+    const component = new SettingsSelectorComponent(data.settings, callbacks);
+    return { component, focus: component.getSettingsList() };
+}
+/** `/scoped-models` — READ-ONLY via a pi-tui SelectList. CONTRACT GAP: pi (through
+ *  0.79.1) does not re-export `ScopedModelsSelectorComponent`, and the contract
+ *  exposes no command frame for its enable/disable/persist mutations, so a
+ *  faithful editable picker is not buildable in scope. This shows the registry
+ *  with the enabled set marked; select notifies that toggling is unsupported. */
+export function buildScopedModelsPicker(data, close, notify) {
+    const enabled = data.enabledModelIds;
+    const isEnabled = (m) => {
+        if (enabled === null)
+            return true; // null = no scoping, every model cycles
+        const ref = `${m.provider}/${m.id}`;
+        return enabled.includes(ref) || enabled.includes(m.id) || enabled.includes('*');
+    };
+    const items = data.allModels.map((m) => ({
+        value: `${m.provider}/${m.id}`,
+        label: `${isEnabled(m) ? '✓' : ' '} ${m.provider}/${m.id}`,
+        description: m.name,
+    }));
+    const theme = getSelectListTheme();
+    const list = new SelectList(items, 12, theme);
+    list.onSelect = () => notify("Enabling/disabling scoped models isn't supported over view.sock yet");
+    list.onCancel = () => close();
+    return { component: list, focus: list };
+}

package/dist/clients/attach/slash-commands.d.ts

@@ -21,6 +21,28 @@ export interface SlashContext {
      *  registers `/graph` as a stub that calls this hook. Unit C/Q owns the overlay
      *  itself and populates this; when absent `/graph` notifies it isn't wired yet. */
     onGraph?: () => void;
+    /** Detach this viewer (`/quit`). A viewer quit DETACHES — it tears down the
+     *  local TUI/socket and leaves the shared engine running. Wired by attach-cmd to
+     *  `teardown('detach')`; without it `/quit` cannot actually exit (just sending
+     *  `bye` makes the broker drop the socket, which the viewer treats as a dropped
+     *  connection and reconnects). */
+    onQuit?: () => void;
+    /** Copy the last assistant message to the clipboard (`/copy`). Wired by
+     *  attach-cmd (it owns the ChatView that holds the text + the clipboard writer). */
+    onCopy?: () => void;
+    /** OPTIONAL native-picker openers — the InputController fills these from its
+     *  read-op request channel. When absent (channel unwired) the value-picker
+     *  builtins fall back to the text-arg notice. */
+    openModelPicker?: () => void;
+    openSessionPicker?: () => void;
+    openForkPicker?: () => void;
+    openTreePicker?: () => void;
+    openSettingsPicker?: () => void;
+    openScopedModelsPicker?: () => void;
+    /** Open the native /login provider selector. */
+    openLoginPicker?: () => void;
+    /** Open the native /logout provider selector. */
+    openLogoutPicker?: () => void;
 }
 /** Canvas slash-commands — reimplemented NATIVE in the viewer (the canvas chrome
  *  pi-extensions cannot load here; see findings-chrome-parity.md Feature 3). Each

package/dist/clients/attach/slash-commands.js

@@ -7,23 +7,23 @@
 // doesn't recognize) fall through to be sent as a `prompt` for the engine's
 // extension runner to handle.
 //
-// SELECTORS — the Phase-4 reality. The plan called for `/model`, `/resume`,
-// `/fork`, `/tree`, `/settings` to open pi's exported `*SelectorComponent`s. The
-// authoritative 0.78.1 .d.ts shows those components require ENGINE-side state a
-// socket-only viewer does not have (`ModelSelectorComponent` needs the
-// `ModelRegistry` + `SettingsManager`; `SessionSelectorComponent` needs session
-// loaders; `TreeSelectorComponent` needs the `SessionTreeNode[]` tree), and the
-// §1.2 command-frame floor set exposes NO read op to fetch any of it. So in
-// Phase 4 these resolve via a TEXT ARGUMENT — `/model <id>`, `/resume <path>`,
-// `/fork <entryId>`, `/tree <entryId>` — which sends the SAME resolved value the
-// selector would have, i.e. zero engine capability is lost; only the interactive
-// picker UI waits for a future read op. A no-arg invocation shows a one-line
-// notice with the arg form. (This protocol gap is reported up to the parent.)
+// SELECTORS — native interactive pickers. `/model`, `/resume`, `/fork`, `/tree`,
+// `/settings`, `/scoped-models` open pi's real `*SelectorComponent`s as overlays,
+// fed by the operator-view read-op `data` frames (broker-protocol) over the
+// socket. With no arg they open the picker (via the `openXPicker` SlashContext
+// callbacks the InputController exposes, fed by its read-op request channel —
+// which attach-cmd MUST wire via `onRequest: (f) => socket.request(f)`). With an
+// arg the same resolved value is sent directly (`/model <provider/id>`, `/resume
+// <path>`, `/fork <entryId>`, `/tree <entryId>`) without the UI. If the request
+// channel is unwired the picker degrades to the arg-form notice. (Verified
+// against pi 0.79.1 — `ScopedModelsSelectorComponent` is the one selector pi does
+// not re-export, so /scoped-models renders read-only via a SelectList.)
 //
 // SCOPED OUT (review m2 — no engine method): `/login`, `/logout`, `/share`,
 // `/trust` — a brief "not supported in attach" notice, never a frame.
 import { execFile } from 'node:child_process';
 import { BUILTIN_SLASH_COMMANDS } from '../../core/runtime/pi-vendored.js';
+import { surfaceTmuxStyleArgs } from '../../core/runtime/surface-bg.js';
 /** Canvas slash-commands — reimplemented NATIVE in the viewer (the canvas chrome
  *  pi-extensions cannot load here; see findings-chrome-parity.md Feature 3). Each
  *  ports the action of its extension: `/promote` ← canvas-commands.ts, `/resume-node`
@@ -39,7 +39,7 @@ export const CANVAS_SLASH_COMMANDS = [
 ];
 const CANVAS_NAMES = new Set(CANVAS_SLASH_COMMANDS.map((c) => c.name));
 /** Builtins with no Phase-4 engine method — scoped out (review m2). */
-const SCOPED_OUT = new Set(['login', 'logout', 'share', 'trust']);
+const SCOPED_OUT = new Set(['trust']);
 /** Valid `/settings thinking` levels — the `SetThinkingLevelFrame['level']`
  *  union (= AgentSession['thinkingLevel'], pi-agent-core ThinkingLevel),
  *  mirrored as a runtime set so an invalid arg is rejected with the options
@@ -95,6 +95,13 @@ export function dispatchSlashCommand(text, ctx) {
             return true;
         case 'quit':
             // A viewer "quit" DETACHES — the shared engine keeps running (one-writer).
+            // onQuit tears the viewer down locally (which sends `bye` itself). Falling
+            // back to a bare `bye` would just make the broker close the socket, which
+            // the viewer reconnects to — so the detach MUST go through onQuit.
+            if (ctx.onQuit) {
+                ctx.onQuit();
+                return true;
+            }
             ctx.send({ type: 'bye' });
             ctx.notify('Detaching — the engine keeps running');
             return true;
@@ -116,27 +123,34 @@ export function dispatchSlashCommand(text, ctx) {
                 return usage(ctx, '/import <path-to-session.jsonl>');
             ctx.send({ type: 'switch_session', path: arg });
             return true;
-        // --- value-picker builtins: arg form (selector deferred, see header) ---
+        // --- value-picker builtins: native picker (no arg) OR direct value (arg) ---
         case 'model':
             if (!arg)
-                return pickerHint(ctx, 'model', '/model <id>');
+                return openOrHint(ctx.openModelPicker, ctx, 'model', '/model <provider/id>');
             ctx.send({ type: 'set_model', model: arg });
             return true;
         case 'resume':
             if (!arg)
-                return pickerHint(ctx, 'session', '/resume <session-path>');
+                return openOrHint(ctx.openSessionPicker, ctx, 'session', '/resume <session-path>');
             ctx.send({ type: 'switch_session', path: arg });
             return true;
         case 'fork':
             if (!arg)
-                return pickerHint(ctx, 'fork point', '/fork <entryId>');
+                return openOrHint(ctx.openForkPicker, ctx, 'fork point', '/fork <entryId>');
             ctx.send({ type: 'fork', entryId: arg });
             return true;
         case 'tree':
             if (!arg)
-                return pickerHint(ctx, 'tree', '/tree <entryId>');
+                return openOrHint(ctx.openTreePicker, ctx, 'tree', '/tree <entryId>');
             ctx.send({ type: 'navigate_tree', targetId: arg });
             return true;
+        case 'scoped-models':
+            if (ctx.openScopedModelsPicker) {
+                ctx.openScopedModelsPicker();
+                return true;
+            }
+            ctx.notify('The scoped-models view needs the read-op channel, which this viewer has not wired');
+            return true;
         // --- settings (sub-command form; interactive menu needs read ops) ------
         case 'settings':
             return handleSettings(arg, ctx);
@@ -144,12 +158,44 @@ export function dispatchSlashCommand(text, ctx) {
         case 'session':
             ctx.notify(describeSession(ctx.state));
             return true;
-        // --- recognized builtins with no Phase-4 wire path --------------------
         case 'copy':
+            // Copy the last assistant message to the clipboard — viewer-owned (the text
+            // is in the ChatView; no engine round-trip). attach-cmd does the actual copy.
+            if (ctx.onCopy) {
+                ctx.onCopy();
+                return true;
+            }
+            ctx.notify('/copy is not available in this viewer');
+            return true;
+        // --- auth commands — viewer-local OAuth/API-key flows ------------------
+        case 'login':
+            if (ctx.openLoginPicker) {
+                ctx.openLoginPicker();
+                return true;
+            }
+            ctx.notify('/login is not available in this viewer');
+            return true;
+        case 'logout':
+            if (ctx.openLogoutPicker) {
+                ctx.openLogoutPicker();
+                return true;
+            }
+            ctx.notify('/logout is not available in this viewer');
+            return true;
+        // --- share / clone / changelog -----------------------------------------
+        case 'share':
+            ctx.send({ type: 'share' });
+            ctx.notify('Sharing session…');
+            return true;
+        case 'clone':
+            ctx.send({ type: 'clone' });
+            ctx.notify('Cloning session…');
+            return true;
         case 'changelog':
+            ctx.notify('/changelog: see https://github.com/earendil-works/pi for release notes (no bundled changelog in this build)');
+            return true;
+        // --- recognized builtins with no Phase-4 wire path --------------------
         case 'hotkeys':
-        case 'scoped-models':
-        case 'clone':
             ctx.notify(`/${name} is not available in attach (Phase 4)`);
             return true;
         default:
@@ -295,7 +341,7 @@ function openView(arg, ctx) {
  *  screen and closes itself when the command exits, dropping back to this pane. */
 function popup(cmd) {
     try {
-        execFile('tmux', ['display-popup', '-E', '-w', '90%', '-h', '85%', cmd], () => {
+        execFile('tmux', ['display-popup', '-E', '-w', '90%', '-h', '85%', ...surfaceTmuxStyleArgs(), cmd], () => {
             /* best-effort: popup is self-contained */
         });
     }
@@ -316,6 +362,16 @@ function pickerHint(ctx, what, form) {
     ctx.notify(`Interactive ${what} picker isn't available over view.sock yet — use ${form}`);
     return true;
 }
+/** Open a native picker if its opener is wired; otherwise fall back to the
+ *  text-arg hint. Keeps every value-picker builtin working even when the
+ *  read-op request channel is absent. */
+function openOrHint(open, ctx, what, form) {
+    if (open) {
+        open();
+        return true;
+    }
+    return pickerHint(ctx, what, form);
+}
 function handleSettings(arg, ctx) {
     const [sub, ...rest] = arg.split(/\s+/);
     const value = rest.join(' ').trim();
@@ -335,12 +391,22 @@ function handleSettings(arg, ctx) {
         case 'auto-compaction':
             ctx.send({ type: 'set_auto_compaction', enabled: parseBool(value) });
             return true;
+        case '':
+            // Bare `/settings` opens the native settings menu (falls back to the
+            // sub-command summary when the picker channel is unwired).
+            if (ctx.openSettingsPicker) {
+                ctx.openSettingsPicker();
+                return true;
+            }
+            return settingsSummary(ctx);
         default:
-            ctx.notify('Settings: /settings thinking <level> | auto-retry on|off | auto-compaction on|off ' +
-                '(the interactive settings menu needs data not exposed over view.sock in Phase 4)');
-            return true;
+            return settingsSummary(ctx);
     }
 }
+function settingsSummary(ctx) {
+    ctx.notify('Settings: /settings thinking <level> | auto-retry on|off | auto-compaction on|off');
+    return true;
+}
 function parseBool(value) {
     return /^(on|true|yes|1|enabled?)$/i.test(value.trim());
 }

package/dist/clients/attach/titled-editor.d.ts

@@ -0,0 +1,33 @@
+import { CustomEditor } from '@earendil-works/pi-coding-agent';
+/** Thinking levels pi cycles through (shift+tab), lowest → highest budget. */
+export type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+/** The default (thinking `off`) title chip: reverse video + a space of padding
+ *  each side, so the name reads as a label sitting on the border rule. Used as
+ *  the fallback when no thinking color applies. */
+export declare const defaultTitleStyle: (s: string) => string;
+/** Resolve the editor border colorizer for a thinking level. Unknown / `off` →
+ *  the supplied `fallback` (the theme's default border color). */
+export declare function thinkingBorderColor(level: string | undefined, fallback: (s: string) => string): (s: string) => string;
+/** Resolve the title-chip styler for a thinking level: the level's color as the
+ *  chip BACKGROUND with bold white text (a space of padding each side), so the
+ *  session name reads as a solid label in the same hue as the border. Unknown /
+ *  `off` → the supplied `fallback` (the reverse-video default chip). */
+export declare function thinkingTitleStyle(level: string | undefined, fallback: (s: string) => string): (s: string) => string;
+/** Compose the replacement top-border line: solid title chip + border rule +
+ *  info chip, never wider than `width` (pi-tui hard-crashes on an over-wide
+ *  line). The info chip yields entirely when the chip leaves it almost no room,
+ *  and truncates when it only partially fits. Exported pure for the overflow
+ *  regression test. */
+export declare function composeTopBorder(width: number, title: string, info: string, titleStyle: (s: string) => string, borderColor: (s: string) => string): string;
+export declare class TitledEditor extends CustomEditor {
+    /** Session-name chip painted into the LEFT of the top border. Empty → plain. */
+    title: string;
+    /** Pre-styled context string painted into the RIGHT of the top border (cwd /
+     *  branch / git status). Already colorized by the caller; empty → omitted. */
+    info: string;
+    /** Paint the chip solid so the name reads as a label sitting on the border
+     *  rule. Defaults to the reverse-video chip; attach-cmd swaps in a
+     *  thinking-colored background (bold white text) on each state update. */
+    titleStyle: (s: string) => string;
+    render(width: number): string[];
+}

package/dist/clients/attach/titled-editor.js

@@ -0,0 +1,84 @@
+// titled-editor.ts — the `crtr attach` input editor with two bits of chrome pi's
+// stock editor doesn't give us:
+//   1. the session name painted INTO the top border as a solid-background chip,
+//      so it stays pinned to the editor instead of scrolling off as a free badge;
+//   2. a border color that tracks the agent's thinking level (set by attach-cmd
+//      on each state update), mirroring pi's `getThinkingBorderColor`.
+// Both are pure render-layer chrome; nothing here touches the socket or session.
+import { CustomEditor } from '@earendil-works/pi-coding-agent';
+import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+/** Per-level border/chip color as a 24-bit RGB triple — ONE blue-violet hue at
+ *  CONSTANT perceived lightness (luma ≈ 120) whose SATURATION alone climbs with
+ *  the budget: a near-gray blue at `minimal` deepening to a vivid violet at
+ *  `xhigh`, never getting lighter or darker — only more colorful. (pi paints its
+ *  own `thinking*` theme colors off its public palette surface, so we own this
+ *  ramp directly — truecolor, not the 16-color ANSI hues, so the saturation
+ *  climb actually reads.) `off` falls back to the caller's default border color. */
+const THINKING_RGB = {
+    off: undefined, // default border color
+    minimal: [125, 115, 135], // near-gray blue-violet
+    low: [129, 109, 151], // muted blue-violet
+    medium: [134, 103, 168], // violet
+    high: [139, 98, 184], // deeper violet
+    xhigh: [144, 92, 200], // vivid violet
+};
+/** The default (thinking `off`) title chip: reverse video + a space of padding
+ *  each side, so the name reads as a label sitting on the border rule. Used as
+ *  the fallback when no thinking color applies. */
+export const defaultTitleStyle = (s) => `\x1b[7m ${s} \x1b[27m`;
+/** Resolve the editor border colorizer for a thinking level. Unknown / `off` →
+ *  the supplied `fallback` (the theme's default border color). */
+export function thinkingBorderColor(level, fallback) {
+    const rgb = level === undefined ? undefined : THINKING_RGB[level];
+    if (rgb === undefined)
+        return fallback;
+    const [r, g, b] = rgb;
+    return (s) => `\x1b[38;2;${r};${g};${b}m${s}\x1b[39m`;
+}
+/** Resolve the title-chip styler for a thinking level: the level's color as the
+ *  chip BACKGROUND with bold white text (a space of padding each side), so the
+ *  session name reads as a solid label in the same hue as the border. Unknown /
+ *  `off` → the supplied `fallback` (the reverse-video default chip). */
+export function thinkingTitleStyle(level, fallback) {
+    const rgb = level === undefined ? undefined : THINKING_RGB[level];
+    if (rgb === undefined)
+        return fallback;
+    const [r, g, b] = rgb;
+    return (s) => `\x1b[48;2;${r};${g};${b}m\x1b[97m\x1b[1m ${s} \x1b[0m`;
+}
+/** Compose the replacement top-border line: solid title chip + border rule +
+ *  info chip, never wider than `width` (pi-tui hard-crashes on an over-wide
+ *  line). The info chip yields entirely when the chip leaves it almost no room,
+ *  and truncates when it only partially fits. Exported pure for the overflow
+ *  regression test. */
+export function composeTopBorder(width, title, info, titleStyle, borderColor) {
+    const chip = title ? titleStyle(truncateToWidth(title, Math.max(1, width - 4), '…')) : '';
+    const chipW = visibleWidth(chip);
+    const avail = width - chipW;
+    let infoChip = '';
+    if (info && avail > 4) {
+        infoChip = visibleWidth(info) <= avail ? info : truncateToWidth(info, avail, '…');
+    }
+    const fill = Math.max(0, width - chipW - visibleWidth(infoChip));
+    return chip + borderColor('─'.repeat(fill)) + infoChip;
+}
+export class TitledEditor extends CustomEditor {
+    /** Session-name chip painted into the LEFT of the top border. Empty → plain. */
+    title = '';
+    /** Pre-styled context string painted into the RIGHT of the top border (cwd /
+     *  branch / git status). Already colorized by the caller; empty → omitted. */
+    info = '';
+    /** Paint the chip solid so the name reads as a label sitting on the border
+     *  rule. Defaults to the reverse-video chip; attach-cmd swaps in a
+     *  thinking-colored background (bold white text) on each state update. */
+    titleStyle = defaultTitleStyle;
+    render(width) {
+        const lines = super.render(width);
+        if ((this.title || this.info) && lines.length > 0) {
+            // Replace the stock top border; dashes in the current (thinking-aware)
+            // border color.
+            lines[0] = composeTopBorder(width, this.title, this.info, this.titleStyle, (s) => this.borderColor(s));
+        }
+        return lines;
+    }
+}

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

@@ -1,6 +1,11 @@
 import { EventEmitter } from 'node:events';
 import type { NodeRow } from '../../core/canvas/types.js';
-import { type BrokerToClient, type ClientToBroker } from '../../core/runtime/broker-protocol.js';
+import { type BrokerDataFrame, type BrokerToClient, type ClientToBroker, type DequeueFrame, type GetSettingsFrame, type GetTreeFrame, type ListModelsFrame, type ListScopedModelsFrame, type ListSessionsFrame } from '../../core/runtime/broker-protocol.js';
+/** A correlated read-op (or `dequeue`) request MINUS the client-chosen `id` —
+ *  {@link ViewSocketClient.request} mints the `id`, sends the frame, and resolves
+ *  with the matching `data` reply. The picker/operator code builds these; the
+ *  socket owns the correlation token so callers never hand-roll one. */
+export type ReadOpRequest = Omit<ListModelsFrame, 'id'> | Omit<ListSessionsFrame, 'id'> | Omit<GetTreeFrame, 'id'> | Omit<GetSettingsFrame, 'id'> | Omit<ListScopedModelsFrame, 'id'> | Omit<DequeueFrame, 'id'>;
 /** Surfaced when the node has no reachable broker at connect time (no socket
  *  file, or a stale socket with nothing listening). The command catches this to
  *  exit non-zero with a focus/revive hint. */
@@ -36,7 +41,19 @@ export declare class ViewSocketClient extends EventEmitter {
     private socket;
     private decoder;
     private closeEmitted;
+    /** In-flight correlated read-ops, keyed by the `id` minted in {@link request}.
+     *  Resolved by the matching `data` frame / rejected by the matching `error`
+     *  frame in {@link onData}, the request's timeout, or socket teardown. */
+    private pending;
     constructor(nodeId: string);
+    /** Issue a correlated read-op and resolve with the broker's `data` reply (or
+     *  reject on the correlated `error`, a timeout, or socket teardown). Mints the
+     *  `id`, sends `{...frame, id}`, and parks a resolver consumed by {@link onData}.
+     *  The reply is narrowed by the caller on its `kind`. */
+    request(frame: ReadOpRequest): Promise<BrokerDataFrame>;
+    /** Reject + clear every in-flight request (socket gone / decode error) so a
+     *  picker fetch never hangs past the connection it rode on. */
+    private rejectAllPending;
     /** The broker binds `join(nodeDir(id), 'view.sock')` — resolve it the same way. */
     get socketPath(): string;
     /** Open the connection. Wire up listeners; emits `connect` on success or