@crouton-kit/crouter 0.3.27 → 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

@@ -12,7 +12,49 @@ export interface SlashContext {
     state?: BrokerSnapshot['state'];
     /** cwd for the default `/export` path; defaults to `process.cwd()`. */
     cwd?: string;
+    /** The canvas node this viewer is attached to — used by `/promote` (passed
+     *  as `--node`). Falls back to `CRTR_NODE_ID` when absent; if neither is set
+     *  `/promote` notifies and no-ops. (Unit Q wires this from `runAttach`.) */
+    nodeId?: string;
+    /** Toggle the in-process GRAPH overlay (the local subscription-tree view).
+     *  `/graph` is inherently an in-viewer overlay, not a tmux popup, so this unit
+     *  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
+ *  ports the action of its extension: `/promote` ← canvas-commands.ts, `/resume-node`
+ *  ← canvas-resume.ts, `/view` ← canvas-view.ts, `/graph` ← canvas-nav.ts. Three of
+ *  them shell a `crtr` subcommand via `tmux display-popup` (the viewer runs inside a
+ *  tmux pane, so this works exactly as in the extensions); `/graph` is a stub for the
+ *  overlay (Unit C/Q). Exported so Unit Q can fold these into the autocomplete list. */
+export declare const CANVAS_SLASH_COMMANDS: ReadonlyArray<{
+    name: string;
+    description: string;
+}>;
 /** True if `text` is a leading-slash command (vs. a normal prompt). */
 export declare function isSlashCommand(text: string): boolean;
 /**
@@ -24,7 +66,8 @@ export declare function isSlashCommand(text: string): boolean;
 export declare function dispatchSlashCommand(text: string, ctx: SlashContext): boolean;
 /** Build slash-command autocomplete entries from the merged command list (the
  *  broker's `get_commands` result, which T7 may inject) — defaults to the
- *  vendored builtins. Shaped for pi-tui's `CombinedAutocompleteProvider`. */
+ *  vendored builtins. The native canvas commands are always appended. Shaped for
+ *  pi-tui's `CombinedAutocompleteProvider`. */
 export declare function slashCommandList(commands?: ReadonlyArray<{
     name: string;
     description?: string;

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

@@ -7,24 +7,39 @@
 // 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`
+ *  ← canvas-resume.ts, `/view` ← canvas-view.ts, `/graph` ← canvas-nav.ts. Three of
+ *  them shell a `crtr` subcommand via `tmux display-popup` (the viewer runs inside a
+ *  tmux pane, so this works exactly as in the extensions); `/graph` is a stub for the
+ *  overlay (Unit C/Q). Exported so Unit Q can fold these into the autocomplete list. */
+export const CANVAS_SLASH_COMMANDS = [
+    { name: 'graph', description: 'Toggle the canvas GRAPH view (your local subscription tree)' },
+    { name: 'promote', description: 'Promote this node to an orchestrator — /promote, or /promote <kind> to specialize' },
+    { name: 'resume-node', description: 'Open the canvas navigator (search/scope/sort/tree) and resume the chosen node' },
+    { name: 'view', description: 'Open a view in a popup — bare for the picker, or /view <name> to open that view directly' },
+];
+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
@@ -60,6 +75,10 @@ export function dispatchSlashCommand(text, ctx) {
         ctx.notify(`/${name} is not supported in attach (Phase 4)`);
         return true;
     }
+    // Canvas commands (reimplemented native in the viewer) — handled before the
+    // builtin gate since they are neither pi builtins nor engine-extension commands.
+    if (CANVAS_NAMES.has(name))
+        return dispatchCanvasCommand(name, arg, ctx);
     // Unknown to us AND not a builtin → let the engine's extension runner have it.
     if (!BUILTIN_NAMES.has(name))
         return false;
@@ -76,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;
@@ -97,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);
@@ -125,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:
@@ -140,15 +205,153 @@ export function dispatchSlashCommand(text, ctx) {
             return true;
     }
 }
+/** Append the native canvas commands to a command list, skipping any already
+ *  present (so they survive whatever list Unit Q feeds in — builtins, or the
+ *  broker's `get_commands` result). The four canvas commands are viewer-owned,
+ *  so they are always surfaced in autocomplete regardless of the source list. */
+function withCanvasCommands(commands) {
+    const seen = new Set(commands.map((c) => c.name));
+    return [...commands, ...CANVAS_SLASH_COMMANDS.filter((c) => !seen.has(c.name))];
+}
 /** Build slash-command autocomplete entries from the merged command list (the
  *  broker's `get_commands` result, which T7 may inject) — defaults to the
- *  vendored builtins. Shaped for pi-tui's `CombinedAutocompleteProvider`. */
+ *  vendored builtins. The native canvas commands are always appended. Shaped for
+ *  pi-tui's `CombinedAutocompleteProvider`. */
 export function slashCommandList(commands = BUILTIN_SLASH_COMMANDS) {
-    return commands.map((c) => ({ name: c.name, description: c.description }));
+    return withCanvasCommands(commands).map((c) => ({ name: c.name, description: c.description }));
 }
 /** Same list as flat autocomplete items (value/label/description). */
 export function commandAutocompleteItems(commands = BUILTIN_SLASH_COMMANDS) {
-    return commands.map((c) => ({ value: `/${c.name}`, label: `/${c.name}`, description: c.description }));
+    return withCanvasCommands(commands).map((c) => ({ value: `/${c.name}`, label: `/${c.name}`, description: c.description }));
+}
+// ---------------------------------------------------------------------------
+// Canvas commands — native reimplementations of the canvas chrome extensions.
+// ---------------------------------------------------------------------------
+/** Dispatch one of the four native canvas commands. Always returns `true` (the
+ *  command is viewer-owned — never forwarded to the engine as a prompt). */
+function dispatchCanvasCommand(name, arg, ctx) {
+    switch (name) {
+        case 'graph':
+            // `/graph` is inherently the in-process GRAPH overlay (canvas-nav.ts
+            // `toggleGraph`), NOT a tmux popup. The overlay is Unit C/Q's surface; this
+            // unit registers the command + autocomplete entry and triggers the overlay
+            // via the `onGraph` hook the integration unit wires in.
+            if (ctx.onGraph)
+                ctx.onGraph();
+            else
+                ctx.notify('The GRAPH overlay is not wired into the viewer yet');
+            return true;
+        case 'promote':
+            promoteNode(arg, ctx);
+            return true;
+        case 'resume-node':
+            // ← canvas-resume.ts: open the full-screen canvas navigator as a popup; on
+            // Enter it focuses the chosen node back into THIS pane via `crtr node focus`.
+            return resumeNode(ctx);
+        case 'view':
+            // ← canvas-view.ts: bare `/view` opens the picker, `/view <name>` opens that
+            // view directly — each as a self-contained popup (no node-focus, no return-pane).
+            return openView(arg, ctx);
+        default:
+            ctx.notify(`/${name} is not available in attach`);
+            return true;
+    }
+}
+/** `/promote [kind]` ← canvas-commands.ts. Shells `crtr node promote --json` for
+ *  this node (out-of-process), notifies the result, then triggers a turn so the
+ *  persona injector steers in the new-role guidance at the turn boundary — exactly
+ *  as the node would by running the command itself. */
+function promoteNode(arg, ctx) {
+    const nodeId = (ctx.nodeId ?? process.env['CRTR_NODE_ID'] ?? '').trim();
+    if (nodeId === '') {
+        ctx.notify('/promote: no node to promote (viewer has no node id)');
+        return;
+    }
+    const kind = arg.trim().toLowerCase();
+    ctx.notify(kind ? `Promoting → ${kind}…` : 'Promoting…');
+    const argv = ['node', 'promote', '--node', nodeId, '--json'];
+    if (kind !== '')
+        argv.push('--kind', kind);
+    execFile('crtr', argv, { timeout: 15_000, maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => {
+        // On a non-zero exit crtr still prints the structured error to stdout, so
+        // prefer its `message` over the raw throw.
+        let result = null;
+        let errMsg = null;
+        try {
+            result = JSON.parse(stdout);
+        }
+        catch {
+            result = null;
+        }
+        if (err && result === null) {
+            const out = typeof err.stdout === 'string' ? err.stdout : '';
+            try {
+                const payload = JSON.parse(out);
+                errMsg = typeof payload.message === 'string' ? payload.message : null;
+            }
+            catch {
+                errMsg = null;
+            }
+            if (errMsg === null)
+                errMsg = err.message;
+        }
+        if (result === null) {
+            ctx.notify(`promote failed: ${errMsg ?? 'unknown error'}`);
+            return;
+        }
+        const rmPath = (result.roadmap_path ?? '').trim();
+        ctx.notify(`Promoted to ${result.kind ?? 'orchestrator'} orchestrator — authoring roadmap${rmPath !== '' ? ` (${rmPath})` : ''}.`);
+        // Trigger a turn so the persona injector (canvas-stophook turn_end) fires and
+        // delivers the new-role guidance — the viewer's only turn-trigger is `prompt`.
+        ctx.send({
+            type: 'prompt',
+            text: 'You have just been promoted to an orchestrator. Your new-role guidance is arriving — read it, author your roadmap, and start delegating.',
+        });
+    });
+}
+/** `/resume-node` ← canvas-resume.ts. Opens `crtr canvas browse` as a tmux popup,
+ *  scoped to this node's cwd; on Enter it focuses the chosen node back into this
+ *  pane via `crtr node focus --pane` (which `canvas browse` shells). */
+function resumeNode(ctx) {
+    const origPane = process.env['TMUX_PANE'];
+    if (process.env['TMUX'] === undefined || origPane === undefined || origPane === '') {
+        ctx.notify('/resume-node needs tmux');
+        return true;
+    }
+    const cwd = shellQuote(ctx.cwd ?? process.cwd());
+    const cmd = `crtr canvas browse --return-pane ${origPane} --cwd ${cwd}`;
+    popup(cmd);
+    return true;
+}
+/** `/view [name]` ← canvas-view.ts. Bare opens the picker (`crtr view pick`);
+ *  `/view <name>` opens that view directly (`crtr view run <name>`). Self-contained
+ *  popup — no node-focus, no return-pane. */
+function openView(arg, ctx) {
+    if (process.env['TMUX'] === undefined) {
+        ctx.notify('/view needs tmux');
+        return true;
+    }
+    const name = arg.trim();
+    const cmd = name === '' ? 'crtr view pick' : `crtr view run ${shellQuote(name)}`;
+    popup(cmd);
+    return true;
+}
+/** Open `cmd` as a fire-and-forget tmux display-popup (same geometry as the canvas
+ *  extensions). tmux runs the trailing string through `sh -c`; the popup owns its
+ *  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%', ...surfaceTmuxStyleArgs(), cmd], () => {
+            /* best-effort: popup is self-contained */
+        });
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/** Single-quote a string for safe interpolation into a `sh -c` command line. */
+function shellQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 // ---------------------------------------------------------------------------
 function usage(ctx, form) {
@@ -159,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();
@@ -178,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[];
+}