@ouro.bot/cli 0.1.0-alpha.260 → 0.1.0-alpha.261

package/changelog.json

@@ -1,11 +1,17 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.261",
+      "changes": [
+        "feat(tui): full input parity with Claude Code \u2014 kill ring, emacs nav, Home/End, Ctrl+D, forward delete, Esc history, bracketed paste, clipboard image, token deletion, chip navigation. 156 new tests."
+      ]
+    },
     {
       "version": "0.1.0-alpha.260",
       "changes": [
-        "fix(daemon): MCP bridge empty-response bug for long-running commands. `sendDaemonCommand` and `checkDaemonSocketAlive` were calling `client.end()` immediately after writing, which half-closed the TCP connection. The daemon server's `net.createServer()` uses the default `allowHalfOpen: false`, so when it saw the client's FIN it auto-closed its own writable side — and any response the server tried to write after processing a long-running command (like `agent.senseTurn`, which runs a full LLM turn) was dropped on the floor. Verified via direct socket repro: with `client.end()`, `agent.senseTurn` returned empty in ~149ms; without it, the same call returned a real response in ~5.8s. This was a silent regression of the fix in #303 (commit `253e4b1f` titled \"socket half-close fix\" actually *added* the half-close back). Fix: drop the `client.end()` calls from both sites AND set `allowHalfOpen: true` on the daemon's `net.createServer(...)` as defense-in-depth so future clients calling `end()` don't silently break again.",
-        "fix(daemon): tighten pidfile trust — `killOrphanProcesses` now verifies each pidfile PID is an actual orphan (PPID reparented to init/PID 1) before SIGTERMing it. Previously a polluted pidfile (written by a crashed daemon whose PIDs have since been reused by the OS for unrelated processes) could cause mass-kill of unrelated apps. New exported helper `filterPidfilePidsToActualOrphans` provides direct unit coverage.",
+        "fix(daemon): MCP bridge empty-response bug for long-running commands. `sendDaemonCommand` and `checkDaemonSocketAlive` were calling `client.end()` immediately after writing, which half-closed the TCP connection. The daemon server's `net.createServer()` uses the default `allowHalfOpen: false`, so when it saw the client's FIN it auto-closed its own writable side \u2014 and any response the server tried to write after processing a long-running command (like `agent.senseTurn`, which runs a full LLM turn) was dropped on the floor. Verified via direct socket repro: with `client.end()`, `agent.senseTurn` returned empty in ~149ms; without it, the same call returned a real response in ~5.8s. This was a silent regression of the fix in #303 (commit `253e4b1f` titled \"socket half-close fix\" actually *added* the half-close back). Fix: drop the `client.end()` calls from both sites AND set `allowHalfOpen: true` on the daemon's `net.createServer(...)` as defense-in-depth so future clients calling `end()` don't silently break again.",
+        "fix(daemon): tighten pidfile trust \u2014 `killOrphanProcesses` now verifies each pidfile PID is an actual orphan (PPID reparented to init/PID 1) before SIGTERMing it. Previously a polluted pidfile (written by a crashed daemon whose PIDs have since been reused by the OS for unrelated processes) could cause mass-kill of unrelated apps. New exported helper `filterPidfilePidsToActualOrphans` provides direct unit coverage.",
         "fix(daemon, repertoire): rename six `_stop` nerves events to `_end` so they pair correctly with their `_start` counterparts under the nerves audit's start/end pairing rule. Affected: `daemon.thoughts_follow_stop`, `daemon.server_stop`, `daemon.update_checker_stop`, `daemon.mcp_server_stop`, `daemon.habit_scheduler_stop`, `mcp.manager_stop`. The naming was semantically fine (`stop` pairs with `start`), but the audit specifically looks for `_end`/`_error` suffixes. Was producing intermittent audit failures whenever any test run exercised these teardown paths (seen today as flakes on `daemon-socket-errors.test.ts` and `MarkdownStreamer` tests).",
         "fix(providers): drop the harness-imposed MiniMax VLM timeout entirely. Previously the module defaulted to a 60-second AbortSignal; E2E validation of the BB image fix hit a real VLM request that took >60s to return (same bytes returned in 9.5s on the immediate retry). Raising to 120s would have been arbitrary too \u2014 the correct answer, per the same reasoning as PR #322 for LLM providers, is to not impose a harness ceiling at all. When `timeoutMs` isn't provided, `fetch()` now runs without an AbortSignal and undici's own defaults (headersTimeout + bodyTimeout, both 5 minutes) are the ceiling. Callers that want a tighter bound can still pass an explicit `timeoutMs`. The AbortError path is kept for that case, and the error message adapts to say \"underlying stack default\" when there was no harness-set value."
       ]

package/dist/senses/cli/bracketed-paste.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BracketedPasteHandler = void 0;
+/**
+ * Bracketed paste mode handler for the TUI.
+ *
+ * Detects \x1b[200~ (paste start) and \x1b[201~ (paste end) markers in
+ * raw stdin data. Buffers paste content between markers and emits it as
+ * a single "paste" event. Non-paste data is emitted as "data" unchanged.
+ *
+ * Works alongside Ink's stdin handling by intercepting raw data events.
+ */
+const events_1 = require("events");
+const runtime_1 = require("../../nerves/runtime");
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+class BracketedPasteHandler extends events_1.EventEmitter {
+    stdin;
+    stdout;
+    pasting = false;
+    buffer = "";
+    dataHandler;
+    constructor(stdin, stdout) {
+        super();
+        this.stdin = stdin;
+        this.stdout = stdout;
+        // Enable bracketed paste mode
+        stdout.write("\x1b[?2004h");
+        this.dataHandler = (chunk) => {
+            this.processChunk(chunk.toString());
+        };
+        stdin.prependListener("data", this.dataHandler);
+    }
+    processChunk(data) {
+        let remaining = data;
+        while (remaining.length > 0) {
+            if (this.pasting) {
+                // Look for end marker in buffer + remaining
+                const combined = this.buffer + remaining;
+                const endIdx = combined.indexOf(PASTE_END);
+                if (endIdx !== -1) {
+                    // Found end marker -- emit paste content
+                    const pasteContent = combined.slice(0, endIdx);
+                    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.bracketed_paste", message: "bracketed paste received", meta: { length: pasteContent.length } });
+                    this.emit("paste", pasteContent);
+                    this.buffer = "";
+                    this.pasting = false;
+                    // Process remaining data after end marker
+                    remaining = combined.slice(endIdx + PASTE_END.length);
+                    continue;
+                }
+                // No end marker yet -- buffer everything so far
+                this.buffer = combined;
+                return;
+            }
+            // Not pasting -- look for start marker
+            const startIdx = remaining.indexOf(PASTE_START);
+            if (startIdx !== -1) {
+                // Emit any data before the start marker
+                const before = remaining.slice(0, startIdx);
+                if (before.length > 0) {
+                    this.emit("data", before);
+                }
+                // Enter paste mode
+                this.pasting = true;
+                this.buffer = "";
+                remaining = remaining.slice(startIdx + PASTE_START.length);
+                continue;
+            }
+            // No start marker -- emit as regular data
+            this.emit("data", remaining);
+            return;
+        }
+    }
+    /** Disable bracketed paste mode and remove listeners. */
+    destroy() {
+        this.stdout.write("\x1b[?2004l");
+        this.stdin.removeListener("data", this.dataHandler);
+        this.removeAllListeners();
+    }
+}
+exports.BracketedPasteHandler = BracketedPasteHandler;

package/dist/senses/cli/image-ref-navigation.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imageRefEndingAt = imageRefEndingAt;
+exports.imageRefStartingAt = imageRefStartingAt;
+exports.deleteTokenBefore = deleteTokenBefore;
+exports.deleteTokenAfter = deleteTokenAfter;
+/**
+ * Token-aware navigation and deletion for [Image #N] references.
+ *
+ * Image refs are treated as atomic "chips" — arrow keys hop over them,
+ * backspace/delete removes them atomically, and word-kill treats them
+ * as single words.
+ */
+const runtime_1 = require("../../nerves/runtime");
+const IMAGE_REF_PATTERN = /\[Image #\d+\]/g;
+/**
+ * If an [Image #N] ref ends exactly at the given position, return its start index.
+ * Otherwise return undefined.
+ */
+function imageRefEndingAt(text, pos) {
+    // Search backward from pos for a potential image ref
+    // Max length of [Image #NNN] is ~14 chars, search a window
+    const windowStart = Math.max(0, pos - 20);
+    const window = text.slice(windowStart, pos);
+    IMAGE_REF_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = IMAGE_REF_PATTERN.exec(window)) !== null) {
+        const matchEnd = windowStart + match.index + match[0].length;
+        if (matchEnd === pos) {
+            return windowStart + match.index;
+        }
+    }
+    return undefined;
+}
+/**
+ * If an [Image #N] ref starts exactly at the given position, return its end index.
+ * Otherwise return undefined.
+ */
+function imageRefStartingAt(text, pos) {
+    if (pos >= text.length)
+        return undefined;
+    // Check if text at pos matches an image ref
+    const window = text.slice(pos, pos + 20);
+    IMAGE_REF_PATTERN.lastIndex = 0;
+    const match = IMAGE_REF_PATTERN.exec(window);
+    if (match && match.index === 0) {
+        return pos + match[0].length;
+    }
+    return undefined;
+}
+/**
+ * If cursor is right after an [Image #N], remove the entire ref.
+ * Returns { text, pos } with the ref removed, or null if no ref found.
+ */
+function deleteTokenBefore(text, pos) {
+    const start = imageRefEndingAt(text, pos);
+    if (start === undefined)
+        return null;
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.image_ref_delete", message: "deleted image ref token", meta: { pos } });
+    const before = text.slice(0, start);
+    const after = text.slice(pos);
+    return { text: before + after, pos: start };
+}
+/**
+ * If cursor is right before an [Image #N], remove the entire ref.
+ * Returns { text, pos } with the ref removed, or null if no ref found.
+ */
+function deleteTokenAfter(text, pos) {
+    const end = imageRefStartingAt(text, pos);
+    if (end === undefined)
+        return null;
+    const before = text.slice(0, pos);
+    const after = text.slice(end);
+    return { text: before + after, pos };
+}

package/dist/senses/cli/input-keys.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleKillToEnd = handleKillToEnd;
+exports.handleKillToStart = handleKillToStart;
+exports.handleKillWordBack = handleKillWordBack;
+exports.handleYank = handleYank;
+exports.handleCursorLeft = handleCursorLeft;
+exports.handleCursorRight = handleCursorRight;
+exports.handleBackspace = handleBackspace;
+exports.handleForwardDelete = handleForwardDelete;
+exports.handleHome = handleHome;
+exports.handleEnd = handleEnd;
+exports.classifyEscapeSequence = classifyEscapeSequence;
+exports.handleYankPop = handleYankPop;
+exports.handleEmptyPaste = handleEmptyPaste;
+const runtime_1 = require("../../nerves/runtime");
+/**
+ * Ctrl+K: kill from cursor to end of line.
+ * Pushes killed text to ring with "append" direction.
+ */
+function handleKillToEnd(text, cursorPos, ring) {
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.input_kill", message: "kill to end", meta: { direction: "end" } });
+    if (cursorPos >= text.length) {
+        return { text, cursorPos };
+    }
+    const killed = text.slice(cursorPos);
+    ring.push(killed, "append");
+    return { text: text.slice(0, cursorPos), cursorPos };
+}
+/**
+ * Ctrl+U: kill from start of line to cursor.
+ * Pushes killed text to ring with "prepend" direction.
+ */
+function handleKillToStart(text, cursorPos, ring) {
+    if (cursorPos === 0) {
+        return { text, cursorPos };
+    }
+    const killed = text.slice(0, cursorPos);
+    ring.push(killed, "prepend");
+    return { text: text.slice(cursorPos), cursorPos: 0 };
+}
+/**
+ * Ctrl+W / Meta+Backspace: kill word before cursor.
+ * Pushes killed word to ring with "prepend" direction.
+ */
+function handleKillWordBack(text, cursorPos, ring) {
+    if (cursorPos === 0) {
+        return { text, cursorPos };
+    }
+    const before = text.slice(0, cursorPos);
+    const after = text.slice(cursorPos);
+    const wordStart = before.replace(/\s*\S+\s*$/, "");
+    const killed = before.slice(wordStart.length);
+    ring.push(killed, "prepend");
+    return { text: wordStart + after, cursorPos: wordStart.length };
+}
+/**
+ * Ctrl+Y: yank (paste) from kill ring at cursor.
+ * Returns null if ring is empty.
+ */
+function handleYank(text, cursorPos, ring) {
+    const yanked = ring.yank();
+    if (yanked === undefined)
+        return null;
+    const before = text.slice(0, cursorPos);
+    const after = text.slice(cursorPos);
+    return { text: before + yanked + after, cursorPos: cursorPos + yanked.length };
+}
+// ─── Emacs Cursor Navigation ─────────────────────────────────────
+/** Ctrl+B: move cursor left by 1. Returns new cursor position. */
+function handleCursorLeft(_text, cursorPos) {
+    return Math.max(0, cursorPos - 1);
+}
+/** Ctrl+F: move cursor right by 1. Returns new cursor position. */
+function handleCursorRight(text, cursorPos) {
+    return Math.min(text.length, cursorPos + 1);
+}
+/** Ctrl+H: backspace (delete char before cursor). */
+function handleBackspace(text, cursorPos) {
+    if (cursorPos === 0)
+        return { text, cursorPos };
+    const before = text.slice(0, cursorPos - 1);
+    const after = text.slice(cursorPos);
+    return { text: before + after, cursorPos: cursorPos - 1 };
+}
+/** Forward delete: delete char at cursor position. */
+function handleForwardDelete(text, cursorPos) {
+    if (cursorPos >= text.length)
+        return { text, cursorPos };
+    const before = text.slice(0, cursorPos);
+    const after = text.slice(cursorPos + 1);
+    return { text: before + after, cursorPos };
+}
+// ─── Home / End ──────────────────────────────────────────────────
+/** Home key: move cursor to position 0. Returns new cursor position. */
+function handleHome(_text, _cursorPos) {
+    return 0;
+}
+/** End key: move cursor to end of text. Returns new cursor position. */
+function handleEnd(text, _cursorPos) {
+    return text.length;
+}
+// ─── Escape Sequence Classification ──────────────────────────────
+/**
+ * Classify raw escape sequences that Ink passes through as regular characters.
+ * Returns:
+ *   "home"   — Home key sequences
+ *   "end"    — End key sequences
+ *   "ignore" — PageUp, PageDown, mouse wheel (should be suppressed)
+ *   null     — not a recognized escape sequence
+ */
+function classifyEscapeSequence(inputChar) {
+    if (!inputChar.startsWith("\x1b["))
+        return null;
+    const seq = inputChar.slice(2); // after \x1b[
+    // Home: \x1b[H or \x1b[1~
+    if (seq === "H" || seq === "1~")
+        return "home";
+    // End: \x1b[F or \x1b[4~
+    if (seq === "F" || seq === "4~")
+        return "end";
+    // PageUp: \x1b[5~, PageDown: \x1b[6~
+    if (seq === "5~" || seq === "6~")
+        return "ignore";
+    // SGR mouse wheel: \x1b[<64;... or \x1b[<65;...
+    if (seq.startsWith("<64;") || seq.startsWith("<65;"))
+        return "ignore";
+    return null;
+}
+/**
+ * Alt+Y: yank-pop -- replace previously yanked text with next ring entry.
+ * Returns null if not in yanking state or ring is empty.
+ */
+function handleYankPop(text, cursorPos, ring) {
+    const lastYanked = ring.lastYankedText;
+    if (!ring.isYanking || lastYanked === undefined)
+        return null;
+    const popped = ring.yankPop();
+    if (popped === undefined)
+        return null;
+    // Find where the last yanked text ends (at current cursor position)
+    // and starts (cursorPos - lastYanked.length)
+    const yankStart = cursorPos - lastYanked.length;
+    const before = text.slice(0, yankStart);
+    const after = text.slice(cursorPos);
+    return { text: before + popped + after, cursorPos: yankStart + popped.length };
+}
+/**
+ * Handle an empty paste event by checking clipboard for images (macOS only).
+ * Returns null if no image found, not on macOS, or clipboard empty.
+ */
+async function handleEmptyPaste(text, cursorPos, currentImageCount, platform, clipboardReader) {
+    if (platform !== "darwin")
+        return null;
+    const imageData = await clipboardReader();
+    if (!imageData)
+        return null;
+    const refNum = currentImageCount + 1;
+    const ref = `[Image #${refNum}]`;
+    const before = text.slice(0, cursorPos);
+    const after = text.slice(cursorPos);
+    return {
+        text: before + ref + after,
+        cursorPos: cursorPos + ref.length,
+        imageRef: refNum,
+        imageData,
+    };
+}

package/dist/senses/cli/kill-ring.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KillRing = void 0;
+/**
+ * Kill ring — emacs-style cut buffer with accumulation and yank-pop cycling.
+ *
+ * Stores up to MAX_SIZE killed text entries. Consecutive kills in the same
+ * direction accumulate into a single entry. Yank retrieves the most recent
+ * entry; yank-pop cycles backward through the ring.
+ */
+const runtime_1 = require("../../nerves/runtime");
+const MAX_SIZE = 10;
+class KillRing {
+    entries = [];
+    accumulating = false;
+    yankIndex = -1;
+    _isYanking = false;
+    _lastYankedText = undefined;
+    /** Whether the ring is currently in yank-cycling mode. */
+    get isYanking() {
+        return this._isYanking;
+    }
+    /** The text that was last returned by yank() or yankPop(). */
+    get lastYankedText() {
+        return this._lastYankedText;
+    }
+    /**
+     * Push killed text onto the ring.
+     *
+     * If accumulating (consecutive kills without a reset), the text is merged
+     * with the top entry: "append" concatenates to the end, "prepend" prepends
+     * to the start. Otherwise a new entry is created, evicting the oldest if
+     * the ring is full.
+     */
+    push(text, direction) {
+        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.kill_ring_push", message: "killed text to ring", meta: { direction, length: text.length } });
+        if (this.accumulating && this.entries.length > 0) {
+            const top = this.entries[this.entries.length - 1];
+            this.entries[this.entries.length - 1] =
+                direction === "append" ? top + text : text + top;
+        }
+        else {
+            if (this.entries.length >= MAX_SIZE) {
+                this.entries.shift();
+            }
+            this.entries.push(text);
+        }
+        this.accumulating = true;
+    }
+    /**
+     * Return the most recent kill ring entry and enter yanking mode.
+     * Returns undefined if the ring is empty.
+     */
+    yank() {
+        if (this.entries.length === 0)
+            return undefined;
+        this.yankIndex = this.entries.length - 1;
+        this._isYanking = true;
+        this._lastYankedText = this.entries[this.yankIndex];
+        return this._lastYankedText;
+    }
+    /**
+     * Cycle to the next older entry in the ring (wrapping around).
+     * Must be called after yank(). Returns undefined if ring is empty
+     * or not in yanking state.
+     */
+    yankPop() {
+        if (!this._isYanking || this.entries.length === 0)
+            return undefined;
+        this.yankIndex =
+            (this.yankIndex - 1 + this.entries.length) % this.entries.length;
+        this._lastYankedText = this.entries[this.yankIndex];
+        return this._lastYankedText;
+    }
+    /** Stop consecutive-kill accumulation (called on non-kill keystrokes). */
+    resetAccumulation() {
+        this.accumulating = false;
+    }
+    /** Exit yank-cycling mode (called on non-yank keystrokes). */
+    resetYankState() {
+        this._isYanking = false;
+        this._lastYankedText = undefined;
+        this.yankIndex = -1;
+    }
+}
+exports.KillRing = KillRing;

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

@@ -18,6 +18,9 @@ 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/outlook-ui/src/style.css and ouroboros.bot
 const OURO = {
@@ -153,8 +156,10 @@ function QueuedMessages({ items }) {
         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 }) {
+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)("");
@@ -219,6 +224,9 @@ function InputArea({ onSubmit, onCtrlC, history, queuedInputs, onPopQueue, agent
             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");
@@ -242,6 +250,9 @@ function InputArea({ onSubmit, onCtrlC, history, queuedInputs, onPopQueue, agent
             clearTimeout(escTimerRef.current);
             escTimerRef.current = null;
         }
+        // PageUp/PageDown: suppress (no text insertion, no action)
+        if (key.pageUp || key.pageDown)
+            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;
@@ -271,19 +282,43 @@ function InputArea({ onSubmit, onCtrlC, history, queuedInputs, onPopQueue, agent
             historyIdx.current = -1;
             return;
         }
-        if (key.backspace || key.delete) {
+        // Forward delete key (fn+Backspace on macOS): delete character at cursor
+        if (key.delete && !key.backspace) {
+            if (key.meta) {
+                // Meta+Delete: kill to end of line (push to ring)
+                const result = (0, input_keys_1.handleKillToEnd)(inputRef.current, cursorRef.current, killRing);
+                updateInput(result.text, result.cursorPos);
+            }
+            else {
+                // Token-aware: check for image ref chip at cursor
+                const chip = (0, image_ref_navigation_1.deleteTokenAfter)(inputRef.current, cursorRef.current);
+                if (chip) {
+                    updateInput(chip.text, chip.pos);
+                }
+                else {
+                    const result = (0, input_keys_1.handleForwardDelete)(inputRef.current, cursorRef.current);
+                    updateInput(result.text, result.cursorPos);
+                }
+            }
+            historyIdx.current = -1;
+            return;
+        }
+        // Backspace: delete character before cursor
+        if (key.backspace) {
             if (cursorRef.current > 0) {
-                // Option+Backspace: delete word
-                if (key.meta) {
-                    const before = inputRef.current.slice(0, cursorRef.current);
-                    const after = inputRef.current.slice(cursorRef.current);
-                    const wordStart = before.replace(/\s*\S+\s*$/, "");
-                    updateInput(wordStart + after, wordStart.length);
+                // Token-aware: check for image ref chip before cursor
+                const chip = (0, image_ref_navigation_1.deleteTokenBefore)(inputRef.current, cursorRef.current);
+                if (chip) {
+                    updateInput(chip.text, chip.pos);
+                }
+                else if (key.meta) {
+                    // Option+Backspace: delete word (also pushes to kill ring)
+                    const result = (0, input_keys_1.handleKillWordBack)(inputRef.current, cursorRef.current, killRing);
+                    updateInput(result.text, result.cursorPos);
                 }
                 else {
-                    const before = inputRef.current.slice(0, cursorRef.current - 1);
-                    const after = inputRef.current.slice(cursorRef.current);
-                    updateInput(before + after, cursorRef.current - 1);
+                    const result = (0, input_keys_1.handleBackspace)(inputRef.current, cursorRef.current);
+                    updateInput(result.text, result.cursorPos);
                 }
             }
             historyIdx.current = -1;
@@ -300,7 +335,9 @@ function InputArea({ onSubmit, onCtrlC, history, queuedInputs, onPopQueue, agent
                 setCursorPos(cursorRef.current);
             }
             else {
-                cursorRef.current = Math.max(0, cursorRef.current - 1);
+                // Token-aware: hop over image ref chips
+                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;
@@ -315,7 +352,9 @@ function InputArea({ onSubmit, onCtrlC, history, queuedInputs, onPopQueue, agent
                 setCursorPos(cursorRef.current);
             }
             else {
-                cursorRef.current = Math.min(inputRef.current.length, cursorRef.current + 1);
+                // Token-aware: hop over image ref chips
+                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;
@@ -391,8 +430,134 @@ function InputArea({ onSubmit, onCtrlC, history, queuedInputs, onPopQueue, agent
             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;
+        }
+        // ─── Non-kill/non-yank keystroke resets ────────────────────────
+        killRing.resetAccumulation();
+        killRing.resetYankState();
         // Regular character: insert at cursor position
         if (!key.ctrl && !key.meta && inputChar) {
+            // Detect raw escape sequences before inserting text
+            const escClass = (0, input_keys_1.classifyEscapeSequence)(inputChar);
+            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 === "ignore")
+                return; // PageUp/PageDown/mouse wheel fallback
             const before = inputRef.current.slice(0, cursorRef.current);
             const after = inputRef.current.slice(cursorRef.current);
             updateInput(before + inputChar + after, cursorRef.current + 1);
@@ -406,11 +571,11 @@ function InputArea({ onSubmit, onCtrlC, history, queuedInputs, onPopQueue, agent
                                 : (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.bone, children: input[cursorPos] ?? " " }), (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO.bone, children: input.slice(cursorPos + 1) })] }))] })), (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, }) {
+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 })] }));
+                } }), (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 })] }));
 }

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

@@ -169,6 +169,10 @@ class TuiStore {
         this._inputHistory.push(text);
         this.notify();
     }
+    /** Add text to input history only (no completed message, no notify). Used by ESC-to-clear. */
+    addToHistoryOnly(text) {
+        this._inputHistory.push(text);
+    }
     /** Seed input history from previous session messages (display only, no rendering) */
     seedHistory(texts) {
         this._inputHistory.push(...texts);

package/dist/senses/cli.js

@@ -618,6 +618,7 @@ async function runCliSession(options) {
                     cwd: process.cwd().replace(process.env.HOME ?? "", "~"),
                     resumeInfo,
                     onImageMap: (images) => { pendingImages = images; },
+                    onHistoryAdd: (text) => { storeRef.addToHistoryOnly(text); },
                 });
             }
             inkRef = ink.render(React.createElement(TuiRoot), { exitOnCtrlC: false, patchConsole: false });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.260",
+  "version": "0.1.0-alpha.261",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",