@north-light/crouter 0.3.154

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

@@ -0,0 +1,31 @@
+import { InputController } from '../input/controller.js';
+import type { KeybindingsManager } from '@earendil-works/pi-tui';
+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. */
+export interface InputWiringHooks {
+    /** Transient footer message. */
+    setNotice: (message: string) => void;
+    /** pi's agent dir from the live `welcome` state, for the auth pickers.
+     *  `undefined` before the first welcome → they fall back to the local default. */
+    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;
+    /** Ctrl+T — flip thinking-block visibility; returns true when now HIDDEN. */
+    toggleThinking: () => boolean;
+    /** `/graph` and the graph keybinding. */
+    toggleGraph: () => void;
+    /** `/node-metadata` — open the viewer-owned Inspector dossier popup. */
+    openNodeMetadata: () => void;
+    /** `/quit` — detach this viewer; the engine keeps running. Must tear down
+     *  locally, since a bare `bye` would just trigger the reconnect loop. */
+    quit: () => void;
+    /** `/color` — recolor the editor's name chip (`null` clears to default). */
+    setChipColor: (color: string | null) => void;
+}
+/** Build the viewer's InputController with every hook answered. */
+export declare function createInputController(ctx: Pick<AttachSession, 'nodeId' | 'remote' | 'role' | 'meta' | 'socket' | 'tui' | 'editor' | 'containers'>, km: KeybindingsManager, hooks: InputWiringHooks): InputController;

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

@@ -0,0 +1,128 @@
+// session/input-wiring.ts — the wiring harness for the input layer.
+//
+// `InputController` (input/controller.ts) is deliberately layout- and
+// canvas-agnostic: it takes ~20 optional hooks and no ambient knowledge. This
+// file is the ONLY place that answers each of them for the attach viewer, so
+// "what does /copy actually do here?" or "where does a picker get mounted?" has
+// one address instead of being a 130-line object literal wedged into runAttach.
+//
+// A few small behaviors live here rather than in the orchestrator because they
+// have exactly one caller — the hook itself: the clipboard copy, the two
+// display-toggle notices, the dormant wake-message send, and the two auth
+// pickers (which need a reference to the controller being constructed, so they
+// 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. */
+export function createInputController(ctx, km, hooks) {
+    const { nodeId, remote, role, socket, tui, editor, containers } = ctx;
+    const { setNotice } = hooks;
+    // The viewer's fixed capability, resolved once at hello: an `--observer`
+    // attach (and a remote one, which is always an observer) may read but never
+    // 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
+    // reload with a `reload_auth` frame.
+    //
+    // A read-only viewer wires NEITHER. A REMOTE attach (`--canvas`) disables both
+    // because they target the LOCAL `auth.json` via `defaultAgentDir()`, the wrong
+    // host for a remote node (Phase 3 review Major 1, 1d); an OBSERVER because
+    // switching credentials and telling the broker to reload them mutates the
+    // engine's auth, which a read-only viewer must not do. Unwired here means the
+    // slash context carries no picker at all, so `/login` and `/logout` report
+    // themselves unavailable rather than reaching a `reload_auth` frame.
+    const reloadAuth = () => socket.send({ type: 'reload_auth' });
+    const authPickers = !writable
+        ? {}
+        : {
+            openLoginPicker: () => {
+                const dir = hooks.agentDir() ?? defaultAgentDir();
+                void input.openAuthPicker(() => buildLoginPicker(tui, dir, reloadAuth, (m) => setNotice(m)));
+            },
+            openLogoutPicker: () => {
+                const dir = hooks.agentDir() ?? defaultAgentDir();
+                void input.openAuthPicker(() => buildLogoutPicker(dir, reloadAuth, (m) => setNotice(m)));
+            },
+        };
+    const input = new InputController(tui, editor, km, {
+        onCommand: (frame) => socket.send(frame),
+        onDialogResponse: (resp) => socket.send(resp),
+        onNotice: (msg) => setNotice(msg),
+        // The slash context: `/promote` targets this node, `/resume-node` opens
+        // scoped to its profile, `remote` structurally omits the local-only
+        // canvas commands, and `/graph` toggles the overlay.
+        nodeId,
+        profileId: ctx.meta.profile_id ?? undefined,
+        remote,
+        role,
+        onGraph: hooks.toggleGraph,
+        onNodeMetadata: hooks.openNodeMetadata,
+        onQuit: hooks.quit,
+        onCopy: copyLastAssistant,
+        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'),
+        onToggleThinking: () => setNotice(hooks.toggleThinking() ? 'Thinking blocks: hidden' : 'Thinking blocks: visible'),
+        // The correlated read-op channel the native pickers (/model, /resume,
+        // /fork, /tree, /settings, /scoped-models) fetch their payloads over.
+        // Without it every picker degrades to the "isn't available in this viewer"
+        // notice (see slash/dispatch.ts + InputController.openPicker).
+        onRequest: (frame) => socket.request(frame),
+        // Mount pickers inline in the chrome stack, directly under the editor
+        // (queued-panel pattern) rather than as a floating centered modal, so a
+        // picker reads as part of the editor — like pi's own selectors.
+        onMountPicker: (component) => {
+            containers.pickerPanel.addChild(component);
+            tui.requestRender();
+        },
+        onUnmountPicker: () => {
+            containers.pickerPanel.clear();
+            tui.requestRender();
+        },
+        // Dormant-node input: the node has no live broker, so a submitted prompt
+        // cannot reach a socket. The reconnect supervisor reports dormancy and the
+        // text is delivered as a wake message (revive + deliver) instead, so the
+        // still-open input box just works. Writable viewers only — a remote or
+        // observer attach cannot drive, leaves `onDormantSubmit` unwired, and
+        // prompts fall through. This is the one mutating path that never touches the
+        // broker (it goes to crtrd via `cliClient`), so leaving it wired for an
+        // observer would let a read-only viewer wake and message the node.
+        isDormant: hooks.isDormant,
+        onDormantSubmit: !writable ? undefined : (msgText) => {
+            void (async () => {
+                try {
+                    // Text typed into a node's box IS the human talking to it — mark it
+                    // `from: 'human'` so it wakes the node and lands as a plain user turn
+                    // (verbatim, no "From … — N updates" digest; see coalesce()), exactly
+                    // like the live path. NOT `CRTR_NODE_ID`: direct keyboard input is
+                    // the human, not whatever node owns the shell that launched us.
+                    const res = await cliClient().sendMessage(nodeId, { body: msgText, from: 'human' });
+                    setNotice(res.revived ? '↻ waking node…' : '✉ delivered — node reads on next wake');
+                }
+                catch (err) {
+                    setNotice(`Couldn't wake node: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            })();
+        },
+        ...authPickers,
+    });
+    return input;
+}

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

@@ -0,0 +1,22 @@
+import { type AttachBindings } from './bindings.js';
+import type { AttachSession } from './context.js';
+export interface KeyHooks {
+    /** The live binding snapshot — re-resolved by `/reload`, so read per key. */
+    bindings: () => AttachBindings;
+    /** How the user would spell the detach binding, for the clear-first hint. */
+    detachHint: () => string | undefined;
+    /** Terminal focus in/out — the roster owns the editor's cursor styling. */
+    setPaneFocused: (focused: boolean) => void;
+    /** 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;
+    cycleModelLadder: (direction: 'forward' | 'backward') => void;
+    inspectLoadedCommand: () => void;
+    /** The file-review chord — open the transcript-file picker + review surface. */
+    openFileReview: () => void;
+}
+/** Install the listener; returns the remover, which teardown MUST call. */
+export declare function installGlobalKeys(ctx: Pick<AttachSession, 'tui' | 'editor'>, hooks: KeyHooks): () => void;

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

@@ -0,0 +1,60 @@
+// session/keys.ts — the viewer's GLOBAL key listener.
+//
+// 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 three things may claim a chunk — terminal focus reports, the
+// roster while it holds the cursor, and a configured crtr binding — and each
+// returns to the editor untouched when it does not apply.
+import { dispatchAttachBinding } 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;
+/** Install the listener; returns the remover, which teardown MUST call. */
+export function installGlobalKeys(ctx, hooks) {
+    const { tui, editor } = ctx;
+    let lastClearOrDetachAt = 0;
+    return tui.addInputListener((data) => {
+        // Terminal focus reporting (DECSET 1004, enabled after tui.start; tmux
+        // forwards it per-pane with `focus-events on`). Pane focus drives the
+        // editor's fake cursor — solid block focused, hollow outline blurred — so a
+        // wall of attach panes shows exactly which one keys go to. The events are
+        // stripped rather than blanket-consumed in case the chunk coalesced them
+        // with real keystrokes.
+        if (data.includes(FOCUS_IN) || data.includes(FOCUS_OUT)) {
+            hooks.setPaneFocused(data.lastIndexOf(FOCUS_IN) > data.lastIndexOf(FOCUS_OUT));
+            tui.requestRender();
+            const rest = data.replaceAll(FOCUS_IN, '').replaceAll(FOCUS_OUT, '');
+            return rest.length > 0 ? { data: rest } : { 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 };
+        const dispatched = dispatchAttachBinding(hooks.bindings(), data, {
+            'crtr.attach.detach': hooks.detach,
+            'crtr.attach.clear-or-detach': () => {
+                const now = Date.now();
+                if (now - lastClearOrDetachAt < CLEAR_OR_DETACH_MS) {
+                    lastClearOrDetachAt = 0;
+                    hooks.detach();
+                    return;
+                }
+                lastClearOrDetachAt = now;
+                editor.setText('');
+                hooks.setNotice(`Editor cleared — press ${hooks.detachHint()} again to detach`);
+                tui.requestRender();
+            },
+            'crtr.mode.cycle': hooks.cycleMode,
+            'crtr.attach.graph.toggle': hooks.toggleGraph,
+            // 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'),
+            'crtr.attach.command.inspect': hooks.inspectLoadedCommand,
+            'crtr.attach.file-review': hooks.openFileReview,
+        });
+        return dispatched ? { consume: true } : undefined;
+    });
+}

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

@@ -0,0 +1,20 @@
+import { ProcessTerminal, TUI } from '@earendil-works/pi-tui';
+import type { KeybindingsManager } from '@earendil-works/pi-tui';
+import type { AttachPalette } from '../config.js';
+import { TitledEditor } from '../input/titled-editor.js';
+import type { AttachContainers } from './context.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. */
+    readonly procTerminal: ProcessTerminal;
+    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. */
+    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;

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

@@ -0,0 +1,56 @@
+// session/layout.ts — the viewer's visual skeleton: the TUI, the nine
+// containers it paints into, and the editor.
+//
+// Pure construction. Nothing here reads session state, talks to the socket, or
+// handles a key — a reader chasing behavior can skip this file entirely, and a
+// reader asking "where does this line get painted?" needs only this one.
+//
+// The render order is the whole point of the file, and it is asserted in ONE
+// place (`mount`). Top to bottom: chat · rule · queued · above-editor extension
+// widgets · editor · picker panel · below-editor extension widgets · roster ·
+// status bar. pi-tui anchors the viewport to the cursor at the BOTTOM, so
+// everything except the scrolling chat lives in the bottom-anchored chrome
+// stack — a "topmost" badge would scroll off into scrollback the instant the
+// transcript exceeded one screen, which is why the mode badge and the two
+// canvas panels sit directly above the queued panel rather than at the top.
+import { Container, ProcessTerminal, TUI } from '@earendil-works/pi-tui';
+import { DynamicBorder, getSelectListTheme } from '@earendil-works/pi-coding-agent';
+import { TitledEditor } from '../input/titled-editor.js';
+/** Build the TUI, its containers, and the editor. No behavior is wired here;
+ *  the orchestrator owns every callback. */
+export function createLayout(pal, km) {
+    const procTerminal = new ProcessTerminal();
+    const tui = new TUI(procTerminal);
+    const containers = {
+        chat: new Container(),
+        chrome: new Container(),
+        aboveWidgets: new Container(),
+        reports: new Container(),
+        queued: new Container(),
+        pickerPanel: new Container(),
+        belowWidgets: new Container(),
+        footer: new Container(),
+    };
+    // The themed rule dividing the scrolling chat from the fixed chrome below it.
+    // `renderExtensionWidgets` re-derives this container's contents on every
+    // widget change (the passive recap replaces the rule), so this is the seed,
+    // not the sole writer.
+    containers.chrome.addChild(new DynamicBorder(pal.border));
+    const editorTheme = { borderColor: pal.border, selectList: getSelectListTheme() };
+    // TitledEditor paints the session name into its top border (solid-background
+    // chip) and tracks a thinking-level border color, both set from live state.
+    const editor = new TitledEditor(tui, editorTheme, km, { paddingX: 1 });
+    const mount = () => {
+        tui.addChild(containers.chat);
+        tui.addChild(containers.chrome);
+        tui.addChild(containers.queued);
+        tui.addChild(containers.aboveWidgets);
+        tui.addChild(editor);
+        tui.addChild(containers.pickerPanel);
+        tui.addChild(containers.belowWidgets);
+        tui.addChild(containers.reports);
+        tui.addChild(containers.footer);
+        tui.setFocus(editor);
+    };
+    return { procTerminal, tui, containers, editor, mount };
+}

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

@@ -0,0 +1,25 @@
+import type { AttachSession } from './context.js';
+export type Mode = 'normal' | 'spec' | 'plan';
+export declare function nextMode(current: Mode): Mode;
+/** Resolve the mode badge's initial state. Remote never reads the local
+ *  mode-switch `current` file for `nodeId` — always starts 'normal'. */
+export declare function resolveInitialMode(cwd: string, nodeId: string, remote: boolean, readMode?: (cwd: string, nodeId: string) => Mode | undefined): Mode;
+/** Handle a configured mode-cycle request. Remote no-ops entirely (returns `false`,
+ *  so the caller leaves `modeState`/the badge untouched) — there is no
+ *  remote-safe mode-switch protocol, and writing the local `request.json` for a
+ *  remote node id would target the wrong (or a colliding local) node. */
+export declare function requestModeSwitch(cwd: string, nodeId: string, remote: boolean, mode: Mode, writeRequest?: (cwd: string, nodeId: string, mode: Mode) => void): boolean;
+/** The live badge: the viewer's current mode plus the one way to change it.
+ *  Owning both here is what keeps `mode` from being a mutable the key handler
+ *  and the editor painter both reach into. */
+export interface ModeBadge {
+    /** Advance to the next mode and repaint. A read-only viewer no-ops entirely,
+     *  badge included: a REMOTE attach has no remote-safe mode-switch protocol,
+     *  and an OBSERVER may not change the node's mode at all. */
+    cycle: () => void;
+}
+/** Resolve the initial mode, paint the badge, and return the cycle verb. */
+export declare function createModeBadge(ctx: Pick<AttachSession, 'nodeId' | 'remote' | 'role' | 'meta' | 'tui' | 'editor'>): ModeBadge;
+/** The badge chip painted for each mode: spec is blue, plan is amber, normal is
+ *  unstyled (no badge chrome when there is nothing to say). */
+export declare function modeBadgeStyle(mode: Mode): (s: string) => string;

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

@@ -0,0 +1,97 @@
+// session/mode.ts — the viewer's spec/plan/normal mode badge and the on-disk
+// mode-switch handshake with the broker.
+//
+// The viewer never mutates engine mode directly: it drops a `request.json` in
+// the node's mode dir (atomic tmp+rename) and reads the
+// broker-written `current` file back for the badge. Both are LOCAL-ONLY reads
+// keyed on `nodeId` — a remote attach (`--canvas`) must never touch them, so
+// every exported entry point takes the session's single `remote` flag rather
+// than re-deriving it.
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { nodeDir } from '../../../core/canvas/paths.js';
+const MODE_CYCLE = ['normal', 'spec', 'plan'];
+function modeSwitchDir(_cwd, nodeId) {
+    return join(nodeDir(nodeId), 'mode');
+}
+function modeSwitchRequestPath(cwd, nodeId) {
+    return join(modeSwitchDir(cwd, nodeId), 'request.json');
+}
+function modeSwitchCurrentPath(cwd, nodeId) {
+    return join(modeSwitchDir(cwd, nodeId), 'current');
+}
+function readCurrentMode(cwd, nodeId) {
+    try {
+        const raw = readFileSync(modeSwitchCurrentPath(cwd, nodeId), 'utf8').trim();
+        return MODE_CYCLE.includes(raw) ? raw : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeModeRequest(cwd, nodeId, mode) {
+    const dir = modeSwitchDir(cwd, nodeId);
+    mkdirSync(dir, { recursive: true });
+    const token = randomUUID();
+    const tmp = join(dir, `request.${token}.tmp`);
+    writeFileSync(tmp, `${JSON.stringify({ mode, token, source: 'attach' })}\n`);
+    renameSync(tmp, modeSwitchRequestPath(cwd, nodeId));
+}
+export function nextMode(current) {
+    const idx = MODE_CYCLE.indexOf(current);
+    return MODE_CYCLE[(idx + 1) % MODE_CYCLE.length];
+}
+/** Resolve the mode badge's initial state. Remote never reads the local
+ *  mode-switch `current` file for `nodeId` — always starts 'normal'. */
+export function resolveInitialMode(cwd, nodeId, remote, readMode = readCurrentMode) {
+    if (remote)
+        return 'normal';
+    return readMode(cwd, nodeId) ?? 'normal';
+}
+/** Handle a configured mode-cycle request. Remote no-ops entirely (returns `false`,
+ *  so the caller leaves `modeState`/the badge untouched) — there is no
+ *  remote-safe mode-switch protocol, and writing the local `request.json` for a
+ *  remote node id would target the wrong (or a colliding local) node. */
+export function requestModeSwitch(cwd, nodeId, remote, mode, writeRequest = writeModeRequest) {
+    if (remote)
+        return false;
+    writeRequest(cwd, nodeId, mode);
+    return true;
+}
+/** Resolve the initial mode, paint the badge, and return the cycle verb. */
+export function createModeBadge(ctx) {
+    const { nodeId, remote, role, meta, tui, editor } = ctx;
+    let mode = resolveInitialMode(meta.cwd, nodeId, remote);
+    const paint = () => {
+        editor.mode = mode === 'normal' ? '' : mode;
+        editor.modeStyle = modeBadgeStyle(mode);
+    };
+    paint();
+    return {
+        cycle: () => {
+            // The mode request rewrites how the node's engine behaves, so it rides the
+            // session's fixed capability like every other mutation: an observer reads
+            // the badge the broker publishes and changes nothing.
+            if (role !== 'controller')
+                return;
+            const next = nextMode(mode);
+            if (!requestModeSwitch(meta.cwd, nodeId, remote, next))
+                return;
+            mode = next;
+            paint();
+            tui.requestRender();
+        },
+    };
+}
+/** The badge chip painted for each mode: spec is blue, plan is amber, normal is
+ *  unstyled (no badge chrome when there is nothing to say). */
+export function modeBadgeStyle(mode) {
+    if (mode === 'spec') {
+        return (s) => `\x1b[44m\x1b[97m\x1b[1m ${s} \x1b[0m`;
+    }
+    if (mode === 'plan') {
+        return (s) => `\x1b[48;2;228;152;68m\x1b[30m\x1b[1m ${s} \x1b[0m`;
+    }
+    return (s) => s;
+}

package/dist/clients/attach/session/pane-tag.d.ts

@@ -0,0 +1,15 @@
+/** The tag's lifecycle for one viewer: `set()` once the startup checkpoint has
+ *  cleared, `clear()` on teardown so a stray tag can't outlive the pane.
+ *  `pane()` is the id teardown reports as this viewer's home.
+ *
+ *  Split into a claim + a clear because ordering matters: a remote relay's "no
+ *  node"/"no running broker" close can still throw AFTER the socket is up, so
+ *  the tag is claimed only past that checkpoint — while `clear()` must be safe
+ *  to call from a teardown that runs before it was ever claimed. */
+export declare function createPaneTag(remote: boolean, nodeId: string): {
+    set: () => void;
+    clear: () => void;
+    pane: () => string | undefined;
+};
+export declare function tagAttachPane(remote: boolean, pane: string | undefined, nodeId: string, setOpt?: (pane: string, name: string, value: string) => void): void;
+export declare function untagAttachPane(remote: boolean, pane: string | undefined, setOpt?: (pane: string, name: string, value: string) => void): void;

package/dist/clients/attach/session/pane-tag.js

@@ -0,0 +1,43 @@
+// session/pane-tag.ts — the `@crtr_node` tmux pane tag that lets the
+// host-agnostic `nodeInPane()` (the Alt+C cycle/recycle/close/demote family)
+// resolve which broker-hosted node a viewer pane is showing.
+//
+// LOCAL ONLY: a remote attach (`--canvas`) never sets the tag, so local pane
+// lifecycle can never resolve a remote node id — or a local id that happens to
+// collide with it — from this pane.
+import { currentTmux, setPaneOption } from '../../../core/runtime/placement-tmux.js';
+/** The tag's lifecycle for one viewer: `set()` once the startup checkpoint has
+ *  cleared, `clear()` on teardown so a stray tag can't outlive the pane.
+ *  `pane()` is the id teardown reports as this viewer's home.
+ *
+ *  Split into a claim + a clear because ordering matters: a remote relay's "no
+ *  node"/"no running broker" close can still throw AFTER the socket is up, so
+ *  the tag is claimed only past that checkpoint — while `clear()` must be safe
+ *  to call from a teardown that runs before it was ever claimed. */
+export function createPaneTag(remote, nodeId) {
+    let pane;
+    return {
+        set: () => {
+            pane = process.env['TMUX_PANE'] ?? currentTmux()?.pane;
+            tagAttachPane(remote, pane, nodeId);
+        },
+        clear: () => untagAttachPane(remote, pane),
+        pane: () => pane,
+    };
+}
+export function tagAttachPane(remote, pane, nodeId, setOpt = setPaneOption) {
+    if (remote || pane === undefined || pane === '')
+        return;
+    try {
+        setOpt(pane, '@crtr_node', nodeId);
+    }
+    catch { /* best-effort */ }
+}
+export function untagAttachPane(remote, pane, setOpt = setPaneOption) {
+    if (remote || pane === undefined || pane === '')
+        return;
+    try {
+        setOpt(pane, '@crtr_node', '');
+    }
+    catch { /* best-effort */ }
+}

package/dist/clients/attach/session/pi-assets.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/session/pi-assets.js

@@ -0,0 +1,24 @@
+// session/pi-assets.ts — point pi-coding-agent at its OWN package dir.
+//
+// `npm run build:attach` esbuild-bundles the viewer into crouter's dist, which
+// relocates the module URL — and that breaks pi's asset resolution: pi finds its
+// theme/asset root by walking up from its own module URL to the nearest
+// package.json (config.js getPackageDir). Inlined into the bundle, that walk
+// lands on CROUTER's package.json, where pi's themes don't exist (ENOENT on
+// dark.json the moment applyTheme runs). PI_PACKAGE_DIR is pi's documented
+// override for exactly this; point it at pi's REAL package dir — resolved with
+// import.meta.resolve, which stays correct in the bundle because it resolves
+// from the output file's node_modules. No-op unbundled (dev/tsx): pi's own walk
+// works, and this just re-asserts the same dir.
+//
+// Import this for side effect at the TOP of the viewer entry, so it precedes
+// any pi theme/asset access during viewer construction.
+import { resolveBundledPiPackageDir } from '../../../core/runtime/pi-cli.js';
+try {
+    // Replace even an inherited value: a parent viewer/daemon may carry a `.pnpm`
+    // package copy that lacks pi's JSON theme assets.
+    process.env['PI_PACKAGE_DIR'] = resolveBundledPiPackageDir();
+}
+catch {
+    /* unbundled/dev — pi resolves its assets from its own location */
+}

package/dist/clients/attach/session/pi-oauth-flows.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/session/pi-oauth-flows.js

@@ -0,0 +1,21 @@
+// session/pi-oauth-flows.ts — hand the bundled viewer pi's OAuth flow modules.
+//
+// Same class of bug as pi-assets.ts: esbuild relocates the module URL. pi-ai
+// 0.82 loads each OAuth flow through a VARIABLE specifier
+// (`import("./anthropic.ts")` in auth/oauth/load.js) specifically so bundlers
+// cannot follow it into Node-only flow code. Bundled, that specifier survives
+// into dist/clients/attach/viewer.js and resolves against the BUNDLE's dir, so
+// /login died on `Cannot find module .../dist/clients/attach/anthropic.js`.
+// (0.80 imported the flows statically, so the bundle carried them and login
+// worked; the 0.82 bump is what broke it.)
+//
+// registerBunOAuthFlows is pi's own escape hatch for statically bundled hosts —
+// it imports every flow module by literal specifier and registers them, so the
+// dynamic path is never taken. Named for Bun's standalone binaries, but the
+// problem it solves is bundling, not the runtime.
+//
+// Import this for side effect at the TOP of the viewer entry, before anything
+// can touch `provider.auth.oauth`. No-op-ish unbundled (dev/tsx): it registers
+// the same flows the lazy path would have loaded.
+import { registerBunOAuthFlows } from '@earendil-works/pi-ai/bun-oauth';
+registerBunOAuthFlows();

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

@@ -0,0 +1,37 @@
+import type { ClientRole } from '../../../core/runtime/broker-protocol.js';
+import type { BrokerToClient } from '../../../core/runtime/broker-protocol.js';
+import type { AttachSession } from './context.js';
+export interface ReconnectHooks {
+    /** This viewer's fixed role, resolved from the original attach flags. */
+    role: ClientRole;
+    /** This viewer's stable client id, echoed by the broker in the hello. */
+    clientId: string;
+    /** Every broker frame, in wire order. */
+    onFrame: (frame: BrokerToClient) => void;
+    setNotice: (msg: string, opts?: {
+        sticky?: boolean;
+    }) => void;
+    /** True once teardown has begun — the supervisor loop's exit condition. */
+    isTornDown: () => boolean;
+    /** End the session. `node-done` is a clean finalize (the node pushed its
+     *  final report) and closes the pane; `broker-gone` freezes the corpse. */
+    teardown: (reason: 'node-done' | 'broker-gone') => void;
+    /** Called once each time the node is first seen as dormant. An idle-released
+     *  broker has settled its turn and will relay no final session event, so the
+     *  viewer must clear its live-only display itself. */
+    onEnterDormancy: () => void;
+}
+export interface ReconnectSupervisor {
+    /** Send the hello handshake. Called once after `tui.start()`, then again on
+     *  every successful redial. */
+    sendHello: () => void;
+    /** True while the node has no live broker — the input layer routes a
+     *  submitted prompt through a wake message rather than a dead socket. */
+    isDormant: () => boolean;
+    /** The last socket-level error, for a broker-gone teardown message. */
+    lastSocketError: () => string | undefined;
+    /** Install the permanent frame/error/close handlers. Call once, AFTER the
+     *  connect race is settled and its temporary listeners are gone. */
+    install: () => void;
+}
+export declare function createReconnect(ctx: Pick<AttachSession, 'nodeId' | 'socket' | 'canvasSource'>, hooks: ReconnectHooks): ReconnectSupervisor;