@ouro.bot/cli 0.1.0-alpha.56 → 0.1.0-alpha.561

package/dist/senses/cli/ouro-tui.js

@@ -0,0 +1,607 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueuedMessages = QueuedMessages;
+exports.OuroTui = OuroTui;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * Ouroboros TUI — full terminal interface using Ink v3 + Static.
+ *
+ * Architecture:
+ *   <Static> renders completed messages ONCE — they scroll up naturally.
+ *   Only the "live" area (current streaming + spinner + input) re-renders.
+ *   This avoids the screen-clearing problem that broke the previous Ink attempt.
+ *
+ * Design language: ouroboros brand palette from ouroboros.bot / Mailbox UI.
+ * ZERO business logic here — pure rendering from CliStore state.
+ */
+const react_1 = require("react");
+const ink_1 = require("ink");
+const streaming_markdown_1 = require("./streaming-markdown");
+const image_paste_1 = require("./image-paste");
+const kill_ring_1 = require("./kill-ring");
+const input_keys_1 = require("./input-keys");
+const image_ref_navigation_1 = require("./image-ref-navigation");
+// ─── Ouroboros Brand Palette (ANSI RGB) ─────────────────────────────
+// From packages/mailbox-ui/src/style.css and ouroboros.bot
+const OURO = {
+    scale: "#2f8f4e", // primary green
+    teal: "#4ec9b0", // tool/accent teal
+    glow: "#74e08f", // bright green (highlights)
+    bone: "#eef2ea", // light text
+    mist: "#a5b8a8", // dim text
+    shadow: "#708373", // very dim
+    fang: "#d35f47", // error red
+    gold: "#d6b56f", // warning amber
+    moss: "#183325", // subtle bg accent
+    separator: "#3a5a40", // dim line separator
+};
+// ─── Ring Spinner (growing/shrinking) ───────────────────────────────
+const RING_FRAMES = ["∙", "○", "◎", "●", "◎", "○"];
+function ringColor(elapsedSec) {
+    if (elapsedSec >= 45)
+        return OURO.fang;
+    if (elapsedSec >= 15)
+        return OURO.gold;
+    return OURO.scale;
+}
+// ─── Header ─────────────────────────────────────────────────────────
+/** Terminal width for content (capped at 200, with 2-char margin) */
+function safeWidth() {
+    return Math.min(process.stdout.columns || 80, 200) - 2;
+}
+/** Full terminal width for edge-to-edge elements (separators) */
+function termWidth() {
+    return process.stdout.columns || 80;
+}
+function Header({ agentName, model, contextPercent, cwd, resumeInfo }) {
+    const showCtx = contextPercent > 0;
+    const info = [agentName, model, cwd, showCtx ? `ctx ${contextPercent}%` : ""].filter(Boolean).join(" · ");
+    // 3-segment snake: TAIL (fixed) + MIDDLE (stretches) + HEAD (fixed)
+    const HEAD1 = "     ____";
+    const HEAD2 = "____/ O  \\___/";
+    const HEAD3 = "_________/   \\";
+    const TAIL1 = "   ";
+    const TAIL2 = " __";
+    const TAIL3 = "<__";
+    const fixedWidth = TAIL1.length + HEAD1.length;
+    const maxMiddle = safeWidth() - fixedWidth;
+    const middleLen = Math.max(Math.min(Math.max(info.length, 20), maxMiddle), 10);
+    const textPad = Math.max(middleLen - info.length, 0);
+    const line1 = TAIL1 + " ".repeat(middleLen) + HEAD1;
+    const line2 = TAIL2 + "_".repeat(middleLen) + HEAD2;
+    const line3text = (info.length > middleLen ? info.slice(0, middleLen) : info) + "_".repeat(textPad);
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.scale, children: line1 }), (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.scale, children: line2 }), (0, jsx_runtime_1.jsxs)(ink_1.Text, { color: OURO.scale, children: [TAIL3, (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.glow, children: line3text }), (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.scale, children: HEAD3 })] }), resumeInfo ? ((0, jsx_runtime_1.jsxs)(ink_1.Text, { color: OURO.teal, children: ["  resuming \u00b7 ", resumeInfo.messageCount, " messages \u00b7 last active ", resumeInfo.timeAgo] })) : null] }));
+}
+// ─── Message Rendering ──────────────────────────────────────────────
+// Flow control tools are invisible to the user — they are internal agent mechanics.
+// `speak` is included because its visible output is the message itself (rendered as
+// regular assistant text), not a tool-result line or in-progress activity indicator.
+const FLOW_CONTROL_TOOLS = new Set(["settle", "ponder", "observe", "rest", "speak"]);
+function ToolResultLine({ tc }) {
+    const icon = tc.success !== false ? "✓" : "✗";
+    const iconColor = tc.success !== false ? OURO.scale : OURO.fang;
+    const argColor = tc.success === false ? OURO.fang : OURO.shadow;
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Text, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: iconColor, children: icon }), " ", (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.teal, children: tc.name }), " ", (0, jsx_runtime_1.jsx)(ink_1.Text, { color: argColor, children: tc.argSummary })] }));
+}
+function MessageBlock({ msg }) {
+    if (msg.role === "tool") {
+        const visibleCalls = msg.toolCalls?.filter(tc => !FLOW_CONTROL_TOOLS.has(tc.name));
+        // Flow control tools produce no visible output at all
+        if (!visibleCalls || visibleCalls.length === 0)
+            return (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" });
+        return ((0, jsx_runtime_1.jsx)(ink_1.Box, { flexDirection: "column", children: visibleCalls.map((tc, i) => (0, jsx_runtime_1.jsx)(ToolResultLine, { tc: tc }, i)) }));
+    }
+    if (msg.role === "user") {
+        return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", marginTop: 1, children: [msg.content ? (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.bone, bold: true, children: msg.content }) : null, (0, jsx_runtime_1.jsx)(ink_1.Box, { marginBottom: 1, children: (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }) })] }));
+    }
+    if (msg.role === "assistant") {
+        return ((0, jsx_runtime_1.jsx)(ink_1.Box, { flexDirection: "column", marginBottom: 1, children: msg.content ? (0, jsx_runtime_1.jsx)(streaming_markdown_1.StreamingMarkdown, { text: msg.content, maxWidth: safeWidth() }) : null }));
+    }
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", marginTop: 1, children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.shadow, children: msg.content }), (0, jsx_runtime_1.jsx)(ink_1.Box, { marginBottom: 1, children: (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }) })] }));
+}
+// ─── Live Area (re-renders) ─────────────────────────────────────────
+function Spinner({ phrasePool, elapsed }) {
+    const [frame, setFrame] = (0, react_1.useState)(0);
+    const [currentPhrase, setCurrentPhrase] = (0, react_1.useState)(() => phrasePool.length > 0 ? phrasePool[Math.floor(Math.random() * phrasePool.length)] : "");
+    // Animate ring frames
+    (0, react_1.useEffect)(() => {
+        const iv = setInterval(() => setFrame(f => (f + 1) % RING_FRAMES.length), 300);
+        return () => clearInterval(iv);
+    }, []);
+    // Rotate phrases every 3 seconds
+    (0, react_1.useEffect)(() => {
+        if (phrasePool.length <= 1)
+            return;
+        const iv = setInterval(() => {
+            setCurrentPhrase(phrasePool[Math.floor(Math.random() * phrasePool.length)]);
+        }, 3000);
+        return () => clearInterval(iv);
+    }, [phrasePool]);
+    const color = ringColor(elapsed);
+    const timeStr = elapsed > 0 ? `${elapsed}s` : "";
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Text, { color: color, children: [RING_FRAMES[frame], " ", timeStr ? (0, jsx_runtime_1.jsxs)(ink_1.Text, { color: OURO.shadow, children: [timeStr, " \u00B7 "] }) : "", currentPhrase] }));
+}
+function formatActiveToolArgs(name, args) {
+    switch (name) {
+        case "shell":
+            return `$ ${args.command ?? "?"}`;
+        case "read_file":
+            return `path=${args.path ?? "?"}`;
+        case "write_file":
+            return `path=${args.path ?? "?"}`;
+        case "edit_file":
+            return args.path ?? "?";
+        case "glob":
+            return `pattern=${args.pattern ?? "?"}`;
+        case "grep":
+            return `pattern=${args.pattern ?? "?"} ${args.path ? `path=${args.path}` : ""}`.trim();
+        default: {
+            // Show first 2 key=value pairs
+            const entries = Object.entries(args).slice(0, 2);
+            return entries.map(([k, v]) => `${k}=${String(v).slice(0, 50)}`).join(" ");
+        }
+    }
+}
+function ActiveToolLine({ tool }) {
+    // Hide flow control tools from in-progress display
+    if (FLOW_CONTROL_TOOLS.has(tool.name))
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" });
+    const argStr = formatActiveToolArgs(tool.name, tool.args);
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Text, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.shadow, children: "∙" }), " ", (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.teal, children: tool.name }), " ", (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.shadow, children: argStr })] }));
+}
+function LiveArea({ live, elapsed }) {
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [live.streamingText ? ((0, jsx_runtime_1.jsx)(streaming_markdown_1.StreamingMarkdown, { text: live.streamingText, maxWidth: safeWidth() })) : null, live.activeTool ? ((0, jsx_runtime_1.jsx)(ActiveToolLine, { tool: live.activeTool })) : null, live.loading ? ((0, jsx_runtime_1.jsx)(Spinner, { phrasePool: live.spinnerPhrasePool, elapsed: elapsed })) : null, live.errorMessage ? ((0, jsx_runtime_1.jsxs)(ink_1.Text, { color: OURO.fang, children: ["✗ ", live.errorMessage] })) : null, live.kickMessage ? ((0, jsx_runtime_1.jsxs)(ink_1.Text, { color: OURO.gold, children: ["↻ ", live.kickMessage] })) : null] }));
+}
+// ─── Queued Messages ───────────────────────────────────────────────
+function QueuedMessages({ items }) {
+    if (items.length === 0)
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" });
+    return ((0, jsx_runtime_1.jsx)(ink_1.Box, { flexDirection: "column", children: items.map((text, i) => ((0, jsx_runtime_1.jsxs)(ink_1.Text, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.shadow, children: "\u231B queued: " }), (0, jsx_runtime_1.jsxs)(ink_1.Text, { color: OURO.mist, children: ["\"", text, "\""] })] }, i))) }));
+}
+// ─── Kill Ring (session-scoped) ─────────────────────────────────────
+const killRing = new kill_ring_1.KillRing();
+// ─── Input ──────────────────────────────────────────────────────────
+function InputArea({ onSubmit, onCtrlC, history, queuedInputs, onPopQueue, agentName, model, onImageMap, onHistoryAdd }) {
+    const [input, setInput] = (0, react_1.useState)("");
+    const [cursorPos, setCursorPos] = (0, react_1.useState)(0); // cursor position within input
+    const [tooltip, setTooltip] = (0, react_1.useState)("");
+    const [cursorVisible, setCursorVisible] = (0, react_1.useState)(true);
+    const inputRef = (0, react_1.useRef)("");
+    const cursorRef = (0, react_1.useRef)(0);
+    const historyIdx = (0, react_1.useRef)(-1);
+    const savedInput = (0, react_1.useRef)("");
+    // Deferred ESC handling: Ink 3.2 fires escape events for ESC prefix of arrow
+    // keys (\x1b[D) and Alt+Enter (\x1b\r). We defer ESC actions by 80ms — if
+    // another key arrives in that window, it was an escape sequence, not standalone ESC.
+    const escTimerRef = (0, react_1.useRef)(null);
+    const lastEscTime = (0, react_1.useRef)(0);
+    const tooltipTimerRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => () => {
+        if (tooltipTimerRef.current)
+            clearTimeout(tooltipTimerRef.current);
+    }, []);
+    // Helper: update input and cursor together
+    const updateInput = (text, pos) => {
+        inputRef.current = text;
+        cursorRef.current = pos ?? text.length;
+        setInput(text);
+        setCursorPos(cursorRef.current);
+    };
+    // Blinking cursor
+    (0, react_1.useEffect)(() => {
+        const iv = setInterval(() => setCursorVisible(v => !v), 530);
+        return () => clearInterval(iv);
+    }, []);
+    const handleCtrlC = (0, react_1.useCallback)(() => {
+        const action = onCtrlC(inputRef.current.length > 0);
+        if (action === "clear") {
+            inputRef.current = "";
+            setInput("");
+            setTooltip("");
+            setTooltip("");
+        }
+        else if (action === "warn") {
+            // tooltip handled below
+            setTooltip("Ctrl-C again to exit");
+            if (tooltipTimerRef.current)
+                clearTimeout(tooltipTimerRef.current);
+            tooltipTimerRef.current = setTimeout(() => setTooltip(""), 3000);
+        }
+        // "abort" and "exit" are handled by the parent (cli.ts)
+    }, [onCtrlC]);
+    (0, ink_1.useInput)((inputChar, key) => {
+        if (key.ctrl && inputChar === "c") {
+            handleCtrlC();
+            return;
+        }
+        // Input is NEVER blocked — user can type while agent responds (TTFA)
+        // Any non-Ctrl-C input clears tooltip
+        setTooltip("");
+        if (key.escape) {
+            lastEscTime.current = Date.now();
+            // Defer ESC action — if another key arrives within 80ms, this was an escape
+            // sequence prefix (arrow key, Alt+Enter), not a standalone Escape press.
+            if (escTimerRef.current)
+                clearTimeout(escTimerRef.current);
+            escTimerRef.current = setTimeout(() => {
+                escTimerRef.current = null;
+                if (inputRef.current) {
+                    // Save to history before clearing (so Up arrow can retrieve it)
+                    if (onHistoryAdd)
+                        onHistoryAdd(inputRef.current);
+                    updateInput("");
+                    historyIdx.current = -1;
+                    setTooltip("Esc again to clear");
+                    if (tooltipTimerRef.current)
+                        clearTimeout(tooltipTimerRef.current);
+                    tooltipTimerRef.current = setTimeout(() => setTooltip(""), 2000);
+                }
+                else if (queuedInputs.length > 0) {
+                    const items = onPopQueue();
+                    updateInput(items.join("\n"));
+                    historyIdx.current = -1;
+                }
+                else {
+                    setTooltip("");
+                }
+            }, 80);
+            return;
+        }
+        // Cancel pending ESC action — this key is part of an escape sequence
+        if (escTimerRef.current) {
+            clearTimeout(escTimerRef.current);
+            escTimerRef.current = null;
+        }
+        // PageUp/PageDown: suppress (no text insertion, no action)
+        if (key.pageUp || key.pageDown)
+            return;
+        // Alt+Enter (single data event): Ink checks `return: input === '\r'` before
+        // stripping the \x1b prefix, so key.return is false when the terminal sends
+        // \x1b\r as one chunk.  Detect via the stripped inputChar instead.
+        if (inputChar === "\r" && key.meta) {
+            lastEscTime.current = 0;
+            const before = inputRef.current.slice(0, cursorRef.current);
+            const after = inputRef.current.slice(cursorRef.current);
+            updateInput(before + "\n" + after, cursorRef.current + 1);
+            return;
+        }
+        if (key.return) {
+            // Alt+Enter: detect via key.meta OR recent ESC (within 50ms — Ink splits \x1b\r)
+            const recentEsc = (Date.now() - lastEscTime.current) < 50;
+            if (key.meta || key.shift || recentEsc) {
+                lastEscTime.current = 0;
+                const before = inputRef.current.slice(0, cursorRef.current);
+                const after = inputRef.current.slice(cursorRef.current);
+                updateInput(before + "\n" + after, cursorRef.current + 1);
+                return;
+            }
+            // Backslash+Enter: insert newline (like Claude Code)
+            if (cursorRef.current > 0 && inputRef.current[cursorRef.current - 1] === "\\") {
+                const before = inputRef.current.slice(0, cursorRef.current - 1);
+                const after = inputRef.current.slice(cursorRef.current);
+                updateInput(before + "\n" + after, cursorRef.current);
+                return;
+            }
+            const text = inputRef.current;
+            if (text.trim()) {
+                const { text: processedText, images } = (0, image_paste_1.processSubmitInput)(text);
+                if (images.size > 0 && onImageMap) {
+                    onImageMap(images);
+                }
+                onSubmit(images.size > 0 ? processedText : text);
+            }
+            updateInput("");
+            historyIdx.current = -1;
+            return;
+        }
+        // Backspace / Forward Delete:
+        // Ink 3.2 maps \x7f (macOS backspace) to key.delete (meta=false).
+        // Ink maps \x1b[3~ (fn+Delete / forward delete) to key.delete (meta=true,
+        // because \x1b prefix triggers meta detection).
+        // Ink maps \x08 (Ctrl+H style) to key.backspace.
+        // Distinguishing: key.meta differentiates fn+Delete from plain backspace.
+        if ((key.backspace || key.delete) && key.meta) {
+            // fn+Delete: forward delete
+            const result = (0, input_keys_1.handleForwardDelete)(inputRef.current, cursorRef.current);
+            updateInput(result.text, result.cursorPos);
+            historyIdx.current = -1;
+            return;
+        }
+        if (key.backspace || key.delete) {
+            // Plain backspace: delete backward
+            if (cursorRef.current > 0) {
+                const chip = (0, image_ref_navigation_1.deleteTokenBefore)(inputRef.current, cursorRef.current);
+                if (chip) {
+                    updateInput(chip.text, chip.pos);
+                }
+                else {
+                    const result = (0, input_keys_1.handleBackspace)(inputRef.current, cursorRef.current);
+                    updateInput(result.text, result.cursorPos);
+                }
+            }
+            historyIdx.current = -1;
+            return;
+        }
+        // Left/right arrow: move cursor (char by char, token-aware)
+        // NOTE: Ink 3.2 bug — key.meta is ALWAYS true for arrow keys because all
+        // arrows start with \x1b and Ink sets meta=true for any ESC-prefixed input.
+        // Word-jump is handled via Meta+B/F (emacs bindings) instead.
+        if (key.leftArrow) {
+            const chipStart = (0, image_ref_navigation_1.imageRefEndingAt)(inputRef.current, cursorRef.current);
+            cursorRef.current = chipStart !== undefined ? chipStart : Math.max(0, cursorRef.current - 1);
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        if (key.rightArrow) {
+            const chipEnd = (0, image_ref_navigation_1.imageRefStartingAt)(inputRef.current, cursorRef.current);
+            cursorRef.current = chipEnd !== undefined ? chipEnd : Math.min(inputRef.current.length, cursorRef.current + 1);
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        // Up/Down: queue pop takes priority over history
+        if (key.upArrow) {
+            // If not already browsing history and queue has items, pop queue into input
+            if (historyIdx.current === -1 && queuedInputs.length > 0) {
+                const items = onPopQueue();
+                updateInput(items.join("\n"));
+                return;
+            }
+            // Otherwise, browse history
+            if (history.length > 0) {
+                if (historyIdx.current === -1) {
+                    savedInput.current = inputRef.current;
+                    historyIdx.current = history.length - 1;
+                }
+                else if (historyIdx.current > 0) {
+                    historyIdx.current--;
+                }
+                updateInput(history[historyIdx.current]);
+            }
+            return;
+        }
+        if (key.downArrow) {
+            if (historyIdx.current >= 0) {
+                if (historyIdx.current < history.length - 1) {
+                    historyIdx.current++;
+                    updateInput(history[historyIdx.current]);
+                }
+                else {
+                    historyIdx.current = -1;
+                    updateInput(savedInput.current);
+                }
+            }
+            return;
+        }
+        // Meta+B / Meta+F: word movement (emacs — Option+Arrow on macOS sends these)
+        if (key.meta && inputChar === "b") {
+            const before = inputRef.current.slice(0, cursorRef.current);
+            const match = before.match(/(?:^|\s)\S+\s*$/);
+            cursorRef.current = match ? Math.max(0, cursorRef.current - match[0].length + (match[0][0] === " " ? 1 : 0)) : 0;
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        if (key.meta && inputChar === "f") {
+            const after = inputRef.current.slice(cursorRef.current);
+            const match = after.match(/^\s*\S+/);
+            cursorRef.current = match ? Math.min(inputRef.current.length, cursorRef.current + match[0].length) : inputRef.current.length;
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        // Meta+D: delete word forward
+        if (key.meta && inputChar === "d") {
+            const after = inputRef.current.slice(cursorRef.current);
+            const match = after.match(/^\s*\S+/);
+            if (match) {
+                const before = inputRef.current.slice(0, cursorRef.current);
+                const rest = after.slice(match[0].length);
+                updateInput(before + rest, cursorRef.current);
+            }
+            return;
+        }
+        // Ctrl+A / Ctrl+E: home / end
+        if (key.ctrl && inputChar === "a") {
+            cursorRef.current = 0;
+            setCursorPos(0);
+            return;
+        }
+        if (key.ctrl && inputChar === "e") {
+            cursorRef.current = inputRef.current.length;
+            setCursorPos(inputRef.current.length);
+            return;
+        }
+        // ─── Emacs Navigation ─────────────────────────────────────────
+        // Ctrl+B: cursor left
+        if (key.ctrl && inputChar === "b") {
+            cursorRef.current = (0, input_keys_1.handleCursorLeft)(inputRef.current, cursorRef.current);
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        // Ctrl+F: cursor right
+        if (key.ctrl && inputChar === "f") {
+            cursorRef.current = (0, input_keys_1.handleCursorRight)(inputRef.current, cursorRef.current);
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        // Ctrl+P: history up (same as up arrow)
+        if (key.ctrl && inputChar === "p") {
+            if (historyIdx.current === -1 && queuedInputs.length > 0) {
+                const items = onPopQueue();
+                updateInput(items.join("\n"));
+                return;
+            }
+            if (history.length > 0) {
+                if (historyIdx.current === -1) {
+                    savedInput.current = inputRef.current;
+                    historyIdx.current = history.length - 1;
+                }
+                else if (historyIdx.current > 0) {
+                    historyIdx.current--;
+                }
+                updateInput(history[historyIdx.current]);
+            }
+            return;
+        }
+        // Ctrl+N: history down (same as down arrow)
+        if (key.ctrl && inputChar === "n") {
+            if (historyIdx.current >= 0) {
+                if (historyIdx.current < history.length - 1) {
+                    historyIdx.current++;
+                    updateInput(history[historyIdx.current]);
+                }
+                else {
+                    historyIdx.current = -1;
+                    updateInput(savedInput.current);
+                }
+            }
+            return;
+        }
+        // Ctrl+H: token-aware backspace
+        if (key.ctrl && inputChar === "h") {
+            const chip = (0, image_ref_navigation_1.deleteTokenBefore)(inputRef.current, cursorRef.current);
+            if (chip) {
+                updateInput(chip.text, chip.pos);
+            }
+            else {
+                const result = (0, input_keys_1.handleBackspace)(inputRef.current, cursorRef.current);
+                updateInput(result.text, result.cursorPos);
+            }
+            historyIdx.current = -1;
+            return;
+        }
+        // Ctrl+D: forward-delete when input present, exit when empty
+        if (key.ctrl && inputChar === "d") {
+            if (inputRef.current.length === 0) {
+                handleCtrlC();
+            }
+            else {
+                const result = (0, input_keys_1.handleForwardDelete)(inputRef.current, cursorRef.current);
+                updateInput(result.text, result.cursorPos);
+            }
+            return;
+        }
+        // ─── Kill Ring Keybindings ─────────────────────────────────────
+        // Ctrl+K: kill from cursor to end of line
+        if (key.ctrl && inputChar === "k") {
+            const result = (0, input_keys_1.handleKillToEnd)(inputRef.current, cursorRef.current, killRing);
+            updateInput(result.text, result.cursorPos);
+            return;
+        }
+        // Ctrl+U: kill from start to cursor
+        if (key.ctrl && inputChar === "u") {
+            const result = (0, input_keys_1.handleKillToStart)(inputRef.current, cursorRef.current, killRing);
+            updateInput(result.text, result.cursorPos);
+            return;
+        }
+        // Ctrl+W: kill word before cursor (token-aware)
+        if (key.ctrl && inputChar === "w") {
+            const chip = (0, image_ref_navigation_1.deleteTokenBefore)(inputRef.current, cursorRef.current);
+            if (chip) {
+                updateInput(chip.text, chip.pos);
+            }
+            else {
+                const result = (0, input_keys_1.handleKillWordBack)(inputRef.current, cursorRef.current, killRing);
+                updateInput(result.text, result.cursorPos);
+            }
+            return;
+        }
+        // Ctrl+Y: yank from kill ring
+        if (key.ctrl && inputChar === "y") {
+            const result = (0, input_keys_1.handleYank)(inputRef.current, cursorRef.current, killRing);
+            if (result)
+                updateInput(result.text, result.cursorPos);
+            return;
+        }
+        // Alt+Y: yank-pop (cycle kill ring)
+        if (key.meta && inputChar === "y") {
+            const result = (0, input_keys_1.handleYankPop)(inputRef.current, cursorRef.current, killRing);
+            if (result)
+                updateInput(result.text, result.cursorPos);
+            return;
+        }
+        // Option+Backspace: Ink parses \x1b\x7f as meta=true, inputChar="" (empty because
+        // \x7f matches key.delete but the whole input was \x1b\x7f not \x7f).
+        // Signature: key.meta && !inputChar && !key.escape && !key.return
+        if (key.meta && !inputChar && !key.escape && !key.return && !key.tab) {
+            if (cursorRef.current > 0) {
+                const chip = (0, image_ref_navigation_1.deleteTokenBefore)(inputRef.current, cursorRef.current);
+                if (chip) {
+                    updateInput(chip.text, chip.pos);
+                }
+                else {
+                    const result = (0, input_keys_1.handleKillWordBack)(inputRef.current, cursorRef.current, killRing);
+                    updateInput(result.text, result.cursorPos);
+                }
+            }
+            historyIdx.current = -1;
+            return;
+        }
+        // ─── Non-kill/non-yank keystroke resets ────────────────────────
+        killRing.resetAccumulation();
+        killRing.resetYankState();
+        // Detect raw escape sequences — Ink 3.2 strips \x1b prefix and sets key.meta,
+        // so we re-prepend it for classification when meta is set and inputChar starts with [
+        const escInput = key.meta && inputChar.startsWith("[") ? "\x1b" + inputChar : inputChar;
+        const escClass = (0, input_keys_1.classifyEscapeSequence)(escInput);
+        if (escClass === "home") {
+            cursorRef.current = (0, input_keys_1.handleHome)(inputRef.current, cursorRef.current);
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        if (escClass === "end") {
+            cursorRef.current = (0, input_keys_1.handleEnd)(inputRef.current, cursorRef.current);
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        if (escClass === "word-left") {
+            const before = inputRef.current.slice(0, cursorRef.current);
+            const match = before.match(/(?:^|\s)\S+\s*$/);
+            cursorRef.current = match ? Math.max(0, cursorRef.current - match[0].length + (match[0].startsWith(" ") ? 1 : 0)) : 0;
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        if (escClass === "word-right") {
+            const after = inputRef.current.slice(cursorRef.current);
+            const match = after.match(/^\s*\S+/);
+            cursorRef.current = match ? Math.min(inputRef.current.length, cursorRef.current + match[0].length) : inputRef.current.length;
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        if (escClass === "ignore")
+            return;
+        // Regular character: insert at cursor position
+        if (!key.ctrl && !key.meta && inputChar) {
+            // Strip ANSI escape codes and normalize \r to \n (SSH/paste compat)
+            const cleaned = inputChar.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\r\n?/g, "\n");
+            if (!cleaned)
+                return;
+            const before = inputRef.current.slice(0, cursorRef.current);
+            const after = inputRef.current.slice(cursorRef.current);
+            updateInput(before + cleaned + after, cursorRef.current + cleaned.length);
+            historyIdx.current = -1;
+        }
+    });
+    const isMultiline = input.includes("\n");
+    const inputLines = input.split("\n");
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: "─".repeat(termWidth()) }), isMultiline ? ((0, jsx_runtime_1.jsx)(ink_1.Box, { flexDirection: "column", children: inputLines.map((line, i) => ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.teal, bold: true, children: i === 0 ? ") " : "· " }), (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.bone, children: line }), i === inputLines.length - 1 ? (cursorVisible ? (0, jsx_runtime_1.jsx)(ink_1.Text, { backgroundColor: OURO.scale, color: "#000000", children: " " }) : (0, jsx_runtime_1.jsx)(ink_1.Text, { children: " " })) : null] }, i))) })) : ((0, jsx_runtime_1.jsx)(ink_1.Box, { children: (0, jsx_runtime_1.jsx)(ink_1.Text, { wrap: "wrap", children: (() => {
+                        const prompt = `\x1b[1m\x1b[38;2;78;201;176m) \x1b[0m`;
+                        if (!input && queuedInputs.length > 0) {
+                            return `${prompt}\x1b[38;2;112;131;115mPress up to edit queued messages\x1b[0m`;
+                        }
+                        const beforeCursor = `\x1b[38;2;238;242;234m${input.slice(0, cursorPos)}\x1b[0m`;
+                        const cursorChar = input[cursorPos] ?? " ";
+                        const cursor = cursorVisible
+                            ? `\x1b[48;2;47;143;78m\x1b[38;2;0;0;0m${cursorChar}\x1b[0m`
+                            : `\x1b[38;2;238;242;234m${cursorChar}\x1b[0m`;
+                        const afterCursor = `\x1b[38;2;238;242;234m${input.slice(cursorPos + 1)}\x1b[0m`;
+                        return `${prompt}${beforeCursor}${cursor}${afterCursor}`;
+                    })() }) })), (0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: "─".repeat(termWidth()) }), (0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsxs)(ink_1.Text, { dimColor: true, children: ["  ", agentName, model ? ` · ${model}` : "", " \u00B7 /help"] }), (0, jsx_runtime_1.jsx)(ink_1.Box, { flexGrow: 1 }), tooltip ? (0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: tooltip }) : (0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: "opt+enter for newline" })] })] }));
+}
+// ─── Main TUI Component ─────────────────────────────────────────────
+function OuroTui({ agentName, model, completedMessages, inputHistory, queuedInputs, live, elapsedSeconds, contextPercent, onSubmit, onCtrlC, onPopQueue, cwd, resumeInfo, onImageMap, onHistoryAdd, }) {
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [(0, jsx_runtime_1.jsx)(ink_1.Static, { items: [{ id: "__header__" }, ...completedMessages], children: (item, index) => {
+                    if (index === 0) {
+                        return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", marginBottom: 2, children: [(0, jsx_runtime_1.jsx)(ink_1.Box, { marginTop: 1, children: (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }) }), (0, jsx_runtime_1.jsx)(Header, { agentName: agentName, model: model, contextPercent: contextPercent, cwd: cwd, resumeInfo: resumeInfo }), (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.shadow, dimColor: true, children: "  Ctrl-C twice to exit \u00b7 \u2191\u2193 history \u00b7 Esc clear \u00b7 opt+Enter newline" })] }, "header"));
+                    }
+                    return (0, jsx_runtime_1.jsx)(MessageBlock, { msg: item }, item.id);
+                } }), (live.loading || live.streamingText || live.activeTool) ? (0, jsx_runtime_1.jsx)(ink_1.Box, { marginTop: 1, children: (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }) }) : null, (0, jsx_runtime_1.jsx)(LiveArea, { live: live, elapsed: elapsedSeconds }), (live.loading || live.streamingText || live.activeTool) ? (0, jsx_runtime_1.jsx)(ink_1.Box, { marginBottom: 1, children: (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }) }) : null, queuedInputs.length > 0 ? (0, jsx_runtime_1.jsx)(QueuedMessages, { items: queuedInputs }) : null, (0, jsx_runtime_1.jsx)(ink_1.Box, { marginTop: 1, children: (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }) }), (0, jsx_runtime_1.jsx)(InputArea, { onSubmit: onSubmit, onCtrlC: onCtrlC, history: inputHistory, queuedInputs: queuedInputs, onPopQueue: onPopQueue, agentName: agentName, model: model, onImageMap: onImageMap, onHistoryAdd: onHistoryAdd })] }));
+}