zcode-acp-server 0.21.3 → 0.22.0

package/dist/repl/App.js

@@ -1,732 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * Ink UI for the interactive REPL (bare `zcode-acp`).
- *
- * Rendering model: the whole app draws in a fixed-height frame managed by
- * run.ts (full-screen mode) — the transcript is an in-app viewport, and the
- * live turn (streaming text, thinking buffer, tool rows), prompt line, and
- * pickers render inside it. A pending permission request takes over the
- * input area with an arrow-key picker.
- */
-import { Box, Static, Text, useInput, usePaste } from "ink";
-import Spinner from "ink-spinner";
-import { Chalk } from "chalk";
-import { Fragment, useCallback, useEffect, useRef, useState } from "react";
-import stringWidth from "string-width";
-import { applyCompletion, COMPLETION_LIMIT, completionCandidates, estimateLines, isConfigArgumentMenu, isConfigCommand, isOneShotCommandValue, lastToolTail, locateCaret, pickerWindow, relativeTime, selectLabel, wrapEditorLine, } from "./model.js";
-import { backspaceAtCaret, caretLeft, caretRight, caretToEnd, caretToStart, createLineEditor, ctrlChord, deleteAtCaret, foldPasteChunk, insertAtCaret, planChunkOps, replaceText, sanitizeInputChunk, } from "./input-buffer.js";
-// Fixed-level chalk so colorization is deterministic regardless of TTY
-// detection (tests run with level 0; the REPL terminal always takes color).
-const color = new Chalk({ level: 2 });
-/**
- * Colorize markdown code fences: lines between ``` fences render cyan. Line
- * level state machine — exported for unit tests.
- */
-export function colorizeCodeFences(text) {
-    let inFence = false;
-    return text
-        .split("\n")
-        .map((line) => {
-        if (line.trimStart().startsWith("```")) {
-            inFence = !inFence;
-            return color.dim(line);
-        }
-        return inFence ? color.cyan(line) : line;
-    })
-        .join("\n");
-}
-/**
- * Esc / Ctrl-C means "dismiss" for every picker (question form, /sessions,
- * permission). Both ctrl-c delivery shapes count: a lone \x03 arrives as
- * ("c", ctrl) but rapid presses coalesce into one raw chunk with ctrl=false.
- */
-function isCancelKey(inputChar, key) {
-    return key.escape || (key.ctrl && inputChar === "c") || (inputChar ?? "").includes("\x03");
-}
-const TOOL_STATUS_ICON = {
-    pending: "○",
-    in_progress: "●",
-    completed: "✔",
-    failed: "✘",
-};
-/**
- * Startup welcome panel — the agent-CLI-style hero shown until the first
- * prompt pushes it into scrollback: branding, session info, the seeded
- * config, and the key hints a first-time user needs.
- */
-function WelcomeView({ info }) {
-    const config = [info.model, info.mode, info.thought].filter(Boolean).join(" · ");
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: "zcode-acp" }), _jsxs(Text, { dimColor: true, children: [" v", info.version] })] }), _jsxs(Text, { dimColor: true, children: ["session \u00B7 ", info.cwd] }), info.sandbox ? _jsx(Text, { color: "green", children: info.sandbox }) : null, config ? (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "\u25CF " }), _jsx(Text, { bold: true, children: config })] })) : null, _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "  /        command menu — ↑/↓ move · enter picks · esc closes" }), _jsx(Text, { dimColor: true, children: "  /model   switch model — /mode and /thought likewise" }), _jsx(Text, { dimColor: true, children: "  /sessions list and resume past conversations of this project" }), _jsx(Text, { dimColor: true, children: "  esc      interrupt the running turn" }), _jsx(Text, { dimColor: true, children: "  ctrl-c   quit — press twice when idle" })] })] }));
-}
-function EntryView({ entry }) {
-    switch (entry.kind) {
-        case "user":
-            return (_jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "cyan", bold: true, children: [">", " "] }), _jsx(Text, { children: entry.text })] }));
-        case "thinking": {
-            const oneLine = entry.text.replace(/\s+/g, " ").slice(0, 120);
-            return _jsxs(Text, { dimColor: true, children: ["\u23BF thinking \u00B7 ", oneLine] });
-        }
-        case "assistant":
-            return _jsx(Text, { children: colorizeCodeFences(entry.text) });
-        case "tool":
-            return (_jsxs(Text, { children: [_jsxs(Text, { color: entry.status === "failed" ? "red" : entry.status === "completed" ? "green" : "yellow", children: [TOOL_STATUS_ICON[entry.status] ?? "•", " "] }), _jsx(Text, { children: entry.title }), _jsxs(Text, { dimColor: true, children: [" (", entry.status, ")"] })] }));
-        case "note":
-            return _jsxs(Text, { dimColor: true, children: ["-- ", entry.text] });
-        case "plan":
-            // Plan approvals print the full plan into the scrollback (the footer
-            // popup cannot scroll a long document); it stays as the record of what
-            // was approved.
-            return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "\u2500\u2500 plan \u2500\u2500" }), _jsx(Text, { children: colorizeCodeFences(entry.text) })] }));
-        case "welcome":
-            return _jsx(WelcomeView, { info: entry.info });
-    }
-}
-/**
- * Derive ink-style key flags for a single char of a COALESCED multi-key chunk
- * (fast double-ctrl-c, "\t\t", …). ink delivers such chunks as ONE event with
- * the raw string and mostly-false flags, so we decompose per char to keep each
- * key's semantics. Chunks containing ESC (arrow-key sequences) are never
- * decomposed — the caller leaves those to ink's parser.
- */
-function derivedKey(ch) {
-    return {
-        return: ch === "\r" || ch === "\n",
-        tab: ch === "\t",
-        escape: false,
-        backspace: ch === "\x7f" || ch === "\b",
-        // Arrow / Delete keys always arrive as escape sequences and are handled
-        // by ink's parser, never inside a decomposed printable chunk.
-        forwardDelete: false,
-        left: false,
-        right: false,
-        ctrl: ch >= "\x01" && ch <= "\x1a" && ch !== "\r" && ch !== "\n" && ch !== "\t",
-        meta: false,
-    };
-}
-/**
- * Self-managed input line. ink-text-input's submit/clear timing proved
- * unreliable under full external rerenders, so the line owns its value and
- * handles plain typing, caret-aware editing (←/→ or Ctrl-B/F to move,
- * Backspace/Delete at the caret, Ctrl-A/E line jumps, Ctrl-U clear), and
- * submit directly.
- *
- * While the line is a slash command (or a config command's argument), an
- * interactive completion menu sits above the box: ↑/↓ move, tab/→ complete
- * the highlighted candidate, enter picks it when the line is a partial match
- * (exact input sends instead), esc dismisses. ←/→ only move the caret when
- * they are not acting as menu/completion keys.
- */
-function InputLine({ busy, status, editor, applyEdit, onMenuOpenChange, quotaLine, onSubmitText, }) {
-    // `ed` mirrors props.editor for the render below; edits go through
-    // applyEdit so run.ts's store stays the single source of truth.
-    const ed = editor;
-    const [selIdx, setSelIdx] = useState(0);
-    const [dismissed, setDismissed] = useState(false);
-    // Mirror of `ed` for event handlers: a decomposed chunk fires several
-    // state updates in one tick, so closures over `ed` would see the stale
-    // pre-chunk line (and submit the wrong text on an embedded \r).
-    const edRef = useRef(editor);
-    edRef.current = editor;
-    // Completion paths replace the whole line — adopt with caret at the end.
-    const applyValue = (fn) => {
-        applyEdit((e) => replaceText(fn(e.text)));
-    };
-    const submitWith = (text) => {
-        applyEdit(() => createLineEditor());
-        setDismissed(false);
-        if (text.trim())
-            onSubmitText(text.trim());
-    };
-    const candidates = completionCandidates(ed.text, status);
-    const menu = !dismissed && candidates !== null && candidates.length > 0 ? candidates : null;
-    // Mirror visibility out of React on every render: the app-level key handler
-    // may run for the same keystroke and must see the PRE-keystroke value
-    // (stale-by-one-keystroke is exactly right — it decides esc precedence
-    // before this component's own listener dismisses anything). Plain store
-    // assignment, no React state, so this can't loop.
-    onMenuOpenChange(menu !== null);
-    // New keystroke → new filter: restart the selection and re-open a
-    // previously dismissed menu.
-    useEffect(() => {
-        setSelIdx(0);
-        setDismissed(false);
-    }, [ed.text]);
-    const handleChar = (ch, k, nav) => {
-        if (nav || k.tab) {
-            if (nav?.up) {
-                setSelIdx((i) => Math.max(0, i - 1));
-                return;
-            }
-            if (nav?.down) {
-                // Without an open menu there is nothing to move through — swallow
-                // the press. `menu!` here used to throw inside a setState UPDATER,
-                // which fires during the next render: React unmounted the whole
-                // tree and ink restored the terminal, leaving a silent zombie.
-                if (!menu)
-                    return;
-                setSelIdx((i) => Math.min(menu.length - 1, i + 1));
-                return;
-            }
-            // tab (or →) completes the highlighted candidate when a menu is open.
-            // Without one, → falls through to caret movement below so it stays a
-            // plain editing key; bare tabs are still dropped.
-            if ((k.tab || nav?.right) && menu) {
-                const item = menu[selIdx] ?? menu[0];
-                if (item)
-                    applyValue((v) => applyCompletion(v, item));
-                return;
-            }
-        }
-        if (k.escape) {
-            setDismissed(true);
-            return;
-        }
-        if (k.return) {
-            // With the menu open, Enter PICKS the highlighted candidate — never
-            // sends the raw partial. It only sends when the line already is the
-            // exact runnable form: a full NON-config command ("/help", "/exit") or
-            // a config command with its exact option ("/mode plan"). Config
-            // commands without an argument open their option menu instead of the
-            // static listing, so a switch never needs hand-typed input.
-            if (menu) {
-                const item = menu[selIdx] ?? menu[0];
-                const line = edRef.current.text;
-                const spaceIdx = line.indexOf(" ");
-                // One-shot commands ("/exit", "/help", "/compact", ...) run ON PICK:
-                // the highlighted row already names the whole action. Other
-                // command-name menus — skills, plugins, unknown advertised commands —
-                // keep fill semantics: their bare form usually expects an argument,
-                // and sending must stay the user's explicit act.
-                if (spaceIdx < 0 && isOneShotCommandValue(item.value)) {
-                    submitWith(item.value);
-                    return;
-                }
-                // Config argument menus execute ON PICK too ("/model x" switches
-                // right away): the highlighted row already states the full decision,
-                // so fill-then-confirm would only add a redundant enter.
-                if (spaceIdx >= 0 && isConfigArgumentMenu(line)) {
-                    submitWith(`${line.slice(0, spaceIdx + 1)}${item.value}`);
-                    return;
-                }
-                if (spaceIdx < 0) {
-                    if (line === item.value && !isConfigCommand(item.value.replace(/^\//, ""))) {
-                        submitWith(line);
-                    }
-                    else {
-                        applyValue(() => applyCompletion(line, item));
-                    }
-                    return;
-                }
-                if (line === `${line.slice(0, spaceIdx + 1)}${item.value}`) {
-                    submitWith(line);
-                }
-                else {
-                    applyValue(() => applyCompletion(line, item));
-                }
-                return;
-            }
-            submitWith(edRef.current.text);
-            return;
-        }
-        // Caret-aware edits. ←/→ arrive as escape-sequence chunks (never inside
-        // coalesced printable chunks), so they ride the k flags below.
-        if (k.backspace) {
-            applyEdit(backspaceAtCaret);
-            return;
-        }
-        if (k.forwardDelete) {
-            applyEdit(deleteAtCaret);
-            return;
-        }
-        if (k.left) {
-            applyEdit(caretLeft);
-            return;
-        }
-        if (k.right && !menu) {
-            applyEdit(caretRight);
-            return;
-        }
-        // Readline-standard Ctrl chords: B/F move by char, A/E jump to the
-        // line's ends, U kills the whole line. Accept both delivery shapes —
-        // the letter (single keypress) and the raw control byte (coalesced
-        // chunks) — see ctrlChord().
-        if (k.ctrl) {
-            const chord = ctrlChord(ch);
-            if (chord === "b")
-                return void applyEdit(caretLeft);
-            if (chord === "f")
-                return void applyEdit(caretRight);
-            if (chord === "a")
-                return void applyEdit(caretToStart);
-            if (chord === "e")
-                return void applyEdit(caretToEnd);
-            if (chord === "u")
-                return void applyEdit(() => createLineEditor());
-        }
-        if (ch && !k.ctrl && !k.meta) {
-            // Paste/drop chunks can carry escape bytes (bracketed-paste wrappers,
-            // image-drop binary) — sanitize before they reach editor state, or
-            // every later render re-wraps corrupted text.
-            const clean = sanitizeInputChunk(ch);
-            if (clean)
-                applyEdit((cur) => insertAtCaret(cur, clean));
-        }
-    };
-    // Dedicated paste channel (ADR-0009): ink tokenizes ?2004 bracketed pastes
-    // and delivers them here — markers stripped, newlines intact — and NEVER
-    // forwards them to useInput while this hook is mounted. ink also arms and
-    // disarms bracketed-paste mode with this hook's lifecycle.
-    usePaste((text) => {
-        applyEdit((cur) => insertAtCaret(cur, foldPasteChunk(text)));
-    });
-    useInput((inputChar, key) => {
-        const applyOps = (chunk) => {
-            for (const op of planChunkOps(chunk)) {
-                if (op.kind === "insert") {
-                    applyEdit((cur) => insertAtCaret(cur, op.text));
-                }
-                else {
-                    handleChar(op.ch, derivedKey(op.ch), null);
-                }
-            }
-        };
-        // Legacy-terminal fallback (no ?2004): unwrapped pastes arrive as raw
-        // coalesced chunks. Require a real newline to fold — lone \r bytes stay
-        // semantic, so coalesced keystroke bursts that happen to carry an Enter
-        // ("x\r" from fast typing, a held-down return) keep their submit
-        // semantics exactly as they had before ADR-0009.
-        if (inputChar && inputChar.length > 1 && inputChar.includes("\n") && !key.ctrl) {
-            applyEdit((cur) => insertAtCaret(cur, foldPasteChunk(inputChar)));
-            return;
-        }
-        // Coalesced printable chunk (paste, rapid keys) — batched via
-        // planChunkOps: printable runs apply as ONE editor op, semantic bytes
-        // stay per-character. Escape-sequence chunks (arrow keys flushed
-        // together) keep ink's parsed flags instead.
-        if (inputChar && inputChar.length > 1 && !inputChar.includes("\x1b") && !key.ctrl) {
-            applyOps(inputChar);
-            return;
-        }
-        handleChar(inputChar, {
-            return: key.return,
-            tab: key.tab,
-            escape: key.escape,
-            backspace: key.backspace,
-            forwardDelete: key.delete,
-            left: key.leftArrow,
-            right: key.rightArrow,
-            ctrl: key.ctrl,
-            meta: key.meta,
-        }, key.upArrow || key.downArrow || key.rightArrow
-            ? { up: key.upArrow, down: key.downArrow, right: key.rightArrow }
-            : null);
-    });
-    // e.g. "GLM-5.3 · build · max" — lives INSIDE the input box (bottom row),
-    // mirroring the editor dropdown state. The plan-quota suffix rides after it
-    // ("5h 34% · wk 8%"), clamped so one wrap never changes the box height —
-    // the transcript viewport slices heights from CHROME_ROWS.
-    const cols = process.stdout.columns || 100;
-    const statusLine = [
-        selectLabel(status.model),
-        selectLabel(status.mode),
-        selectLabel(status.thought),
-    ]
-        .filter(Boolean)
-        .join(" · ");
-    const LEFT_BUDGET = Math.max(12, cols - 40); // right hint ≈ 34 cols + margin
-    const leftLine = [statusLine, quotaLine].filter(Boolean).join(" · ").slice(0, LEFT_BUDGET);
-    return (
-    // width="100%": the chrome parent is a row Box, so without an explicit
-    // width the whole subtree shrink-wraps to its longest line and the
-    // bordered input box stops spanning the terminal.
-    _jsxs(Box, { flexDirection: "column", width: "100%", children: [menu ? (
-            // Rows are pre-colored as ONE plain string (chalk) instead of a
-            // <Text color> wrapper — whole-string rows always diff as clean
-            // full-line replacements. The block ALWAYS paints COMPLETION_LIMIT
-            // slots (blanks beyond the candidate count), so filtering changes
-            // only line CONTENT, never height: ink's frame update erases the
-            // previous frame's line count upward and rewrites, and a height
-            // change misplaces that sequence — the top candidate row used to
-            // land off-position and go invisible until the selection moved.
-            _jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [Array.from({ length: COMPLETION_LIMIT }, (_, i) => {
-                        const m = menu[i];
-                        if (!m) {
-                            return _jsx(Text, { children: " " }, `slot:${i}`);
-                        }
-                        const desc = m.description ? ` — ${m.description}` : "";
-                        const body = `${m.current ? "● " : "  "}${m.label}${desc}`;
-                        return (_jsx(Text, { children: i === selIdx ? color.cyan(`❯ ${body}`) : `  ${body}` }, `${i}:${m.label}:${m.value}`));
-                    }), _jsx(Text, { dimColor: true, children: (() => {
-                            // Hint follows the HIGHLIGHTED row: one-shot commands announce
-                            // that enter runs them, config menus that it switches, and
-                            // everything else keeps pick-to-fill.
-                            if (isConfigArgumentMenu(ed.text)) {
-                                return " ↑/↓ select · enter switches now · tab fills · esc dismiss";
-                            }
-                            const picked = menu[selIdx] ?? menu[0];
-                            if (picked && isOneShotCommandValue(picked.value)) {
-                                return " ↑/↓ select · enter runs it now · tab fills · esc dismiss";
-                            }
-                            return " ↑/↓ select · tab or enter picks · esc dismiss";
-                        })() })] })) : null, _jsxs(Box, { borderStyle: "round", borderColor: busy ? "gray" : "cyan", paddingX: 1, width: "100%", flexDirection: "column", children: [(() => {
-                        // Multi-row prompt: text hard-wraps at the inner width and the
-                        // block cursor sits on its OWN visual row — soft-wrap via implicit
-                        // ink layout used to strand the caret visually on the first row.
-                        const prefix = busy ? "starting… " : "❯ ";
-                        const prefixCols = stringWidth(prefix);
-                        const inner = Math.max(4, cols - 2 - prefixCols);
-                        const rows = wrapEditorLine(ed.text, inner);
-                        const pos = locateCaret(ed.text, ed.caret, inner);
-                        return (_jsx(Box, { flexDirection: "column", children: rows.map((r, i) => {
-                                const indent = i === 0 ? prefix : " ".repeat(prefixCols);
-                                if (i !== pos.row) {
-                                    return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: indent }), r.text ? _jsx(Text, { children: r.text }) : _jsx(Text, { children: " " })] }, r.start));
-                                }
-                                // Block cursor on the character at the caret (a space past
-                                // the end) — makes ←/→ editing visible.
-                                const parts = Array.from(r.text);
-                                const split = Math.max(0, Math.min(parts.length, pos.rowOffset));
-                                const before = parts.slice(0, split).join("");
-                                const atCaret = parts.slice(split, split + 1).join("");
-                                const after = parts.slice(split + 1).join("");
-                                return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: indent }), _jsx(Text, { children: before }), _jsx(Text, { backgroundColor: "white", color: "black", children: atCaret || " " }), after ? _jsx(Text, { children: after }) : null] }, r.start));
-                            }) }));
-                    })(), _jsxs(Box, { justifyContent: "space-between", width: "100%", children: [_jsx(Text, { dimColor: true, children: leftLine || "type / for commands · tab completes" }), _jsx(Text, { dimColor: true, children: " " }), _jsx(Text, { dimColor: true, children: busy ? "" : "enter send · esc interrupt · ctrl-c quit" })] })] })] }));
-}
-/**
- * Rendered height of one live-turn entry (local twin of the old viewport
- * entryHeight): feeds turnHeight's cap math only.
- */
-function entryHeight(entry, width) {
-    switch (entry.kind) {
-        case "user":
-            return 1 + estimateLines(`> ${entry.text}`, width);
-        case "welcome":
-            // Branding + session + sandbox row + config + 5 hint lines + margins.
-            return 1 + 13;
-        case "tool":
-            return estimateLines(`• ${entry.title} (${entry.status})`, width);
-        default:
-            return estimateLines(entry.text, width);
-    }
-}
-/**
- * Height of the live-turn block (entries + streaming buffers + spinner).
- * Deliberately biased HIGH: an underestimate makes the whole layout exceed
- * the terminal and ink clips from the bottom — the input box disappears. A
- * few blank rows at the bottom of the viewport are harmless by contrast.
- */
-function turnHeight(turn, width) {
-    if (!turn)
-        return 0;
-    let h = turn.entries.reduce((n, e) => n + entryHeight(e, width), 0);
-    const tail = lastToolTail(turn);
-    if (tail)
-        h += estimateLines(tail, width);
-    if (turn.thinkBuf.trim()) {
-        // The render collapses whitespace and keeps only the tail, but even that
-        // can wrap (CJK especially) — measure it instead of assuming one line.
-        h += estimateLines(`⎿ thinking · ${turn.thinkBuf.replace(/\s+/g, " ").slice(-120)}`, width);
-    }
-    if (turn.textBuf)
-        h += estimateLines(turn.textBuf, width);
-    return h + 1 + 2; // spinner line + safety margin
-}
-export function App(props) {
-    const { entries, turn, permission, question, sessionPick, queued, status, busy } = props;
-    // Second consecutive idle Ctrl-C exits; a turn-running Ctrl-C only cancels.
-    const idleIntCount = useRef(0);
-    // --- live-turn liveness ticker ---
-    // A turn with no streamed output (model thinking, silent tool calls) would
-    // otherwise leave the footer frozen — indistinguishable from a stall. The
-    // status row below re-renders once a second so time visibly progresses.
-    const [, tick] = useState(0);
-    const turnStartRef = useRef(null);
-    if (turn && turnStartRef.current === null)
-        turnStartRef.current = Date.now();
-    if (!turn)
-        turnStartRef.current = null;
-    const turnActive = turn !== null;
-    useEffect(() => {
-        if (!turnActive)
-            return;
-        const timer = setInterval(() => tick((n) => n + 1), 1000);
-        return () => clearInterval(timer);
-    }, [turnActive]);
-    // Native-scrollback layout: full terminal width — no centered reading
-    // column. `rows` still matters for capping the live-turn tail so the input
-    // box can't be pushed off-screen mid-stream; there is no viewport math.
-    const cols = process.stdout.columns || 100;
-    const rows = process.stdout.rows || 24;
-    const submit = useCallback((text) => props.onSubmit(text), [props]);
-    // --- picker keyboard state ---
-    // Pickers are PURE VIEWS; all their keys are handled HERE in the app-level
-    // useInput. ink's per-component useInput proved unreliable for components
-    // mounted late via external rerenders (ink.rerender from the run loop):
-    // the freshly-mounted hook sometimes never receives events. The root-level
-    // hook always does.
-    const EMPTY_Q = { index: 0, custom: null, toggled: [] };
-    const [q, setQ] = useState(EMPTY_Q);
-    const qRef = useRef(EMPTY_Q);
-    const applyQ = (fn) => {
-        qRef.current = fn(qRef.current);
-        setQ(qRef.current);
-    };
-    useEffect(() => {
-        // New question (or cleared) → fresh selection state.
-        applyQ(() => EMPTY_Q);
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [question]);
-    const [permIndex, setPermIndex] = useState(0);
-    const permIndexRef = useRef(0);
-    useEffect(() => {
-        permIndexRef.current = 0;
-        setPermIndex(0);
-    }, [permission]);
-    // /sessions picker selection (mirrored in a ref for the key handler).
-    const [sessIndex, setSessIndex] = useState(0);
-    const sessIndexRef = useRef(0);
-    useEffect(() => {
-        sessIndexRef.current = 0;
-        setSessIndex(0);
-    }, [sessionPick]);
-    useInput((inputChar, key) => {
-        if (sessionPick && sessionPick.items.length > 0) {
-            handleSessionKey(inputChar, key);
-            return;
-        }
-        if (question) {
-            handleQuestionKey(inputChar, key);
-            return;
-        }
-        if (permission) {
-            handlePermissionKey(inputChar, key);
-            return;
-        }
-        // Prompt-history recall: the completion menu keeps its claim on ↑/↓ while
-        // open (its own handler consumes them); with it closed — and no picker
-        // mounted — the arrows walk submitted prompts (ADR-0008). InputLine's
-        // handler also sees these keys but only nudges its (reset) selection.
-        if ((key.upArrow || key.downArrow) &&
-            !props.isMenuOpen() &&
-            !sessionPick &&
-            !question &&
-            !permission) {
-            if (key.upArrow)
-                props.onHistoryUp();
-            else
-                props.onHistoryDown();
-            return;
-        }
-        // Esc interrupts the running turn — with or without queued follow-ups;
-        // the stop handler drains the queue, so a next queued message starts at
-        // once. With the completion menu open, the menu takes this esc instead
-        // (dismiss); a second esc reaches here and interrupts.
-        if (key.escape && turn && !props.isMenuOpen()) {
-            props.onCancelTurn();
-            return;
-        }
-        // Count ctrl-c presses across both delivery shapes: a lone \x03 arrives
-        // as ("c", ctrl) but rapid presses coalesce into one raw "\x03\x03"
-        // chunk with ctrl=false (ink does not split multi-key chunks).
-        const presses = (key.ctrl && inputChar === "c" ? 1 : 0) + ((inputChar ?? "").match(/\x03/g)?.length ?? 0);
-        if (presses > 0) {
-            if (turn) {
-                props.onCancelTurn();
-                idleIntCount.current = 0;
-            }
-            else {
-                idleIntCount.current += presses;
-                if (idleIntCount.current >= 2)
-                    props.onExit();
-            }
-            return;
-        }
-        idleIntCount.current = 0;
-    });
-    /** Keys for the active AskUserQuestion picker (state mirrors in qRef). */
-    function handleQuestionKey(inputChar, key) {
-        if (!question)
-            return;
-        const isSkip = isCancelKey(inputChar, key);
-        if (qRef.current.custom !== null) {
-            if (key.return) {
-                props.onAnswerQuestion({ picked: [...qRef.current.toggled], custom: qRef.current.custom });
-                return;
-            }
-            if (isSkip) {
-                applyQ((s) => ({ ...s, custom: null }));
-                return;
-            }
-            if (key.backspace || key.delete) {
-                applyQ((s) => ({ ...s, custom: (s.custom ?? "").slice(0, -1) }));
-                return;
-            }
-            if (inputChar &&
-                !key.ctrl &&
-                !key.meta &&
-                inputChar.length === 1 &&
-                !/[\r\n]/.test(inputChar)) {
-                applyQ((s) => ({ ...s, custom: (s.custom ?? "") + inputChar }));
-            }
-            return;
-        }
-        if (key.upArrow) {
-            applyQ((s) => ({ ...s, index: Math.max(0, s.index - 1) }));
-            return;
-        }
-        if (key.downArrow) {
-            applyQ((s) => ({ ...s, index: Math.min(question.options.length, s.index + 1) }));
-            return;
-        }
-        if (isSkip) {
-            props.onAnswerQuestion(null); // skip this question
-            return;
-        }
-        const onCustomRow = qRef.current.index === question.options.length;
-        if (key.return || key.tab) {
-            if (onCustomRow) {
-                applyQ((s) => ({ ...s, custom: "" }));
-                return;
-            }
-            if (question.multiSelect) {
-                props.onAnswerQuestion({ picked: [...qRef.current.toggled], custom: "" });
-                return;
-            }
-            props.onAnswerQuestion({
-                picked: [question.options[qRef.current.index].value],
-                custom: "",
-            });
-            return;
-        }
-        if (inputChar === " " && question.multiSelect && !onCustomRow) {
-            const value = question.options[qRef.current.index].value;
-            applyQ((s) => ({
-                ...s,
-                toggled: s.toggled.includes(value)
-                    ? s.toggled.filter((v) => v !== value)
-                    : [...s.toggled, value],
-            }));
-        }
-    }
-    /** Keys for the /sessions picker (selection mirrored in sessIndexRef). */
-    function handleSessionKey(inputChar, key) {
-        if (!sessionPick)
-            return;
-        const last = sessionPick.items.length - 1;
-        if (key.upArrow) {
-            sessIndexRef.current = Math.max(0, sessIndexRef.current - 1);
-            setSessIndex(sessIndexRef.current);
-            return;
-        }
-        if (key.downArrow) {
-            sessIndexRef.current = Math.min(last, sessIndexRef.current + 1);
-            setSessIndex(sessIndexRef.current);
-            return;
-        }
-        if (key.return) {
-            props.onPickSession(sessionPick.items[sessIndexRef.current].sessionId);
-            return;
-        }
-        if (isCancelKey(inputChar, key)) {
-            props.onPickSession(null);
-        }
-    }
-    /** Keys for the active permission picker (selection mirrored in permIndexRef). */
-    function handlePermissionKey(inputChar, key) {
-        if (!permission)
-            return;
-        if (key.upArrow) {
-            permIndexRef.current = Math.max(0, permIndexRef.current - 1);
-            setPermIndex(permIndexRef.current);
-            return;
-        }
-        if (key.downArrow) {
-            permIndexRef.current = Math.min(permission.options.length - 1, permIndexRef.current + 1);
-            setPermIndex(permIndexRef.current);
-            return;
-        }
-        if (key.return) {
-            props.onAnswerPermission(permission.options[permIndexRef.current].id);
-            return;
-        }
-        if (isCancelKey(inputChar, key)) {
-            props.onAnswerPermission(null);
-        }
-    }
-    // The queued-prompts panel sits between the turn block and the input box.
-    const queuedShown = Math.min(queued.length, 3);
-    const queueRows = queued.length > 0 ? queuedShown + (queued.length > 3 ? 1 : 0) + 1 : 0;
-    // The live-turn block is capped at half the screen: the input box must
-    // stay visible while a long reply streams, and non-alt-screen ink can't
-    // pin anything — a taller dynamic footer would push it below the fold.
-    // Older turn entries crop from the top (bottom-anchored + overflow:hidden);
-    // the full transcript lands in <Static> on stop.
-    const MAX_TURN_ROWS = Math.max(6, Math.floor(rows / 2));
-    // Bottom-anchored overflow:hidden also absorbs ink word-wrap vs hard-cut
-    // estimate drift INSIDE this box: an undercounted row crops invisibly off
-    // the top instead of stretching the footer past the fold.
-    const turnBudget = Math.min(turnHeight(turn, cols), MAX_TURN_ROWS);
-    // Status row for the live-turn block: phase label + elapsed seconds. Bright
-    // (not dim) and self-updating — this line is the "still alive" signal.
-    const turnElapsed = turnStartRef.current
-        ? Math.max(0, Math.floor((Date.now() - turnStartRef.current) / 1000))
-        : 0;
-    const turnLabel = turn
-        ? turn.textBuf
-            ? "writing"
-            : turn.thinkBuf.trim()
-                ? "thinking"
-                : "working"
-        : "";
-    return (_jsxs(Box, { flexDirection: "column", width: cols, children: [_jsx(Static, { items: entries, children: (entry, index) => (_jsx(Box, { flexDirection: "column", width: cols, children: _jsx(EntryView, { entry: entry }) }, index)) }), props.replaying ? (_jsxs(Text, { dimColor: true, children: [_jsx(Spinner, { type: "dots" }), " restoring history\u2026"] })) : null, turn ? (_jsxs(Box, { flexDirection: "column", width: cols, height: turnBudget, overflow: "hidden", justifyContent: "flex-end", children: [(() => {
-                        // Attach the live output tail to the LAST tool row: a long silent
-                        // tool (build, sleep, sub-agent work) otherwise shows nothing but
-                        // its title and the spinner seconds for minutes on end.
-                        let tailIdx = -1;
-                        for (let i = turn.entries.length - 1; i >= 0; i--) {
-                            if (turn.entries[i].kind === "tool") {
-                                tailIdx = i;
-                                break;
-                            }
-                        }
-                        const tail = lastToolTail(turn);
-                        return turn.entries.map((e, i) => (_jsxs(Fragment, { children: [_jsx(EntryView, { entry: e }), i === tailIdx && tail ? _jsx(Text, { dimColor: true, children: tail }) : null] }, i)));
-                    })(), turn.thinkBuf.trim() ? (_jsxs(Text, { dimColor: true, children: ["\u23BF thinking \u00B7 ", turn.thinkBuf.replace(/\s+/g, " ").slice(-120)] })) : null, turn.textBuf ? _jsx(Text, { children: colorizeCodeFences(turn.textBuf) }) : null, _jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " ", turnLabel, "\u2026 (", turnElapsed, "s \u00B7 esc to interrupt)"] })] })) : null, queued.length > 0 ? (_jsxs(Box, { flexDirection: "column", width: cols, height: queueRows, overflow: "hidden", justifyContent: "flex-end", children: [queued.slice(0, 3).map((text, i) => (_jsxs(Text, { dimColor: true, children: ["\u23F8 queued \u00B7 ", text.length > cols - 16 ? `${text.slice(0, cols - 17)}…` : text] }, `${i}:${text}`))), queued.length > 3 ? _jsxs(Text, { dimColor: true, children: ["\u23F8 \u2026 +", queued.length - 3, " more"] }) : null, turn ? (_jsx(Text, { dimColor: true, children: " esc stops the current turn and sends the next queued message" })) : null] })) : null, _jsx(Box, { width: cols, children: sessionPick ? (_jsx(SessionPicker, { pick: sessionPick, index: sessIndex, cwd: process.cwd() })) : permission ? (_jsx(PermissionPicker, { prompt: permission, index: permIndex })) : question ? (_jsx(QuestionPicker, { prompt: question, state: q })) : (_jsx(InputLine, { busy: busy, status: status, editor: props.editor, applyEdit: props.applyEdit, quotaLine: props.quotaLine, onMenuOpenChange: props.onMenuOpenChange, onSubmitText: submit })) })] }));
-}
-/**
- * `/sessions` picker: resumable sessions of the current project, newest last
- * (the backend orders by activity). Enter resumes; esc dismisses.
- */
-function SessionPicker({ pick, index, cwd, }) {
-    const win = pickerWindow(pick.items, index);
-    const above = win.start;
-    const below = pick.items.length - (win.start + win.slice.length);
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { bold: true, children: ["sessions \u00B7 ", cwd, " \u00B7 ", Math.min(index + 1, pick.items.length), "/", pick.items.length] }), above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u2026 ", above, " newer above"] }) : null, win.slice.map((s, i) => {
-                const abs = win.start + i;
-                const title = s.title?.trim() || "untitled";
-                const age = relativeTime(s.updatedAt);
-                const elsewhere = s.cwd && s.cwd !== cwd ? ` · ${s.cwd}` : "";
-                // Live sessions are owned by another bridge instance right now —
-                // picking one attaches through the hub and streams updates as they
-                // happen (ADR-0018) instead of replaying a frozen local snapshot.
-                const live = s.live ? (s.running ? " · live ●" : " · live") : "";
-                return (_jsxs(Box, { paddingLeft: 1, children: [_jsxs(Text, { color: abs === index ? "cyan" : undefined, children: [abs === index ? "❯ " : "  ", title] }), _jsxs(Text, { dimColor: true, children: [" ", age ? `· ${age}` : "", "\u00B7 ", s.sessionId.slice(0, 8), live, elsewhere] })] }, s.sessionId));
-            }), below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u2026 ", below, " older below"] }) : null, _jsx(Text, { dimColor: true, children: "\u2191/\u2193 select \u00B7 enter resume \u00B7 esc cancel" })] }));
-}
-function PermissionPicker({ prompt, index, }) {
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { bold: true, children: prompt.heading }), _jsx(Text, { children: prompt.title }), prompt.detail ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { children: colorizeCodeFences(prompt.detail.trimEnd()) }) })) : null, prompt.options.map((opt, i) => (_jsx(Box, { paddingLeft: 1, marginTop: i === 0 && prompt.detail ? 1 : 0, children: _jsxs(Text, { color: i === index ? "cyan" : undefined, children: [i === index ? "❯ " : "  ", opt.name] }) }, opt.id))), _jsx(Text, { dimColor: true, children: "\u2191/\u2193 select \u00B7 enter confirm \u00B7 esc cancel" })] }));
-}
-/**
- * AskUserQuestion picker: the question text as the heading (NOT a permission
- * shell), options below, and a built-in custom-answer row. Single-select:
- * enter picks. Multi-select: space toggles, enter confirms. esc/ctrl-c skips
- * the question (its key is omitted from the form response).
- */
-function QuestionPicker({ prompt, state, }) {
-    const customRow = prompt.options.length; // index of the custom row
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { bold: true, children: ["\u2753 ", prompt.title] }), prompt.options.map((opt, i) => (_jsx(Box, { paddingLeft: 1, children: _jsxs(Text, { color: i === state.index ? "cyan" : undefined, children: [i === state.index ? "❯ " : "  ", prompt.multiSelect ? (state.toggled.includes(opt.value) ? "[●] " : "[ ] ") : "", opt.label] }) }, opt.value))), state.custom !== null ? (_jsxs(Box, { paddingLeft: 1, children: [_jsx(Text, { color: "cyan", children: "\u276F \u270E " }), _jsx(Text, { children: state.custom }), _jsx(Text, { dimColor: true, children: "\u258F" })] })) : (_jsx(Box, { paddingLeft: 1, children: _jsxs(Text, { color: state.index === customRow ? "cyan" : undefined, dimColor: state.index !== customRow, children: [state.index === customRow ? "❯ " : "  ", "\u270E type a custom answer\u2026"] }) })), _jsx(Text, { dimColor: true, children: prompt.multiSelect
-                    ? "↑/↓ move · space toggle · enter confirm · esc skip"
-                    : "↑/↓ move · enter pick · esc skip" })] }));
-}
-//# sourceMappingURL=App.js.map