zcode-acp-server 0.11.8 → 0.14.1

package/dist/repl/App.js

@@ -0,0 +1,706 @@
+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 { useCallback, useEffect, useRef, useState } from "react";
+import stringWidth from "string-width";
+import { applyCompletion, COMPLETION_LIMIT, completionCandidates, estimateLines, isConfigArgumentMenu, isConfigCommand, isOneShotCommandValue, 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] }), 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 "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":
+            return 1 + 12;
+        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);
+    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: [turn.entries.map((e, i) => (_jsx(EntryView, { entry: e }, 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}` : "";
+                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), 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