@ouro.bot/cli 0.1.0-alpha.67 → 0.1.0-alpha.671

package/dist/senses/cli.js

@@ -33,9 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MarkdownStreamer = exports.InputController = exports.Spinner = exports.wrapCliText = exports.formatEchoedInputSummary = void 0;
+exports.InputQueue = exports.MarkdownStreamer = exports.InputController = exports.Spinner = exports.StreamingWordWrapper = exports.wrapCliText = exports.formatEchoedInputSummary = void 0;
 exports.formatPendingPrefix = formatPendingPrefix;
 exports.getCliContinuityIngressTexts = getCliContinuityIngressTexts;
+exports.formatTimeAgo = formatTimeAgo;
+exports.writeCliAsyncAssistantMessage = writeCliAsyncAssistantMessage;
+exports.pauseActiveSpinner = pauseActiveSpinner;
+exports.resumeActiveSpinner = resumeActiveSpinner;
+exports.setActiveSpinner = setActiveSpinner;
 exports.handleSigint = handleSigint;
 exports.addHistory = addHistory;
 exports.renderMarkdown = renderMarkdown;
@@ -51,27 +56,31 @@ const prompt_1 = require("../mind/prompt");
 const phrases_1 = require("../mind/phrases");
 const format_1 = require("../mind/format");
 const config_1 = require("../heart/config");
+const session_events_1 = require("../heart/session-events");
 const context_1 = require("../mind/context");
 const pending_1 = require("../mind/pending");
 const commands_1 = require("./commands");
 const identity_1 = require("../heart/identity");
+const mcp_manager_1 = require("../repertoire/mcp-manager");
 const nerves_1 = require("../nerves");
-const store_file_1 = require("../mind/friends/store-file");
-const resolver_1 = require("../mind/friends/resolver");
-const tokens_1 = require("../mind/friends/tokens");
+const friends_1 = require("@ouro.bot/friends");
 const cli_logging_1 = require("../nerves/cli-logging");
 const runtime_1 = require("../nerves/runtime");
 const trust_gate_1 = require("./trust-gate");
 const pipeline_1 = require("./pipeline");
-const channel_1 = require("../mind/friends/channel");
 const session_lock_1 = require("./session-lock");
-const update_hooks_1 = require("../heart/daemon/update-hooks");
+const update_hooks_1 = require("../heart/versioning/update-hooks");
 const bundle_meta_1 = require("../heart/daemon/hooks/bundle-meta");
+const agent_config_v2_1 = require("../heart/daemon/hooks/agent-config-v2");
 const bundle_manifest_1 = require("../mind/bundle-manifest");
 const cli_layout_1 = require("./cli-layout");
+const image_paste_1 = require("./cli/image-paste");
+const spinner_imperative_1 = require("./cli/spinner-imperative");
+const tool_display_1 = require("./cli/tool-display");
 var cli_layout_2 = require("./cli-layout");
 Object.defineProperty(exports, "formatEchoedInputSummary", { enumerable: true, get: function () { return cli_layout_2.formatEchoedInputSummary; } });
 Object.defineProperty(exports, "wrapCliText", { enumerable: true, get: function () { return cli_layout_2.wrapCliText; } });
+Object.defineProperty(exports, "StreamingWordWrapper", { enumerable: true, get: function () { return cli_layout_2.StreamingWordWrapper; } });
 /**
  * Format pending messages as content-prefix strings for injection into
  * the next user message. Self-messages (from === agentName) become
@@ -89,68 +98,46 @@ function getCliContinuityIngressTexts(input) {
     const trimmed = input.trim();
     return trimmed ? [trimmed] : [];
 }
-// spinner that only touches stderr, cleans up after itself
-// exported for direct testability (stop-without-start branch)
-class Spinner {
-    frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-    i = 0;
-    iv = null;
-    piv = null;
-    msg = "";
-    phrases = null;
-    lastPhrase = "";
-    stopped = false;
-    constructor(m = "working", phrases) {
-        this.msg = m;
-        if (phrases && phrases.length > 0)
-            this.phrases = phrases;
-    }
-    start() {
-        this.stopped = false;
-        process.stderr.write("\r\x1b[K");
-        this.spin();
-        this.iv = setInterval(() => this.spin(), 80);
-        if (this.phrases) {
-            this.piv = setInterval(() => this.rotatePhrase(), 1500);
-        }
-    }
-    spin() {
-        // Guard: clearInterval can't prevent already-dequeued callbacks
-        /* v8 ignore next -- race guard: timer callback fires after stop() @preserve */
-        if (this.stopped)
-            return;
-        process.stderr.write(`\r\x1b[K${this.frames[this.i]} ${this.msg}... `);
-        this.i = (this.i + 1) % this.frames.length;
-    }
-    rotatePhrase() {
-        /* v8 ignore next -- race guard: timer callback fires after stop() @preserve */
-        if (this.stopped)
-            return;
-        const next = (0, phrases_1.pickPhrase)(this.phrases, this.lastPhrase);
-        this.lastPhrase = next;
-        this.msg = next;
-    }
-    stop(ok) {
-        this.stopped = true;
-        if (this.iv) {
-            clearInterval(this.iv);
-            this.iv = null;
-        }
-        if (this.piv) {
-            clearInterval(this.piv);
-            this.piv = null;
-        }
-        process.stderr.write("\r\x1b[K");
-        /* v8 ignore next -- ok parameter currently unused by callers @preserve */
-        if (ok)
-            process.stderr.write(`\x1b[32m\u2713\x1b[0m ${ok}\n`);
-    }
-    fail(msg) {
-        this.stop();
-        process.stderr.write(`\x1b[31m\u2717\x1b[0m ${msg}\n`);
+/* v8 ignore start -- cosmetic time formatting @preserve */
+function formatTimeAgo(date) {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return "just now";
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+const CLI_PROMPT = "\x1b[36m) \x1b[0m";
+function writeCliAsyncAssistantMessage(rl, message, stdout = process.stdout) {
+    const rlInt = rl;
+    const currentLine = rlInt.line ?? "";
+    const currentCursor = rlInt.cursor ?? currentLine.length;
+    stdout.write("\r\x1b[K");
+    stdout.write(`${renderMarkdown(message)}\n`);
+    stdout.write(CLI_PROMPT);
+    if (!currentLine)
+        return;
+    stdout.write(currentLine);
+    if (currentCursor < currentLine.length) {
+        readline.cursorTo(process.stdout, 2 + currentCursor);
     }
 }
-exports.Spinner = Spinner;
+// Module-level active spinner for log coordination.
+// The terminal log sink calls these to avoid interleaving with spinner output.
+let _activeSpinner = null;
+/* v8 ignore start -- spinner coordination: exercised at runtime, not unit-testable without real terminal @preserve */
+function pauseActiveSpinner() { _activeSpinner?.pause(); }
+function resumeActiveSpinner() { _activeSpinner?.resume(); }
+/* v8 ignore stop */
+function setActiveSpinner(s) { _activeSpinner = s; }
+// Re-export ImperativeSpinner as Spinner for backward compatibility
+var spinner_imperative_2 = require("./cli/spinner-imperative");
+Object.defineProperty(exports, "Spinner", { enumerable: true, get: function () { return spinner_imperative_2.ImperativeSpinner; } });
 // Input controller: pauses readline during model/tool execution.
 // Does NOT touch raw mode — readline with terminal:true manages raw mode
 // internally. Touching it causes ^C to be echoed by the terminal driver.
@@ -318,60 +305,65 @@ function createCliCallbacks() {
         meta: {},
     });
     let currentSpinner = null;
-    let hadReasoning = false;
+    function setSpinner(s) { currentSpinner = s; setActiveSpinner(s); }
     let hadToolRun = false;
     let textDirty = false; // true when text/reasoning was written without a trailing newline
     const streamer = new MarkdownStreamer();
+    const wrapper = new cli_layout_1.StreamingWordWrapper();
     return {
         onModelStart: () => {
             currentSpinner?.stop();
-            currentSpinner = null;
-            hadReasoning = false;
+            setSpinner(null);
             textDirty = false;
             streamer.reset();
+            wrapper.reset();
             const phrases = (0, phrases_1.getPhrases)();
             const pool = hadToolRun ? phrases.followup : phrases.thinking;
             const first = (0, phrases_1.pickPhrase)(pool);
-            currentSpinner = new Spinner(first, pool);
+            setSpinner(new spinner_imperative_1.ImperativeSpinner(first, pool));
             currentSpinner.start();
         },
         onModelStreamStart: () => {
             // No-op: content callbacks (onTextChunk, onReasoningChunk) handle
             // stopping the spinner. onModelStreamStart fires too early and
-            // doesn't fire at all for final_answer tool streaming.
+            // doesn't fire at all for settle tool streaming.
         },
         onClearText: () => {
             streamer.reset();
+            wrapper.reset();
         },
         onTextChunk: (text) => {
-            // Stop spinner if still running — final_answer streaming and Anthropic
+            // Stop spinner if still running — settle streaming and Anthropic
             // tool-only responses bypass onModelStreamStart, so the spinner would
             // otherwise keep running (and its \r writes overwrite response text).
             if (currentSpinner) {
                 currentSpinner.stop();
-                currentSpinner = null;
-            }
-            if (hadReasoning) {
-                // Single newline to separate reasoning from reply — reasoning
-                // output often ends with its own trailing newline(s)
-                process.stdout.write("\n");
-                hadReasoning = false;
+                setSpinner(null);
             }
             const rendered = streamer.push(text);
-            if (rendered)
-                process.stdout.write(rendered);
-            textDirty = text.length > 0 && !text.endsWith("\n");
-        },
-        onReasoningChunk: (text) => {
-            if (currentSpinner) {
-                currentSpinner.stop();
-                currentSpinner = null;
+            /* v8 ignore start -- wrapper integration: tested via cli.test.ts onTextChunk tests @preserve */
+            if (rendered) {
+                const wrapped = wrapper.push(rendered);
+                if (wrapped)
+                    process.stdout.write(wrapped);
             }
-            hadReasoning = true;
-            process.stdout.write(`\x1b[2m${text}\x1b[0m`);
+            /* v8 ignore stop */
             textDirty = text.length > 0 && !text.endsWith("\n");
         },
+        flushNow: () => {
+            // CLI flushes immediately on each onTextChunk; nothing buffered to push.
+        },
+        onReasoningChunk: (_text) => {
+            // Keep reasoning private in the CLI surface. The spinner continues to
+            // represent active thinking until actual tool or answer output arrives.
+        },
         onToolStart: (_name, _args) => {
+            // speak is flow-control: its visible output is the message itself (delivered
+            // via onTextChunk/flushNow). Do NOT start a tool spinner — that would write
+            // a "running speak..." phrase to stderr right before the actual message
+            // arrives, which is the visual churn the user explicitly does not want.
+            if (_name === "speak")
+                return;
             // Stop the model-start spinner: when the model returns only tool calls
             // (no content/reasoning), onModelStreamStart never fires, so the old
             // spinner's intervals would leak.
@@ -384,31 +376,29 @@ function createCliCallbacks() {
             }
             const toolPhrases = (0, phrases_1.getPhrases)().tool;
             const first = (0, phrases_1.pickPhrase)(toolPhrases);
-            currentSpinner = new Spinner(first, toolPhrases);
+            setSpinner(new spinner_imperative_1.ImperativeSpinner(first, toolPhrases));
             currentSpinner.start();
             hadToolRun = true;
         },
         onToolEnd: (name, argSummary, success) => {
             currentSpinner?.stop();
-            currentSpinner = null;
-            const msg = (0, format_1.formatToolResult)(name, argSummary, success);
-            const color = success ? "\x1b[32m" : "\x1b[31m";
-            process.stderr.write(`${color}${msg}\x1b[0m\n`);
+            setSpinner(null);
+            (0, tool_display_1.writeToolEnd)(name, argSummary, success);
         },
         onError: (error, severity) => {
             if (severity === "transient") {
                 currentSpinner?.fail(error.message);
-                currentSpinner = null;
+                setSpinner(null);
             }
             else {
                 currentSpinner?.stop();
-                currentSpinner = null;
+                setSpinner(null);
                 process.stderr.write(`\x1b[31m${(0, format_1.formatError)(error)}\x1b[0m\n`);
             }
         },
         onKick: () => {
             currentSpinner?.stop();
-            currentSpinner = null;
+            setSpinner(null);
             if (textDirty) {
                 process.stdout.write("\n");
                 textDirty = false;
@@ -417,10 +407,18 @@ function createCliCallbacks() {
         },
         flushMarkdown: () => {
             currentSpinner?.stop();
-            currentSpinner = null;
+            setSpinner(null);
+            /* v8 ignore start -- wrapper flush: tested via cli.test.ts flushMarkdown tests @preserve */
             const remaining = streamer.flush();
-            if (remaining)
-                process.stdout.write(remaining);
+            if (remaining) {
+                const wrapped = wrapper.push(remaining);
+                if (wrapped)
+                    process.stdout.write(wrapped);
+            }
+            const tail = wrapper.flush();
+            if (tail)
+                process.stdout.write(tail);
+            /* v8 ignore stop */
         },
     };
 }
@@ -461,29 +459,243 @@ async function* createDebouncedLines(source, debounceMs) {
         yield lines.join("\n");
     }
 }
+/**
+ * Async queue that bridges push-based Ink input to pull-based async iteration.
+ * Input from Ink's onSubmit callback is pushed; the business logic loop awaits via for-await.
+ */
+class InputQueue {
+    queue = [];
+    resolve = null;
+    done = false;
+    push(input) {
+        if (this.done)
+            return;
+        if (this.resolve) {
+            const r = this.resolve;
+            this.resolve = null;
+            r({ value: input, done: false });
+        }
+        else {
+            this.queue.push(input);
+        }
+    }
+    close() {
+        this.done = true;
+        if (this.resolve) {
+            const r = this.resolve;
+            this.resolve = null;
+            r({ value: undefined, done: true });
+        }
+    }
+    /** Drain all buffered items, leaving any pending async awaiter untouched. */
+    drainAll() {
+        const items = [...this.queue];
+        this.queue = [];
+        return items;
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.queue.length > 0) {
+                    return Promise.resolve({ value: this.queue.shift(), done: false });
+                }
+                if (this.done) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => {
+                    this.resolve = resolve;
+                });
+            },
+        };
+    }
+}
+exports.InputQueue = InputQueue;
 async function runCliSession(options) {
     /* v8 ignore start -- integration: runCliSession is interactive, tested via E2E @preserve */
-    const pasteDebounceMs = options.pasteDebounceMs ?? 50;
     const registry = (0, commands_1.createCommandRegistry)();
     if (!options.disableCommands) {
         (0, commands_1.registerDefaultCommands)(registry);
     }
     const messages = options.messages
-        ?? [{ role: "system", content: await (0, prompt_1.buildSystem)("cli") }];
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
-    const ctrl = new InputController(rl);
+        ?? [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)("cli")) }];
+    // ─── Rendering: TUI (Ink + Static) for TTY, imperative for tests/pipes ───
+    const useTui = !options._testInputSource && process.stdin.isTTY === true;
     let currentAbort = null;
-    const history = [];
     let closed = false;
-    rl.on("close", () => { closed = true; });
-    if (options.banner !== false) {
-        const bannerText = typeof options.banner === "string"
-            ? options.banner
-            : `${options.agentName} (type /commands for help)`;
-        // eslint-disable-next-line no-console -- terminal UX: startup banner
-        console.log(`\n${bannerText}\n`);
+    // eslint-disable-next-line prefer-const -- set by onImageMap callback during input
+    let pendingImages = null;
+    let cliCallbacks;
+    let tuiStore = null;
+    let inkRef = null;
+    const inputQueue = useTui ? new InputQueue() : null;
+    let rl = null;
+    if (useTui) {
+        try {
+            const [ink, React, tuiMod, storeMod] = await Promise.all([
+                Promise.resolve().then(() => __importStar(require("ink"))),
+                Promise.resolve().then(() => __importStar(require("react"))),
+                Promise.resolve().then(() => __importStar(require("./cli/ouro-tui"))),
+                Promise.resolve().then(() => __importStar(require("./cli/tui-store"))),
+            ]);
+            const { OuroTui } = tuiMod;
+            const { TuiStore, createTuiCallbacks } = storeMod;
+            tuiStore = new TuiStore();
+            cliCallbacks = createTuiCallbacks(tuiStore);
+            // Seed input history from previous session (for up/down arrows) — NOT display
+            const prevUserMsgs = messages
+                .filter((msg) => msg.role === "user" && typeof msg.content === "string")
+                .map(msg => msg.content);
+            tuiStore.seedHistory(prevUserMsgs);
+            // Show session resume context: last 2 exchanges as normal messages
+            if (messages.length > 1) {
+                const userAssistantMsgs = messages.filter((m) => (m.role === "user" || m.role === "assistant") && typeof m.content === "string" && m.content.trim().length > 0);
+                // Extract last 2 exchanges (up to 4 messages)
+                const lastExchanges = [];
+                for (let i = userAssistantMsgs.length - 1; i >= 0 && lastExchanges.length < 4; i--) {
+                    lastExchanges.unshift({ role: userAssistantMsgs[i].role, content: userAssistantMsgs[i].content });
+                }
+                tuiStore.addResumeMessages(lastExchanges);
+            }
+            // Compute resumeInfo for header banner
+            const resumeInfo = messages.length > 1
+                ? {
+                    messageCount: messages.filter(m => m.role === "user" || m.role === "assistant").length,
+                    timeAgo: options.lastActivityAt ? formatTimeAgo(new Date(options.lastActivityAt)) : "unknown",
+                }
+                : undefined;
+            // Ctrl-C state machine (Claude Code behavior):
+            // During generation: abort current request
+            // Idle with text: clear input
+            // Idle empty (first): warn
+            // Idle empty (second): exit
+            let ctrlCWarned = false;
+            let ctrlCTimer = null;
+            const handleCtrlC = (hasInput) => {
+                if (currentAbort) {
+                    currentAbort.abort();
+                    ctrlCWarned = false;
+                    return "abort";
+                }
+                if (hasInput) {
+                    ctrlCWarned = false;
+                    return "clear";
+                }
+                if (ctrlCWarned) {
+                    ctrlCWarned = false;
+                    if (ctrlCTimer) {
+                        clearTimeout(ctrlCTimer);
+                        ctrlCTimer = null;
+                    }
+                    closed = true;
+                    inputQueue.close();
+                    return "exit";
+                }
+                ctrlCWarned = true;
+                // Reset after 2 seconds — must press twice within window
+                ctrlCTimer = setTimeout(() => { ctrlCWarned = false; }, 2000);
+                return "warn";
+            };
+            // TUI root: subscribes to store, passes props to OuroTui
+            // Elapsed timer is local React state (no store.notify overhead)
+            const storeRef = tuiStore;
+            function TuiRoot() {
+                const [, forceUpdate] = React.useState(0);
+                const [elapsed, setElapsed] = React.useState(0);
+                React.useEffect(() => storeRef.subscribe(() => {
+                    forceUpdate((n) => n + 1);
+                    // Reset ctrlC warning on any state change (new turn, etc.)
+                }), []);
+                React.useEffect(() => {
+                    const iv = setInterval(() => setElapsed(storeRef.getElapsed()), 1000);
+                    return () => clearInterval(iv);
+                }, []);
+                return React.createElement(OuroTui, {
+                    agentName: options.agentName,
+                    model: (0, identity_1.loadAgentConfig)().humanFacing?.model ?? "",
+                    completedMessages: storeRef.completedMessages,
+                    inputHistory: storeRef.inputHistory,
+                    queuedInputs: storeRef.queuedInputs,
+                    live: storeRef.live,
+                    elapsedSeconds: elapsed,
+                    contextPercent: 0,
+                    onSubmit: (text) => { ctrlCWarned = false; inputQueue.push(text); storeRef.enqueueInput(text); },
+                    onCtrlC: handleCtrlC,
+                    onPopQueue: () => { const items = storeRef.popAllQueuedForEditing(); inputQueue.drainAll(); return items; },
+                    headerShown: storeRef.headerShown,
+                    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 });
+        }
+        catch (err) {
+            // Ink failed to load (CJS compat, missing deps, etc.) — fall through to imperative
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.tui_fallback",
+                message: `TUI failed to load, falling back to imperative: ${err instanceof Error ? err.message : String(err)}`,
+                meta: {},
+            });
+        }
+    }
+    // Fallback to imperative callbacks if TUI didn't initialize
+    if (!tuiStore) {
+        cliCallbacks = createCliCallbacks();
+        if (options.banner !== false) {
+            const bannerText = typeof options.banner === "string"
+                ? options.banner
+                : `${options.agentName} (type /commands for help)`;
+            // eslint-disable-next-line no-console -- terminal UX: startup banner
+            console.log(`\n${bannerText}\n`);
+        }
     }
-    const cliCallbacks = createCliCallbacks();
+    // Display helpers: route to TUI store or imperative stderr/stdout
+    const display = {
+        error: (msg) => {
+            if (tuiStore)
+                tuiStore.setError(msg);
+            else
+                process.stderr.write(`\x1b[31m${msg}\x1b[0m\n`);
+        },
+        warn: (msg) => {
+            if (tuiStore)
+                tuiStore.setError(msg); // TUI shows warnings as errors (amber color handled in component)
+            else
+                process.stderr.write(`\x1b[33m${msg}\x1b[0m\n`);
+        },
+        text: (msg) => {
+            if (tuiStore)
+                tuiStore.appendText(msg);
+            else
+                process.stdout.write(`${msg}\n`);
+        },
+        suppressInput: () => {
+            if (tuiStore)
+                tuiStore.suppressInput();
+        },
+        restoreInput: () => {
+            if (tuiStore)
+                tuiStore.restoreInput();
+        },
+    };
+    const effectiveToolContext = {
+        signin: options.toolContext?.signin ?? (async () => undefined),
+        ...options.toolContext,
+        codingFeedback: {
+            send: async (message) => {
+                const assistantMessage = {
+                    role: "assistant",
+                    content: message,
+                };
+                messages.push(assistantMessage);
+                await options.onAsyncAssistantMessage?.(messages, assistantMessage);
+                display.text(message);
+                await options.toolContext?.codingFeedback?.send(message);
+            },
+        },
+    };
     // exitOnToolCall machinery: wrap execTool to detect target tool
     let exitToolResult;
     let exitToolFired = false;
@@ -494,8 +706,6 @@ async function runCliSession(options) {
             if (name === options.exitOnToolCall) {
                 exitToolResult = result;
                 exitToolFired = true;
-                // Abort immediately so the model doesn't generate more output
-                // (e.g. reasoning about calling final_answer after complete_adoption)
                 currentAbort?.abort();
             }
             return result;
@@ -503,28 +713,6 @@ async function runCliSession(options) {
         : resolvedExecTool;
     // Resolve toolChoiceRequired: use explicit option if set, else fall back to toggle
     const getEffectiveToolChoiceRequired = () => options.toolChoiceRequired !== undefined ? options.toolChoiceRequired : (0, commands_1.getToolChoiceRequired)();
-    // Ctrl-C at the input prompt: clear line or warn/exit
-    rl.on("SIGINT", () => {
-        const rlInt = rl;
-        const currentLine = rlInt.line || "";
-        const result = handleSigint(rl, currentLine);
-        if (result === "clear") {
-            rlInt.line = "";
-            rlInt.cursor = 0;
-            process.stdout.write("\r\x1b[K\x1b[36m> \x1b[0m");
-        }
-        else if (result === "warn") {
-            rlInt.line = "";
-            rlInt.cursor = 0;
-            process.stdout.write("\r\x1b[K");
-            process.stderr.write("press Ctrl-C again to exit\n");
-            process.stdout.write("\x1b[36m> \x1b[0m");
-        }
-        else {
-            rl.close();
-        }
-    });
-    const debouncedLines = (source) => createDebouncedLines(source, pasteDebounceMs);
     (0, runtime_1.emitNervesEvent)({
         component: "senses",
         event: "senses.cli_session_start",
@@ -537,7 +725,7 @@ async function runCliSession(options) {
     if (options.autoFirstTurn && messages.length > 0 && messages[messages.length - 1]?.role === "user") {
         currentAbort = new AbortController();
         const traceId = (0, nerves_1.createTraceId)();
-        ctrl.suppress(() => currentAbort.abort());
+        display.suppressInput();
         let result;
         try {
             result = await (0, core_1.runAgent)(messages, cliCallbacks, options.skipSystemPromptRefresh ? undefined : "cli", currentAbort.signal, {
@@ -545,119 +733,145 @@ async function runCliSession(options) {
                 traceId,
                 tools: options.tools,
                 execTool: wrappedExecTool,
-                toolContext: options.toolContext,
+                toolContext: effectiveToolContext,
             });
         }
         catch (err) {
-            // AbortError (Ctrl-C) -- silently continue to prompt
-            // All other errors: show the user what happened
             if (!(err instanceof DOMException && err.name === "AbortError")) {
-                process.stderr.write(`\x1b[31m${err instanceof Error ? err.message : String(err)}\x1b[0m\n`);
+                display.error(err instanceof Error ? err.message : String(err));
             }
         }
         cliCallbacks.flushMarkdown();
-        ctrl.restore();
+        display.restoreInput();
         currentAbort = null;
         if (exitToolFired) {
             exitReason = "tool_exit";
-            rl.close();
+            closed = true;
         }
         else {
             const lastMsg = messages[messages.length - 1];
             if (lastMsg?.role === "assistant" && !(typeof lastMsg.content === "string" ? lastMsg.content : "").trim()) {
-                process.stderr.write("\x1b[33m(empty response)\x1b[0m\n");
+                display.warn("(empty response)");
             }
-            process.stdout.write("\n\n");
             if (options.onTurnEnd) {
                 await options.onTurnEnd(messages, result ?? { usage: undefined });
             }
         }
     }
-    if (!exitToolFired) {
-        process.stdout.write("\x1b[36m> \x1b[0m");
-    }
     try {
-        for await (const input of debouncedLines(rl)) {
+        // Input source: TUI queue for Ink, test source for tests, readline fallback
+        let inputSource;
+        let inputCtrl = null;
+        if (tuiStore && inputQueue) {
+            // TUI path: input comes from Ink's onSubmit → InputQueue
+            inputSource = inputQueue;
+        }
+        else if (options._testInputSource) {
+            inputSource = options._testInputSource;
+        }
+        else {
+            // Imperative fallback: readline
+            const isTTY = process.stdin.isTTY === true;
+            rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: isTTY });
+            inputCtrl = new InputController(rl);
+            inputSource = rl;
+            process.stdout.write(CLI_PROMPT);
+        }
+        for await (const input of inputSource) {
             if (closed)
                 break;
-            if (!input.trim()) {
-                process.stdout.write("\x1b[36m> \x1b[0m");
+            if (!input.trim())
                 continue;
-            }
+            // Remove from TUI queue display as the agent picks up this message
+            tuiStore?.dequeueInput(input);
             // Optional input gate (e.g. trust gate in main)
             if (options.onInput) {
                 const gate = options.onInput(input);
                 if (!gate.allowed) {
                     if (gate.reply) {
-                        process.stdout.write(`${gate.reply}\n`);
+                        display.text(gate.reply);
                     }
                     if (closed)
                         break;
-                    process.stdout.write("\x1b[36m> \x1b[0m");
                     continue;
                 }
             }
-            // Check for slash commands
-            const parsed = (0, commands_1.parseSlashCommand)(input);
-            if (parsed) {
-                const dispatchResult = registry.dispatch(parsed.command, { channel: "cli" });
-                if (dispatchResult.handled && dispatchResult.result) {
-                    if (dispatchResult.result.action === "exit") {
-                        break;
-                    }
-                    else if (dispatchResult.result.action === "new") {
-                        messages.length = 0;
-                        messages.push({ role: "system", content: await (0, prompt_1.buildSystem)("cli") });
-                        await options.onNewSession?.();
-                        // eslint-disable-next-line no-console -- terminal UX: session cleared
-                        console.log("session cleared");
-                        process.stdout.write("\x1b[36m> \x1b[0m");
-                        continue;
-                    }
-                    else if (dispatchResult.result.action === "response") {
-                        // eslint-disable-next-line no-console -- terminal UX: command dispatch result
-                        console.log(dispatchResult.result.message || "");
-                        process.stdout.write("\x1b[36m> \x1b[0m");
-                        continue;
+            // Check for slash commands (legacy path only — pipeline handles commands for runTurn path)
+            if (!options.runTurn) {
+                const parsed = (0, commands_1.parseSlashCommand)(input);
+                if (parsed) {
+                    const dispatchResult = registry.dispatch(parsed.command, { channel: "cli" });
+                    if (dispatchResult.handled && dispatchResult.result) {
+                        if (dispatchResult.result.action === "exit") {
+                            break;
+                        }
+                        else if (dispatchResult.result.action === "response") {
+                            display.text(dispatchResult.result.message || "");
+                            continue;
+                        }
                     }
                 }
             }
-            // Re-style the echoed input lines without leaving wrapped paste remnants behind.
-            const cols = process.stdout.columns || 80;
-            process.stdout.write((0, cli_layout_1.formatEchoedInputSummary)(input, cols));
-            addHistory(history, input);
+            // Track user message in TUI for display
+            if (tuiStore)
+                tuiStore.addUserMessage(input);
             currentAbort = new AbortController();
-            ctrl.suppress(() => currentAbort.abort());
+            if (tuiStore)
+                tuiStore.suppressInput();
+            inputCtrl?.suppress(() => { currentAbort?.abort(); });
+            // Resolve pending image content before the turn executes
+            let contentParts = null;
+            const currentImages = pendingImages;
+            if (currentImages && currentImages.size > 0) {
+                contentParts = await (0, image_paste_1.resolveImageContent)(input, currentImages);
+                pendingImages = null;
+            }
             let result;
             try {
                 if (options.runTurn) {
                     // Pipeline-based turn: the runTurn callback handles user message assembly,
                     // pending drain, trust gate, runAgent, postTurn, and token accumulation.
-                    result = await options.runTurn(messages, input, cliCallbacks, currentAbort.signal);
+                    result = await options.runTurn(messages, input, cliCallbacks, currentAbort.signal, effectiveToolContext, contentParts ?? undefined);
+                    // Handle pipeline-intercepted commands with loop-control side effects
+                    if (result?.turnOutcome === "command") {
+                        if (result.commandAction === "exit") {
+                            break;
+                        }
+                        // For "response" commands: the pipeline already emitted the response via onTextChunk
+                        cliCallbacks.flushMarkdown();
+                        continue;
+                    }
                 }
                 else {
-                    // Legacy path: inline runAgent (used by adoption specialist and tests)
+                    // Legacy path: inline runAgent (used by serpent guide and tests)
                     const prefix = options.getContentPrefix?.();
-                    messages.push({ role: "user", content: prefix ? `${prefix}\n\n${input}` : input });
+                    const userContent = contentParts
+                        ? contentParts
+                        : (prefix ? `${prefix}\n\n${input}` : input);
+                    const userMsg = { role: "user", content: userContent };
+                    (0, session_events_1.stampIngressTime)(userMsg);
+                    messages.push(userMsg);
                     const traceId = (0, nerves_1.createTraceId)();
                     result = await (0, core_1.runAgent)(messages, cliCallbacks, options.skipSystemPromptRefresh ? undefined : "cli", currentAbort.signal, {
                         toolChoiceRequired: getEffectiveToolChoiceRequired(),
                         traceId,
                         tools: options.tools,
                         execTool: wrappedExecTool,
-                        toolContext: options.toolContext,
+                        toolContext: effectiveToolContext,
                     });
                 }
             }
             catch (err) {
-                // AbortError (Ctrl-C) -- silently return to prompt
-                // All other errors: show the user what happened
                 if (!(err instanceof DOMException && err.name === "AbortError")) {
-                    process.stderr.write(`\x1b[31m${err instanceof Error ? err.message : String(err)}\x1b[0m\n`);
+                    display.error(err instanceof Error ? err.message : String(err));
                 }
             }
             cliCallbacks.flushMarkdown();
-            ctrl.restore();
+            if (!tuiStore)
+                process.stdout.write("\n"); // ensure response ends with newline before prompt (imperative only)
+            if (tuiStore)
+                tuiStore.restoreInput();
+            inputCtrl?.restore();
             currentAbort = null;
             // Check if exit tool was fired during this turn
             if (exitToolFired) {
@@ -667,20 +881,35 @@ async function runCliSession(options) {
             // Safety net: never silently swallow an empty response
             const lastMsg = messages[messages.length - 1];
             if (lastMsg?.role === "assistant" && !(typeof lastMsg.content === "string" ? lastMsg.content : "").trim()) {
-                process.stderr.write("\x1b[33m(empty response)\x1b[0m\n");
+                display.warn("(empty response)");
             }
-            process.stdout.write("\n\n");
             // Post-turn hook (session persistence, pending drain, prompt refresh, etc.)
             if (options.onTurnEnd) {
                 await options.onTurnEnd(messages, result ?? { usage: undefined });
             }
             if (closed)
                 break;
-            process.stdout.write("\x1b[36m> \x1b[0m");
         }
     }
     finally {
-        rl.close();
+        rl?.close();
+        if (inkRef) {
+            // Suppress React "state update on unmounted component" warnings during cleanup.
+            // Ink's useInput hook fires after unmount — this is harmless but noisy.
+            // This also covers the SerpentGuide exitOnToolCall path, which aborts the
+            // current request and breaks out of the loop into this finally block.
+            // eslint-disable-next-line no-console -- intentional console.warn/error override for cleanup
+            const origWarn = console.warn;
+            const origError = console.error; // eslint-disable-line no-console
+            // eslint-disable-next-line no-console -- suppress React unmount warnings
+            console.warn = (...args) => { if (typeof args[0] === "string" && args[0].includes("Can't perform a React state update"))
+                return; origWarn.apply(console, args); };
+            // eslint-disable-next-line no-console -- suppress React unmount warnings
+            console.error = (...args) => { if (typeof args[0] === "string" && args[0].includes("Can't perform a React state update"))
+                return; origError.apply(console, args); };
+            inkRef.unmount();
+            setTimeout(() => { console.warn = origWarn; console.error = origError; }, 100); // eslint-disable-line no-console
+        }
         if (options.banner !== false) {
             // eslint-disable-next-line no-console -- terminal UX: goodbye
             console.log("bye");
@@ -693,18 +922,33 @@ async function main(agentName, options) {
     if (agentName)
         (0, identity_1.setAgentName)(agentName);
     const pasteDebounceMs = options?.pasteDebounceMs ?? 50;
+    // Safety net: process-level SIGINT handler ensures Ctrl+C always exits,
+    // even when Ink's event loop is blocked by expensive renders.
+    /* v8 ignore start -- process signal handler @preserve */
+    let sigintCount = 0;
+    const sigintHandler = () => {
+        sigintCount++;
+        if (sigintCount >= 2)
+            process.exit(1);
+    };
+    if (!options?._testInputSource) {
+        process.on("SIGINT", sigintHandler);
+    }
+    /* v8 ignore stop */
+    // Register spinner hooks so log output clears the spinner before printing
+    (0, nerves_1.registerSpinnerHooks)(pauseActiveSpinner, resumeActiveSpinner);
     // Fallback: apply pending updates for daemon-less direct CLI usage
     (0, update_hooks_1.registerUpdateHook)(bundle_meta_1.bundleMetaHook);
+    (0, update_hooks_1.registerUpdateHook)(agent_config_v2_1.agentConfigV2Hook);
     await (0, update_hooks_1.applyPendingUpdates)((0, identity_1.getAgentBundlesRoot)(), (0, bundle_manifest_1.getPackageVersion)());
     // Fail fast if provider is misconfigured (triggers human-readable error + exit)
-    (0, core_1.getProvider)();
+    (0, core_1.getProvider)("human");
     // Resolve context kernel (identity + channel) for CLI
     const friendsPath = path.join((0, identity_1.getAgentRoot)(), "friends");
-    const friendStore = new store_file_1.FileFriendStore(friendsPath);
+    const friendStore = new friends_1.FileFriendStore(friendsPath);
     const username = os.userInfo().username;
-    const hostname = os.hostname();
-    const localExternalId = `${username}@${hostname}`;
-    const resolver = new resolver_1.FriendResolver(friendStore, {
+    const localExternalId = username;
+    const resolver = new friends_1.FriendResolver(friendStore, {
         provider: "local",
         externalId: localExternalId,
         displayName: username,
@@ -734,31 +978,74 @@ async function main(agentName, options) {
     // Load existing session or start fresh
     const existing = (0, context_1.loadSession)(sessPath);
     let sessionState = existing?.state;
+    let sessionEvents = existing?.events ?? [];
+    const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
     const sessionMessages = existing?.messages && existing.messages.length > 0
         ? existing.messages
-        : [{ role: "system", content: await (0, prompt_1.buildSystem)("cli", undefined, resolvedContext) }];
+        : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)("cli", {}, resolvedContext)) }];
+    // Repair any orphaned tool calls from a crash mid-turn
+    (0, core_1.repairOrphanedToolCalls)(sessionMessages);
     // Per-turn pipeline input: CLI capabilities and pending dir
-    const cliCapabilities = (0, channel_1.getChannelCapabilities)("cli");
+    const cliCapabilities = (0, friends_1.getChannelCapabilities)("cli");
     const currentAgentName = (0, identity_1.getAgentName)();
     const pendingDir = (0, pending_1.getPendingDir)(currentAgentName, friendId, "cli", "session");
-    const summarize = (0, core_1.createSummarize)();
+    const summarize = (0, core_1.createSummarize)("human");
+    const cliFailoverState = { pending: null };
     try {
         await runCliSession({
             agentName: currentAgentName,
             pasteDebounceMs,
             messages: sessionMessages,
-            runTurn: async (messages, userInput, callbacks, signal) => {
+            lastActivityAt: sessionState?.lastFriendActivityAt,
+            _testInputSource: options?._testInputSource,
+            onAsyncAssistantMessage: async (messages, _assistantMessage) => {
+                const prepared = (0, context_1.postTurnTrim)(messages);
+                const events = (0, context_1.postTurnPersist)(sessPath, prepared, undefined, sessionState);
+                /* v8 ignore next -- defensive: postTurnPersist always returns events in practice @preserve */
+                sessionEvents = events.length > 0 ? events : sessionEvents;
+            },
+            runTurn: async (messages, userInput, callbacks, signal, toolContext, userContent) => {
                 // Run the full per-turn pipeline: resolve -> gate -> session -> drain -> runAgent -> postTurn -> tokens
                 // User message passed via input.messages so the pipeline can prepend pending messages to it.
+                const failoverState = cliFailoverState;
+                // Capture terminal errors instead of displaying immediately — the failover
+                // message replaces the raw error if failover triggers successfully.
+                let capturedTerminalError = null;
+                /* v8 ignore start -- failover-aware callback wrapper: tested via pipeline integration @preserve */
+                const failoverAwareCallbacks = {
+                    ...callbacks,
+                    // Save session after each tool result for crash recovery (deferred to avoid blocking)
+                    onToolResult: (turnMessages) => {
+                        const prepared = (0, context_1.postTurnTrim)(turnMessages);
+                        (0, context_1.deferPostTurnPersist)(sessPath, prepared, undefined, sessionState);
+                    },
+                    onError: (error, severity) => {
+                        if (severity === "terminal" && failoverState) {
+                            capturedTerminalError = error;
+                            callbacks.onError(new Error(""), "transient");
+                            return;
+                        }
+                        callbacks.onError(error, severity);
+                    },
+                };
+                /* v8 ignore stop */
                 const result = await (0, pipeline_1.handleInboundTurn)({
                     channel: "cli",
                     sessionKey: "session",
                     capabilities: cliCapabilities,
-                    messages: [{ role: "user", content: userInput }],
+                    messages: [{ role: "user", content: userContent ?? userInput }],
                     continuityIngressTexts: getCliContinuityIngressTexts(userInput),
-                    callbacks,
+                    callbacks: failoverAwareCallbacks,
                     friendResolver: { resolve: () => Promise.resolve(resolvedContext) },
-                    sessionLoader: { loadOrCreate: () => Promise.resolve({ messages, sessionPath: sessPath, state: sessionState }) },
+                    sessionLoader: {
+                        loadOrCreate: () => Promise.resolve({
+                            messages,
+                            sessionPath: sessPath,
+                            state: sessionState,
+                            events: sessionEvents,
+                            structuredOutputs: existing?.structuredOutputs,
+                        }),
+                    },
                     pendingDir,
                     friendStore,
                     provider: "local",
@@ -776,30 +1063,53 @@ async function main(agentName, options) {
                         },
                     }),
                     postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
-                        (0, context_1.postTurn)(turnMessages, sessionPathArg, usage, hooks, state);
+                        // Trim synchronously (mutates turnMessages for next turn),
+                        // then defer envelope build + disk I/O to avoid blocking the TUI.
+                        const prepared = (0, context_1.postTurnTrim)(turnMessages, usage, hooks);
                         sessionState = state;
+                        (0, context_1.deferPostTurnPersist)(sessionPathArg, prepared, usage, state).then((events) => {
+                            /* v8 ignore next -- defensive: deferPostTurnPersist always resolves events in practice @preserve */
+                            sessionEvents = events.length > 0 ? events : sessionEvents;
+                        });
                     },
-                    accumulateFriendTokens: tokens_1.accumulateFriendTokens,
+                    accumulateFriendTokens: friends_1.accumulateFriendTokens,
                     signal,
                     runAgentOptions: {
                         toolChoiceRequired: (0, commands_1.getToolChoiceRequired)(),
                         traceId: (0, nerves_1.createTraceId)(),
+                        mcpManager,
+                        toolContext,
                     },
+                    failoverState,
                 });
+                /* v8 ignore start -- failover display: tested via pipeline integration tests @preserve */
+                if (result.failoverMessage) {
+                    // Failover handled it — show the actionable message instead of the raw error
+                    process.stdout.write(`\x1b[33m${result.failoverMessage}\x1b[0m\n`);
+                }
+                else if (capturedTerminalError) {
+                    // Failover didn't trigger (no failoverState, or sequence failed) — show the raw error
+                    process.stderr.write(`\x1b[31m${(0, format_1.formatError)(capturedTerminalError)}\x1b[0m\n`);
+                }
+                /* v8 ignore stop */
                 // Handle gate rejection: display auto-reply if present
                 if (!result.gateResult.allowed) {
                     if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
                         process.stdout.write(`${result.gateResult.autoReply}\n`);
                     }
                 }
-                return { usage: result.usage };
-            },
-            onNewSession: () => {
-                (0, context_1.deleteSession)(sessPath);
+                return { usage: result.usage, turnOutcome: result.turnOutcome, commandAction: result.commandAction };
             },
         });
     }
     finally {
         sessionLock?.release();
     }
+    // Force exit: lingering handles (Ink cleanup timers, MCP connections) keep the
+    // event loop alive after the interactive session ends. This is safe because all
+    // session persistence has already completed in the finally block above.
+    /* v8 ignore next -- process.exit not callable in vitest @preserve */
+    if (!options?._testInputSource)
+        process.exit(0);
 }
+// CI trigger