@ouro.bot/cli 0.1.0-alpha.74 → 0.1.0-alpha.740

package/dist/senses/cli.js

@@ -33,9 +33,11 @@ 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;
@@ -54,38 +56,41 @@ 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 session_transaction_1 = require("../mind/session-transaction");
+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
- * `[inner thought: {content}]`, inter-agent messages become
+ * `[private-runtime note: {content}]`, inter-agent messages become
  * `[message from {name}: {content}]`.
  */
 function formatPendingPrefix(messages, agentName) {
     return messages
         .map((msg) => msg.from === agentName
-        ? `[inner thought: ${msg.content}]`
+        ? `[private-runtime note: ${msg.content}]`
         : `[message from ${msg.from}: ${msg.content}]`)
         .join("\n");
 }
@@ -93,6 +98,35 @@ function getCliContinuityIngressTexts(input) {
     const trimmed = input.trim();
     return trimmed ? [trimmed] : [];
 }
+/* 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);
+    }
+}
 // Module-level active spinner for log coordination.
 // The terminal log sink calls these to avoid interleaving with spinner output.
 let _activeSpinner = null;
@@ -101,82 +135,9 @@ function pauseActiveSpinner() { _activeSpinner?.pause(); }
 function resumeActiveSpinner() { _activeSpinner?.resume(); }
 /* v8 ignore stop */
 function setActiveSpinner(s) { _activeSpinner = s; }
-// 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;
-    }
-    /* v8 ignore start -- pause/resume: exercised at runtime via log sink coordination @preserve */
-    /** Clear the spinner line temporarily so other output can print cleanly. */
-    pause() {
-        if (this.stopped)
-            return;
-        process.stderr.write("\r\x1b[K");
-    }
-    /** Restore the spinner line after a pause. */
-    resume() {
-        if (this.stopped)
-            return;
-        this.spin();
-    }
-    /* v8 ignore stop */
-    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`);
-    }
-}
-exports.Spinner = Spinner;
+// 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.
@@ -345,60 +306,65 @@ function createCliCallbacks() {
     });
     let currentSpinner = null;
     function setSpinner(s) { currentSpinner = s; setActiveSpinner(s); }
-    let hadReasoning = false;
     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 {
+        settleOutputMode: "final_only",
         onModelStart: () => {
             currentSpinner?.stop();
             setSpinner(null);
-            hadReasoning = false;
             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);
-            setSpinner(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();
                 setSpinner(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;
-            }
             const rendered = streamer.push(text);
-            if (rendered)
-                process.stdout.write(rendered);
-            textDirty = text.length > 0 && !text.endsWith("\n");
-        },
-        onReasoningChunk: (text) => {
-            if (currentSpinner) {
-                currentSpinner.stop();
-                setSpinner(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.
@@ -411,16 +377,14 @@ function createCliCallbacks() {
             }
             const toolPhrases = (0, phrases_1.getPhrases)().tool;
             const first = (0, phrases_1.pickPhrase)(toolPhrases);
-            setSpinner(new Spinner(first, toolPhrases));
+            setSpinner(new spinner_imperative_1.ImperativeSpinner(first, toolPhrases));
             currentSpinner.start();
             hadToolRun = true;
         },
         onToolEnd: (name, argSummary, success) => {
             currentSpinner?.stop();
             setSpinner(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`);
+            (0, tool_display_1.writeToolEnd)(name, argSummary, success);
         },
         onError: (error, severity) => {
             if (severity === "transient") {
@@ -445,9 +409,17 @@ function createCliCallbacks() {
         flushMarkdown: () => {
             currentSpinner?.stop();
             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 */
         },
     };
 }
@@ -488,29 +460,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;
@@ -521,8 +707,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;
@@ -530,28 +714,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",
@@ -564,7 +726,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, {
@@ -572,142 +734,189 @@ 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;
+            await options.onTurnStart?.(messages);
+            try {
+                // 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;
+                            }
+                        }
                     }
-                    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;
+                }
+                // Track user message in TUI for display
+                if (tuiStore)
+                    tuiStore.addUserMessage(input);
+                currentAbort = new AbortController();
+                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, 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 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;
+                    else {
+                        // Legacy path: inline runAgent (used by serpent guide and tests)
+                        const prefix = options.getContentPrefix?.();
+                        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: effectiveToolContext,
+                        });
                     }
                 }
-            }
-            // 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);
-            currentAbort = new AbortController();
-            ctrl.suppress(() => currentAbort.abort());
-            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);
+                catch (err) {
+                    if (!(err instanceof DOMException && err.name === "AbortError")) {
+                        display.error(err instanceof Error ? err.message : String(err));
+                    }
                 }
-                else {
-                    // Legacy path: inline runAgent (used by adoption specialist and tests)
-                    const prefix = options.getContentPrefix?.();
-                    messages.push({ role: "user", content: prefix ? `${prefix}\n\n${input}` : input });
-                    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,
-                    });
+                cliCallbacks.flushMarkdown();
+                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) {
+                    exitReason = "tool_exit";
+                    break;
                 }
-            }
-            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`);
+                // 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()) {
+                    display.warn("(empty response)");
+                }
+                // Post-turn hook (session persistence, pending drain, prompt refresh, etc.)
+                if (options.onTurnEnd) {
+                    await options.onTurnEnd(messages, result ?? { usage: undefined });
                 }
             }
-            cliCallbacks.flushMarkdown();
-            ctrl.restore();
-            currentAbort = null;
-            // Check if exit tool was fired during this turn
-            if (exitToolFired) {
-                exitReason = "tool_exit";
-                break;
-            }
-            // 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");
-            }
-            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 });
+            finally {
+                await options.onTurnFinish?.();
             }
             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");
@@ -720,20 +929,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,
@@ -747,90 +969,168 @@ async function main(agentName, options) {
         sinks: agentConfig.logging?.sinks,
     });
     const sessPath = (0, config_1.sessionPath)(friendId, "cli", "session");
-    let sessionLock = null;
-    try {
-        sessionLock = (0, session_lock_1.acquireSessionLock)(`${sessPath}.lock`, (0, identity_1.getAgentName)());
-    }
-    catch (error) {
-        /* v8 ignore start -- integration: main() is interactive, lock tested in session-lock.test.ts @preserve */
-        if (error instanceof session_lock_1.SessionLockError) {
-            process.stderr.write(`${error.message}\n`);
-            return;
-        }
-        throw error;
-        /* v8 ignore stop */
-    }
-    // Load existing session or start fresh
-    const existing = (0, context_1.loadSession)(sessPath);
-    let sessionState = existing?.state;
+    const acquireTurnLease = options?._acquireSessionTurnLease ?? session_transaction_1.acquireSessionTurnLease;
+    let sessionTurnLease = null;
+    let pendingPersists = [];
+    let existing = null;
+    let sessionState;
+    let sessionEvents = [];
     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", { mcpManager }, resolvedContext) }];
+    const sessionMessages = [
+        { role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)("cli", {}, resolvedContext)) },
+    ];
     // 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)();
-    try {
-        await runCliSession({
-            agentName: currentAgentName,
-            pasteDebounceMs,
-            messages: sessionMessages,
-            runTurn: async (messages, userInput, callbacks, signal) => {
-                // 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 result = await (0, pipeline_1.handleInboundTurn)({
-                    channel: "cli",
-                    sessionKey: "session",
-                    capabilities: cliCapabilities,
-                    messages: [{ role: "user", content: userInput }],
-                    continuityIngressTexts: getCliContinuityIngressTexts(userInput),
-                    callbacks,
-                    friendResolver: { resolve: () => Promise.resolve(resolvedContext) },
-                    sessionLoader: { loadOrCreate: () => Promise.resolve({ messages, sessionPath: sessPath, state: sessionState }) },
-                    pendingDir,
-                    friendStore,
-                    provider: "local",
-                    externalId: localExternalId,
-                    enforceTrustGate: trust_gate_1.enforceTrustGate,
-                    drainPending: pending_1.drainPending,
-                    drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(currentAgentName, deferredFriendId),
-                    runAgent: (msgs, cb, channel, sig, opts) => (0, core_1.runAgent)(msgs, cb, channel, sig, {
-                        ...opts,
-                        toolContext: {
-                            /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
-                            signin: async () => undefined,
-                            ...opts?.toolContext,
-                            summarize,
-                        },
+    const summarize = (0, core_1.createSummarize)("human");
+    const cliFailoverState = { pending: null };
+    await runCliSession({
+        agentName: currentAgentName,
+        pasteDebounceMs,
+        messages: sessionMessages,
+        lastActivityAt: sessionState?.lastFriendActivityAt,
+        _testInputSource: options?._testInputSource,
+        onTurnStart: async (messages) => {
+            sessionTurnLease = await acquireTurnLease(sessPath);
+            try {
+                pendingPersists = [];
+                existing = (0, context_1.loadSession)(sessPath);
+                sessionState = existing?.state;
+                sessionEvents = existing?.events ?? [];
+                const loadedMessages = existing?.messages && existing.messages.length > 0
+                    ? existing.messages
+                    : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)("cli", {}, resolvedContext)) }];
+                (0, core_1.repairOrphanedToolCalls)(loadedMessages);
+                messages.splice(0, messages.length, ...loadedMessages);
+            }
+            catch (error) {
+                const lease = sessionTurnLease;
+                sessionTurnLease = null;
+                await lease.release();
+                throw error;
+            }
+        },
+        onTurnFinish: async () => {
+            try {
+                await Promise.all(pendingPersists);
+            }
+            finally {
+                const lease = sessionTurnLease;
+                sessionTurnLease = null;
+                await lease.release();
+            }
+        },
+        onAsyncAssistantMessage: async (messages, _assistantMessage) => {
+            const prepared = (0, context_1.postTurnTrim)(messages);
+            const events = (0, context_1.postTurnPersist)(sessPath, prepared, undefined, sessionState, sessionTurnLease ?? undefined);
+            /* 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);
+                    pendingPersists.push((0, context_1.deferPostTurnPersist)(sessPath, prepared, undefined, sessionState, sessionTurnLease ?? undefined));
+                },
+                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: userContent ?? userInput }],
+                continuityIngressTexts: getCliContinuityIngressTexts(userInput),
+                callbacks: failoverAwareCallbacks,
+                sessionTurnLease: sessionTurnLease,
+                friendResolver: { resolve: () => Promise.resolve(resolvedContext) },
+                sessionLoader: {
+                    loadOrCreate: () => Promise.resolve({
+                        messages,
+                        sessionPath: sessPath,
+                        state: sessionState,
+                        events: sessionEvents,
+                        structuredOutputs: existing?.structuredOutputs,
                     }),
-                    postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
-                        (0, context_1.postTurn)(turnMessages, sessionPathArg, usage, hooks, state);
-                        sessionState = state;
-                    },
-                    accumulateFriendTokens: tokens_1.accumulateFriendTokens,
-                    signal,
-                    runAgentOptions: {
-                        toolChoiceRequired: (0, commands_1.getToolChoiceRequired)(),
-                        traceId: (0, nerves_1.createTraceId)(),
-                        mcpManager,
+                },
+                pendingDir,
+                friendStore,
+                provider: "local",
+                externalId: localExternalId,
+                enforceTrustGate: trust_gate_1.enforceTrustGate,
+                drainPending: pending_1.drainPending,
+                drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(currentAgentName, deferredFriendId),
+                runAgent: (msgs, cb, channel, sig, opts) => (0, core_1.runAgent)(msgs, cb, channel, sig, {
+                    ...opts,
+                    toolContext: {
+                        /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
+                        signin: async () => undefined,
+                        ...opts?.toolContext,
+                        summarize,
                     },
-                });
-                // 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`);
-                    }
+                }),
+                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;
+                    const persist = (0, context_1.deferPostTurnPersist)(sessionPathArg, prepared, usage, state, sessionTurnLease ?? undefined).then((events) => {
+                        /* v8 ignore next -- defensive: deferPostTurnPersist always resolves events in practice @preserve */
+                        sessionEvents = events.length > 0 ? events : sessionEvents;
+                    });
+                    pendingPersists.push(persist);
+                },
+                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);
-            },
-        });
-    }
-    finally {
-        sessionLock?.release();
-    }
+            }
+            return { usage: result.usage, turnOutcome: result.turnOutcome, commandAction: result.commandAction };
+        },
+    });
+    // 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