@ouro.bot/cli 0.1.0-alpha.7 → 0.1.0-alpha.700

package/dist/senses/cli.js

@@ -33,11 +33,20 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MarkdownStreamer = exports.InputController = exports.Spinner = 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;
 exports.createCliCallbacks = createCliCallbacks;
+exports.createDebouncedLines = createDebouncedLines;
+exports.runCliSession = runCliSession;
 exports.main = main;
 const readline = __importStar(require("readline"));
 const os = __importStar(require("os"));
@@ -47,71 +56,88 @@ 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 prompt_refresh_1 = require("../mind/prompt-refresh");
 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 session_lock_1 = require("./session-lock");
-// 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 = "";
-    constructor(m = "working", phrases) {
-        this.msg = m;
-        if (phrases && phrases.length > 0)
-            this.phrases = phrases;
-    }
-    start() {
-        process.stderr.write("\r\x1b[K");
-        this.spin();
-        this.iv = setInterval(() => this.spin(), 80);
-        if (this.phrases) {
-            this.piv = setInterval(() => this.rotatePhrase(), 1500);
-        }
-    }
-    spin() {
-        process.stderr.write(`\r${this.frames[this.i]} ${this.msg}... `);
-        this.i = (this.i + 1) % this.frames.length;
-    }
-    rotatePhrase() {
-        const next = (0, phrases_1.pickPhrase)(this.phrases, this.lastPhrase);
-        this.lastPhrase = next;
-        this.msg = next;
-    }
-    stop(ok) {
-        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`);
+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
+ * `[private-runtime note: {content}]`, inter-agent messages become
+ * `[message from {name}: {content}]`.
+ */
+function formatPendingPrefix(messages, agentName) {
+    return messages
+        .map((msg) => msg.from === agentName
+        ? `[private-runtime note: ${msg.content}]`
+        : `[message from ${msg.from}: ${msg.content}]`)
+        .join("\n");
+}
+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);
     }
 }
-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.
@@ -279,43 +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: () => {
-            currentSpinner?.stop();
-            currentSpinner = null;
+            // No-op: content callbacks (onTextChunk, onReasoningChunk) handle
+            // stopping the spinner. onModelStreamStart fires too early and
+            // doesn't fire at all for settle tool streaming.
+        },
+        onClearText: () => {
+            streamer.reset();
+            wrapper.reset();
         },
         onTextChunk: (text) => {
-            if (hadReasoning) {
-                process.stdout.write("\n\n");
-                hadReasoning = false;
+            // 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);
             }
             const rendered = streamer.push(text);
-            if (rendered)
-                process.stdout.write(rendered);
+            /* 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);
+            }
+            /* v8 ignore stop */
             textDirty = text.length > 0 && !text.endsWith("\n");
         },
-        onReasoningChunk: (text) => {
-            hadReasoning = true;
-            process.stdout.write(`\x1b[2m${text}\x1b[0m`);
-            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.
@@ -328,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;
@@ -361,41 +407,554 @@ 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 */
         },
     };
 }
+// Debounced line iterator: collects rapid-fire lines (paste) into a single input.
+// When the debounce timeout wins the race, the pending iter.next() is saved
+// and reused in the next iteration to prevent it from silently consuming input.
+async function* createDebouncedLines(source, debounceMs) {
+    if (debounceMs <= 0) {
+        yield* source;
+        return;
+    }
+    const iter = source[Symbol.asyncIterator]();
+    let pending = null;
+    while (true) {
+        const first = pending ? await pending : await iter.next();
+        pending = null;
+        if (first.done)
+            break;
+        const lines = [first.value];
+        let more = true;
+        while (more) {
+            const nextPromise = iter.next();
+            const raced = await Promise.race([
+                nextPromise.then((r) => ({ kind: "line", result: r })),
+                new Promise((r) => setTimeout(() => r({ kind: "timeout" }), debounceMs)),
+            ]);
+            if (raced.kind === "timeout") {
+                pending = nextPromise;
+                more = false;
+            }
+            else if (raced.result.done) {
+                more = false;
+            }
+            else {
+                lines.push(raced.result.value);
+            }
+        }
+        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 registry = (0, commands_1.createCommandRegistry)();
+    if (!options.disableCommands) {
+        (0, commands_1.registerDefaultCommands)(registry);
+    }
+    const messages = options.messages
+        ?? [{ 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;
+    let closed = false;
+    // 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`);
+        }
+    }
+    // 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;
+    const resolvedExecTool = options.execTool;
+    const wrappedExecTool = options.exitOnToolCall && resolvedExecTool
+        ? async (name, args, ctx) => {
+            const result = await resolvedExecTool(name, args, ctx);
+            if (name === options.exitOnToolCall) {
+                exitToolResult = result;
+                exitToolFired = true;
+                currentAbort?.abort();
+            }
+            return result;
+        }
+        : resolvedExecTool;
+    // Resolve toolChoiceRequired: use explicit option if set, else fall back to toggle
+    const getEffectiveToolChoiceRequired = () => options.toolChoiceRequired !== undefined ? options.toolChoiceRequired : (0, commands_1.getToolChoiceRequired)();
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.cli_session_start",
+        message: "runCliSession started",
+        meta: { agentName: options.agentName, hasExitOnToolCall: !!options.exitOnToolCall },
+    });
+    let exitReason = "user_quit";
+    // Auto-first-turn: process the last user message immediately so the agent
+    // speaks first (e.g. specialist greeting). Only triggers when explicitly opted in.
+    if (options.autoFirstTurn && messages.length > 0 && messages[messages.length - 1]?.role === "user") {
+        currentAbort = new AbortController();
+        const traceId = (0, nerves_1.createTraceId)();
+        display.suppressInput();
+        let result;
+        try {
+            result = await (0, core_1.runAgent)(messages, cliCallbacks, options.skipSystemPromptRefresh ? undefined : "cli", currentAbort.signal, {
+                toolChoiceRequired: getEffectiveToolChoiceRequired(),
+                traceId,
+                tools: options.tools,
+                execTool: wrappedExecTool,
+                toolContext: effectiveToolContext,
+            });
+        }
+        catch (err) {
+            if (!(err instanceof DOMException && err.name === "AbortError")) {
+                display.error(err instanceof Error ? err.message : String(err));
+            }
+        }
+        cliCallbacks.flushMarkdown();
+        display.restoreInput();
+        currentAbort = null;
+        if (exitToolFired) {
+            exitReason = "tool_exit";
+            closed = true;
+        }
+        else {
+            const lastMsg = messages[messages.length - 1];
+            if (lastMsg?.role === "assistant" && !(typeof lastMsg.content === "string" ? lastMsg.content : "").trim()) {
+                display.warn("(empty response)");
+            }
+            if (options.onTurnEnd) {
+                await options.onTurnEnd(messages, result ?? { usage: undefined });
+            }
+        }
+    }
+    try {
+        // 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())
+                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) {
+                        display.text(gate.reply);
+                    }
+                    if (closed)
+                        break;
+                    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;
+                        }
+                    }
+                }
+            }
+            // 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 {
+                    // 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,
+                    });
+                }
+            }
+            catch (err) {
+                if (!(err instanceof DOMException && err.name === "AbortError")) {
+                    display.error(err instanceof Error ? err.message : String(err));
+                }
+            }
+            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;
+            }
+            // 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 });
+            }
+            if (closed)
+                break;
+        }
+    }
+    finally {
+        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");
+        }
+    }
+    /* v8 ignore stop */
+    return { exitReason, toolResult: exitToolResult };
+}
 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)();
-    const registry = (0, commands_1.createCommandRegistry)();
-    (0, commands_1.registerDefaultCommands)(registry);
+    (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,
         channel: "cli",
     });
     const resolvedContext = await resolver.resolve();
-    const cliToolContext = {
-        /* v8 ignore next -- CLI has no OAuth sign-in; this no-op satisfies the interface @preserve */
-        signin: async () => undefined,
-        context: resolvedContext,
-        friendStore,
-        summarize: (0, core_1.createSummarize)(),
-    };
     const friendId = resolvedContext.friend.id;
     const agentConfig = (0, identity_1.loadAgentConfig)();
     (0, cli_logging_1.configureCliRuntimeLogger)(friendId, {
@@ -418,187 +977,139 @@ async function main(agentName, options) {
     }
     // Load existing session or start fresh
     const existing = (0, context_1.loadSession)(sessPath);
-    const messages = existing?.messages && existing.messages.length > 0
+    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) }];
-    // Pending queue drain: inject pending messages as harness-context + assistant-content pairs
-    const pendingDir = (0, pending_1.getPendingDir)((0, identity_1.getAgentName)(), friendId, "cli", "session");
-    const drainToMessages = () => {
-        const pending = (0, pending_1.drainPending)(pendingDir);
-        if (pending.length === 0)
-            return 0;
-        for (const msg of pending) {
-            messages.push({ role: "user", name: "harness", content: `[proactive message from ${msg.from}]` });
-            messages.push({ role: "assistant", content: msg.content });
-        }
-        return pending.length;
-    };
-    // Startup drain: deliver offline messages
-    const startupCount = drainToMessages();
-    if (startupCount > 0) {
-        (0, context_1.saveSession)(sessPath, messages);
-    }
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
-    const ctrl = new InputController(rl);
-    let currentAbort = null;
-    const history = [];
-    let closed = false;
-    rl.on("close", () => { closed = true; });
-    // eslint-disable-next-line no-console -- terminal UX: startup banner
-    console.log(`\n${(0, identity_1.getAgentName)()} (type /commands for help)\n`);
-    const cliCallbacks = createCliCallbacks();
-    process.stdout.write("\x1b[36m> \x1b[0m");
-    // Ctrl-C at the input prompt: clear line or warn/exit
-    // readline with terminal:true catches Ctrl-C in raw mode (no ^C echo)
-    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();
-        }
-    });
-    // Debounced line iterator: collects rapid-fire lines (paste) into a single input
-    async function* debouncedLines(source) {
-        if (pasteDebounceMs <= 0) {
-            yield* source;
-            return;
-        }
-        const iter = source[Symbol.asyncIterator]();
-        while (true) {
-            const first = await iter.next();
-            if (first.done)
-                break;
-            // Collect any lines that arrive within the debounce window (paste detection)
-            const lines = [first.value];
-            let more = true;
-            while (more) {
-                const raced = await Promise.race([
-                    iter.next().then((r) => ({ kind: "line", result: r })),
-                    new Promise((r) => setTimeout(() => r({ kind: "timeout" }), pasteDebounceMs)),
-                ]);
-                if (raced.kind === "timeout") {
-                    more = false;
-                }
-                else if (raced.result.done) {
-                    more = false;
-                }
-                else {
-                    lines.push(raced.result.value);
-                }
-            }
-            yield lines.join("\n");
-        }
-    }
+        : [{ 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, 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)("human");
+    const cliFailoverState = { pending: null };
     try {
-        for await (const input of debouncedLines(rl)) {
-            if (closed)
-                break;
-            if (!input.trim()) {
-                process.stdout.write("\x1b[36m> \x1b[0m");
-                continue;
-            }
-            const trustGate = (0, trust_gate_1.enforceTrustGate)({
-                friend: resolvedContext.friend,
-                provider: "local",
-                externalId: localExternalId,
-                channel: "cli",
-            });
-            if (!trustGate.allowed) {
-                if (trustGate.reason === "stranger_first_reply") {
-                    process.stdout.write(`${trustGate.autoReply}\n`);
+        await runCliSession({
+            agentName: currentAgentName,
+            pasteDebounceMs,
+            messages: sessionMessages,
+            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: userContent ?? userInput }],
+                    continuityIngressTexts: getCliContinuityIngressTexts(userInput),
+                    callbacks: failoverAwareCallbacks,
+                    friendResolver: { resolve: () => Promise.resolve(resolvedContext) },
+                    sessionLoader: {
+                        loadOrCreate: () => Promise.resolve({
+                            messages,
+                            sessionPath: sessPath,
+                            state: sessionState,
+                            events: sessionEvents,
+                            structuredOutputs: existing?.structuredOutputs,
+                        }),
+                    },
+                    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,
+                        },
+                    }),
+                    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: 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`);
                 }
-                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") });
-                        (0, context_1.deleteSession)(sessPath);
-                        // 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;
+                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`);
                     }
                 }
-            }
-            // Re-style the echoed input lines (readline terminal:true echoes each line)
-            // For multiline paste, each line was echoed separately — erase them all
-            const cols = process.stdout.columns || 80;
-            const inputLines = input.split("\n");
-            let echoRows = 0;
-            for (const line of inputLines) {
-                echoRows += Math.ceil((2 + line.length) / cols); // "> " prefix + line content
-            }
-            process.stdout.write(`\x1b[${echoRows}A\x1b[K` + `\x1b[1m> ${inputLines[0]}${inputLines.length > 1 ? ` (+${inputLines.length - 1} lines)` : ""}\x1b[0m\n\n`);
-            messages.push({ role: "user", content: input });
-            addHistory(history, input);
-            currentAbort = new AbortController();
-            const traceId = (0, nerves_1.createTraceId)();
-            ctrl.suppress(() => currentAbort.abort());
-            let result;
-            try {
-                result = await (0, core_1.runAgent)(messages, cliCallbacks, "cli", currentAbort.signal, {
-                    toolChoiceRequired: (0, commands_1.getToolChoiceRequired)(),
-                    toolContext: cliToolContext,
-                    traceId,
-                });
-            }
-            catch {
-                // AbortError — silently return to prompt
-            }
-            cliCallbacks.flushMarkdown();
-            ctrl.restore();
-            currentAbort = null;
-            // 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");
-            (0, context_1.postTurn)(messages, sessPath, result?.usage);
-            await (0, tokens_1.accumulateFriendTokens)(friendStore, resolvedContext.friend.id, result?.usage);
-            // Post-turn: drain any pending messages that arrived during runAgent
-            drainToMessages();
-            // Post-turn: refresh system prompt so active sessions metadata is current
-            await (0, prompt_refresh_1.refreshSystemPrompt)(messages, "cli", undefined, resolvedContext);
-            if (closed)
-                break;
-            process.stdout.write("\x1b[36m> \x1b[0m");
-        }
+                return { usage: result.usage, turnOutcome: result.turnOutcome, commandAction: result.commandAction };
+            },
+        });
     }
     finally {
         sessionLock?.release();
-        rl.close();
-        // eslint-disable-next-line no-console -- terminal UX: goodbye
-        console.log("bye");
     }
+    // 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