@ouro.bot/cli 0.1.0-alpha.174 → 0.1.0-alpha.176

package/dist/repertoire/tools-base.js

@@ -40,8 +40,11 @@ const fg = __importStar(require("fast-glob"));
 const child_process_1 = require("child_process");
 const path = __importStar(require("path"));
 const skills_1 = require("./skills");
+const shell_sessions_1 = require("./shell-sessions");
 const config_1 = require("../heart/config");
 const runtime_1 = require("../nerves/runtime");
+const file_state_1 = require("../mind/file-state");
+const scrutiny_1 = require("../mind/scrutiny");
 const identity_1 = require("../heart/identity");
 const identity_2 = require("../heart/identity");
 const socket_client_1 = require("../heart/daemon/socket-client");
@@ -337,7 +340,7 @@ exports.baseToolDefinitions = [
             type: "function",
             function: {
                 name: "read_file",
-                description: "read file contents",
+                description: "Read file contents. Results include line numbers. Use offset/limit for large files -- don't read the whole thing if you only need a section. Use this tool before editing any file. When reading code, read enough context to understand the surrounding logic, not just the target line.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -355,6 +358,17 @@ exports.baseToolDefinitions = [
             exports.editFileReadTracker.add(resolvedPath);
             const offset = a.offset ? parseInt(a.offset, 10) : undefined;
             const limit = a.limit ? parseInt(a.limit, 10) : undefined;
+            // Record in file state cache for staleness detection
+            try {
+                const mtime = fs.statSync(resolvedPath).mtimeMs;
+                const readContent = (offset === undefined && limit === undefined)
+                    ? content
+                    : content.split("\n").slice(offset ? offset - 1 : 0, limit !== undefined ? (offset ? offset - 1 : 0) + limit : undefined).join("\n");
+                file_state_1.fileStateCache.record(resolvedPath, readContent, mtime, offset, limit);
+            }
+            catch {
+                // stat failed -- skip cache recording
+            }
             if (offset === undefined && limit === undefined)
                 return content;
             const lines = content.split("\n");
@@ -369,7 +383,7 @@ exports.baseToolDefinitions = [
             type: "function",
             function: {
                 name: "write_file",
-                description: "write content to file",
+                description: "Prefer this tool for creating new files or fully replacing existing ones. You MUST read an existing file with read_file before overwriting it. Prefer edit_file for modifying existing files -- it only sends the diff. Do not create documentation files (*.md, README) by default; only do so when explicitly asked or when documentation is clearly part of the requested change.",
                 parameters: {
                     type: "object",
                     properties: { path: { type: "string" }, content: { type: "string" } },
@@ -381,7 +395,10 @@ exports.baseToolDefinitions = [
             const resolvedPath = resolveLocalToolPath(a.path);
             fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
             fs.writeFileSync(resolvedPath, a.content, "utf-8");
-            return "ok";
+            (0, scrutiny_1.trackModifiedFile)(resolvedPath);
+            const scrutiny = (0, scrutiny_1.getPostImplementationScrutiny)((0, scrutiny_1.getModifiedFileCount)());
+            /* v8 ignore next -- scrutiny appendix branch depends on session-level file count @preserve */
+            return scrutiny ? `ok\n\n${scrutiny}` : "ok";
         },
         summaryKeys: ["path"],
     },
@@ -390,7 +407,7 @@ exports.baseToolDefinitions = [
             type: "function",
             function: {
                 name: "edit_file",
-                description: "surgically edit a file by replacing an exact string. the file must have been read via read_file first. old_string must match exactly one location in the file.",
+                description: "Surgically edit a file by replacing an exact string. The file MUST have been read via read_file first -- this tool will reject the call otherwise. old_string must match EXACTLY ONE location in the file -- if it matches zero or multiple, the edit fails. To fix: provide more surrounding context to make the match unique. Preserve exact indentation (tabs/spaces) from the file. Prefer this over write_file for modifications -- it only sends the diff.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -407,6 +424,8 @@ exports.baseToolDefinitions = [
             if (!exports.editFileReadTracker.has(resolvedPath)) {
                 return `error: you must read the file with read_file before editing it. call read_file on ${a.path} first.`;
             }
+            // Check staleness before editing
+            const stalenessCheck = file_state_1.fileStateCache.isStale(resolvedPath);
             let content;
             try {
                 content = fs.readFileSync(resolvedPath, "utf-8");
@@ -434,13 +453,33 @@ exports.baseToolDefinitions = [
             const idx = occurrences[0];
             const updated = content.slice(0, idx) + a.new_string + content.slice(idx + a.old_string.length);
             fs.writeFileSync(resolvedPath, updated, "utf-8");
+            // Update file state cache with new content
+            try {
+                const newMtime = fs.statSync(resolvedPath).mtimeMs;
+                file_state_1.fileStateCache.record(resolvedPath, updated, newMtime);
+            }
+            catch {
+                // stat failed -- skip cache update
+            }
             // Build contextual diff
             const lines = updated.split("\n");
             const prefixLines = content.slice(0, idx).split("\n");
             const changeStartLine = prefixLines.length - 1;
             const newStringLines = a.new_string.split("\n");
             const changeEndLine = changeStartLine + newStringLines.length;
-            return buildContextDiff(lines, changeStartLine, changeEndLine);
+            const diffResult = buildContextDiff(lines, changeStartLine, changeEndLine);
+            // Track modified file and compute scrutiny appendix
+            (0, scrutiny_1.trackModifiedFile)(resolvedPath);
+            const scrutiny = (0, scrutiny_1.getPostImplementationScrutiny)((0, scrutiny_1.getModifiedFileCount)());
+            // Append staleness warning if detected (do not block -- TTFA)
+            /* v8 ignore start -- staleness+diff+scrutiny combo not exercised in integration tests @preserve */
+            if (stalenessCheck.stale) {
+                const base = `${diffResult}\n\n⚠️ warning: file changed externally since last read -- re-read recommended`;
+                return scrutiny ? `${base}\n\n${scrutiny}` : base;
+            }
+            /* v8 ignore stop */
+            /* v8 ignore next -- scrutiny appendix branch depends on session-level file count @preserve */
+            return scrutiny ? `${diffResult}\n\n${scrutiny}` : diffResult;
         },
         summaryKeys: ["path"],
     },
@@ -449,7 +488,7 @@ exports.baseToolDefinitions = [
             type: "function",
             function: {
                 name: "glob",
-                description: "find files matching a glob pattern. returns matching paths sorted alphabetically, one per line.",
+                description: "Find files matching a glob pattern, sorted alphabetically. Use this instead of shell commands like `find` or `ls`. For broad exploratory searches that would require multiple rounds of globbing and grepping, consider using claude or coding_spawn.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -472,7 +511,7 @@ exports.baseToolDefinitions = [
             type: "function",
             function: {
                 name: "grep",
-                description: "search file contents for lines matching a regex pattern. searches recursively when given a directory. returns matching lines with file path and line numbers.",
+                description: "Search file contents for lines matching a regex pattern. Searches recursively in directories. Use this instead of shell commands like `grep` or `rg`. Returns matching lines with file path and line numbers. Use context_lines for surrounding context. Use include to filter file types (e.g., '*.ts').",
                 parameters: {
                     type: "object",
                     properties: {
@@ -581,22 +620,112 @@ exports.baseToolDefinitions = [
             type: "function",
             function: {
                 name: "shell",
-                description: "run shell command",
+                description: "Run a shell command and return stdout/stderr. Working directory persists between calls. Use dedicated tools instead of shell when available: read_file instead of cat, edit_file instead of sed, glob instead of find, grep instead of grep/rg. Reserve shell for operations that genuinely need the shell: installing packages, running builds/tests, git operations, process management. Be careful with destructive commands -- consider reversibility before running. If a command fails, read the error output before retrying with a different approach.",
                 parameters: {
                     type: "object",
-                    properties: { command: { type: "string" } },
+                    properties: {
+                        command: { type: "string" },
+                        timeout_ms: {
+                            type: "number",
+                            description: "Timeout in milliseconds. Default: 30000. Max: 600000.",
+                        },
+                        background: {
+                            type: "boolean",
+                            description: "Run in background. Returns immediately with a process ID. Use shell_status/shell_tail to monitor.",
+                        },
+                    },
                     required: ["command"],
                 },
             },
         },
         handler: (a) => {
-            return (0, child_process_1.execSync)(a.command, {
+            // Destructive pattern detection (friction, not a block)
+            const destructivePatterns = (0, shell_sessions_1.detectDestructivePatterns)(a.command);
+            if (destructivePatterns.length > 0) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    event: "tool.shell.destructive_detected",
+                    component: "tools",
+                    message: `destructive pattern detected: ${destructivePatterns.join(", ")}`,
+                    meta: { command: a.command, patterns: destructivePatterns },
+                });
+            }
+            // Background mode: spawn and return immediately
+            if (a.background === "true") {
+                const session = (0, shell_sessions_1.spawnBackgroundShell)(a.command);
+                return JSON.stringify({ id: session.id, command: session.command, status: session.status });
+            }
+            const MAX_TIMEOUT = 600000;
+            const requestedTimeout = Number(a.timeout_ms) || 0;
+            let configDefault = 30000;
+            try {
+                configDefault = (0, identity_1.loadAgentConfig)().shell?.defaultTimeout ?? 30000;
+            }
+            catch { /* test env: no --agent flag */ }
+            const baseTimeout = requestedTimeout > 0 ? requestedTimeout : configDefault;
+            const timeout = Math.min(baseTimeout, MAX_TIMEOUT);
+            const output = (0, child_process_1.execSync)(a.command, {
                 encoding: "utf-8",
-                timeout: 30000,
+                timeout,
             });
+            if (destructivePatterns.length > 0) {
+                return `${output}\n\n--- destructive pattern detected: ${destructivePatterns.join(", ")} ---`;
+            }
+            return output;
         },
         summaryKeys: ["command"],
     },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "shell_status",
+                description: "Check status of background shell processes. Omit id to list all.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        id: { type: "string", description: "Background shell process ID" },
+                    },
+                },
+            },
+        },
+        handler: (a) => {
+            if (!a.id) {
+                return JSON.stringify((0, shell_sessions_1.listShellSessions)());
+            }
+            const session = (0, shell_sessions_1.getShellSession)(a.id);
+            if (!session)
+                return `process not found: ${a.id}`;
+            return JSON.stringify(session);
+        },
+        summaryKeys: ["id"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "shell_tail",
+                description: "Show recent output from a background shell process.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        id: { type: "string", description: "Background shell process ID" },
+                    },
+                    required: ["id"],
+                },
+            },
+        },
+        handler: (a) => {
+            /* v8 ignore next -- schema requires id, defensive guard @preserve */
+            if (!a.id)
+                return "id is required";
+            const output = (0, shell_sessions_1.tailShellSession)(a.id);
+            if (output === undefined)
+                return `process not found: ${a.id}`;
+            return output || "(no output yet)";
+        },
+        summaryKeys: ["id"],
+    },
     {
         tool: {
             type: "function",
@@ -636,7 +765,7 @@ exports.baseToolDefinitions = [
             type: "function",
             function: {
                 name: "claude",
-                description: "use claude code to query this codebase or get an outside perspective. useful for code review, second opinions, and asking questions about your own source.",
+                description: "use claude code to query this codebase or get an outside perspective. Use for code review, second opinions, or questions that benefit from a fresh perspective outside this conversation's context.",
                 parameters: {
                     type: "object",
                     properties: { prompt: { type: "string" } },
@@ -709,7 +838,7 @@ exports.baseToolDefinitions = [
             type: "function",
             function: {
                 name: "recall",
-                description: "recall what i know — search my diary and journal for facts, thoughts, and working notes that match a query",
+                description: "Search my diary and journal for facts, thoughts, and working notes matching a query. Uses semantic similarity -- phrasing matters. Try different angles if the first query doesn't find what you're looking for. Check recall before asking the human something you might already know.",
                 parameters: {
                     type: "object",
                     properties: { query: { type: "string" } },
@@ -762,7 +891,7 @@ exports.baseToolDefinitions = [
             type: "function",
             function: {
                 name: "diary_write",
-                description: "write an entry in my diary — something i learned, noticed, or concluded that i want to recall later. optional 'about' tags the entry to a person, topic, or context.",
+                description: "Write an entry in my diary -- something I learned, noticed, or concluded that I want to recall later. Use 'about' to tag the entry to a person, topic, or context. Write for my future self: include enough context that the entry makes sense without the surrounding conversation. Prefer durable conclusions over passing noise. Don't duplicate what already belongs in friend notes.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -1376,7 +1505,7 @@ exports.ponderTool = {
     type: "function",
     function: {
         name: "ponder",
-        description: "i need to sit with this. from a conversation, takes the thread inward with a thought and a parting word. from inner dialog, keeps the wheel turning for another pass. must be the only tool call in the turn.",
+        description: "i need to sit with this. from a conversation, takes the thread inward with a thought and a parting word. from inner dialog, keeps the wheel turning for another pass. must be the only tool call in the turn. Use when a question deserves more thought than this turn allows. Don't ponder trivial questions.",
         parameters: {
             type: "object",
             properties: {
@@ -1409,7 +1538,7 @@ exports.settleTool = {
     type: "function",
     function: {
         name: "settle",
-        description: "respond to the user with your message. call this tool when you are ready to deliver your response.",
+        description: "respond to the user with your message. call this tool when you are ready to deliver your response. Only call when you have a substantive response. If you're settling with 'I'll look into that,' you probably should be using a tool instead.",
         parameters: {
             type: "object",
             properties: {

package/dist/repertoire/tools.js

@@ -38,6 +38,7 @@ exports.getToolsForChannel = getToolsForChannel;
 exports.isConfirmationRequired = isConfirmationRequired;
 exports.execTool = execTool;
 exports.summarizeArgs = summarizeArgs;
+exports.buildToolResultSummary = buildToolResultSummary;
 const tools_base_1 = require("./tools-base");
 const tools_teams_1 = require("./tools-teams");
 const tools_bluebubbles_1 = require("./tools-bluebubbles");
@@ -387,3 +388,39 @@ function summarizeArgs(name, args) {
     }
     return summarizeUnknownArgs(args);
 }
+/**
+ * Build an enriched tool result summary for display on remote channels.
+ * For recognized tools, includes result-derived info (diff stats, exit codes, etc.).
+ * Falls back to arg-based summary for unrecognized tools.
+ */
+function buildToolResultSummary(name, args, _result, success) {
+    switch (name) {
+        case "edit_file": {
+            if (!success)
+                return summarizeArgs(name, args);
+            const addedLines = (args.new_string ?? "").split("\n").length;
+            const removedLines = (args.old_string ?? "").split("\n").length;
+            return `+${addedLines} -${removedLines} lines in ${args.path ?? "unknown"}`;
+        }
+        case "shell": {
+            const cmd = args.command ?? "?";
+            const exitCode = success ? 0 : 1;
+            return `$ ${cmd} (exit ${exitCode})`;
+        }
+        case "read_file":
+            return `path=${args.path ?? "unknown"}`;
+        case "write_file":
+            return `path=${args.path ?? "unknown"}`;
+        case "glob":
+            return `pattern=${args.pattern ?? "?"} ${args.cwd ? `cwd=${args.cwd}` : ""}`.trim();
+        case "grep":
+            return `pattern=${args.pattern ?? "?"} ${args.path ? `path=${args.path}` : ""}`.trim();
+        case "coding_spawn": {
+            const taskRef = args.taskRef ?? "unknown";
+            const status = success ? "spawned" : "failed";
+            return `${taskRef} -> ${status}`;
+        }
+        default:
+            return summarizeArgs(name, args);
+    }
+}

package/dist/senses/cli/adapter.js

@@ -0,0 +1,307 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliStore = void 0;
+exports.createInkCallbacks = createInkCallbacks;
+exports.InkCliApp = InkCliApp;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = __importStar(require("react"));
+const ink_1 = require("ink");
+const streaming_markdown_1 = require("./streaming-markdown");
+const spinner_1 = require("./spinner");
+const tool_render_1 = require("./tool-render");
+const phrases_1 = require("../../mind/phrases");
+const format_1 = require("../../mind/format");
+const runtime_1 = require("../../nerves/runtime");
+/**
+ * Ink CLI Adapter — bridges RunCliSessionOptions with Ink/React rendering.
+ *
+ * Architecture:
+ * - CliStore: mutable external state, updated by callbacks
+ * - InkCliApp: reads from store via subscription, renders Ink components
+ * - createInkCallbacks: returns ChannelCallbacks that update the store
+ *
+ * The business logic (runAgent, pipeline, commands) stays unchanged.
+ * Only the rendering layer is replaced: readline -> Ink.
+ */
+// Ouroboros brand palette
+const OURO_GREEN = "#2ecc40";
+const OURO_TEAL = "#4ec9b0";
+/**
+ * Mutable external store. Callbacks mutate state; React subscribes via
+ * useSyncExternalStore pattern (simplified: we use a version counter +
+ * forceUpdate in the component).
+ */
+class CliStore {
+    state = {
+        streamingText: "",
+        loading: false,
+        spinnerPhrase: "",
+        activeTool: null,
+        toolResults: [],
+        errorMessage: null,
+        kickMessage: null,
+        inputSuppressed: false,
+        bannerLines: [],
+    };
+    listeners = new Set();
+    spinnerStartTime = 0;
+    hadToolRun = false;
+    getState() {
+        return this.state;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    notify() {
+        for (const fn of this.listeners)
+            fn();
+    }
+    // ─── Mutation methods called by callbacks ───
+    modelStart() {
+        const phrases = (0, phrases_1.getPhrases)();
+        const pool = this.hadToolRun ? phrases.followup : phrases.thinking;
+        const first = (0, phrases_1.pickPhrase)(pool);
+        this.state = {
+            ...this.state,
+            loading: true,
+            spinnerPhrase: first,
+            streamingText: "",
+            activeTool: null,
+            toolResults: [],
+            errorMessage: null,
+            kickMessage: null,
+        };
+        this.spinnerStartTime = Date.now();
+        this.notify();
+    }
+    clearText() {
+        this.state = { ...this.state, streamingText: "" };
+        this.notify();
+    }
+    appendText(text) {
+        this.state = {
+            ...this.state,
+            loading: false,
+            streamingText: this.state.streamingText + text,
+        };
+        this.notify();
+    }
+    toolStart(name, args) {
+        this.hadToolRun = true;
+        this.state = {
+            ...this.state,
+            loading: true,
+            activeTool: { name, args },
+            spinnerPhrase: (0, phrases_1.pickPhrase)((0, phrases_1.getPhrases)().tool),
+        };
+        this.spinnerStartTime = Date.now();
+        this.notify();
+    }
+    toolEnd(name, argSummary, success) {
+        this.state = {
+            ...this.state,
+            loading: false,
+            activeTool: null,
+            toolResults: [...this.state.toolResults, { name, argSummary, success }],
+        };
+        this.notify();
+    }
+    setError(message) {
+        this.state = { ...this.state, loading: false, errorMessage: message };
+        this.notify();
+    }
+    setKick() {
+        this.state = { ...this.state, loading: false, kickMessage: (0, format_1.formatKick)() };
+        this.notify();
+    }
+    suppressInput() {
+        this.state = { ...this.state, inputSuppressed: true };
+        this.notify();
+    }
+    restoreInput() {
+        this.state = { ...this.state, inputSuppressed: false };
+        this.notify();
+    }
+    /** Flush streaming state at end of turn */
+    endTurn() {
+        this.state = {
+            ...this.state,
+            loading: false,
+            activeTool: null,
+            errorMessage: null,
+            kickMessage: null,
+        };
+        this.notify();
+    }
+    setBanner(lines) {
+        this.state = { ...this.state, bannerLines: lines };
+        this.notify();
+    }
+    getElapsedSeconds() {
+        if (!this.state.loading)
+            return 0;
+        return Math.floor((Date.now() - this.spinnerStartTime) / 1000);
+    }
+}
+exports.CliStore = CliStore;
+// ─── Callbacks factory ─────────────────────────────────────────────
+function createInkCallbacks(store) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.cli_callbacks_created",
+        message: "ink cli callbacks created",
+        meta: {},
+    });
+    return {
+        onModelStart: () => { store.modelStart(); },
+        onModelStreamStart: () => { },
+        onClearText: () => { store.clearText(); },
+        onTextChunk: (text) => { store.appendText(text); },
+        onReasoningChunk: (_text) => { },
+        onToolStart: (name, args) => { store.toolStart(name, args); },
+        onToolEnd: (name, argSummary, success) => { store.toolEnd(name, argSummary, success); },
+        onError: (error, severity) => {
+            if (severity === "transient") {
+                store.setError(error.message);
+            }
+            else {
+                store.setError((0, format_1.formatError)(error));
+            }
+        },
+        onKick: () => { store.setKick(); },
+        flushMarkdown: () => { store.endTurn(); },
+    };
+}
+// ─── Input Area ────────────────────────────────────────────────────
+function InputArea({ onSubmit, suppressed, }) {
+    const [input, setInput] = (0, react_1.useState)("");
+    const inputRef = (0, react_1.useRef)("");
+    const [history, setHistory] = (0, react_1.useState)([]);
+    const historyIdx = (0, react_1.useRef)(-1);
+    (0, ink_1.useInput)((inputChar, key) => {
+        if (suppressed)
+            return;
+        if (key.return) {
+            const text = inputRef.current;
+            if (text.trim()) {
+                onSubmit(text);
+                setHistory(prev => {
+                    const next = [...prev, text];
+                    return next;
+                });
+                historyIdx.current = -1;
+            }
+            inputRef.current = "";
+            setInput("");
+            return;
+        }
+        if (key.backspace || key.delete) {
+            inputRef.current = inputRef.current.slice(0, -1);
+            setInput(inputRef.current);
+            return;
+        }
+        // History navigation
+        if (key.upArrow) {
+            if (history.length > 0) {
+                const idx = historyIdx.current < 0 ? history.length - 1 : Math.max(0, historyIdx.current - 1);
+                historyIdx.current = idx;
+                inputRef.current = history[idx];
+                setInput(history[idx]);
+            }
+            return;
+        }
+        if (key.downArrow) {
+            if (historyIdx.current >= 0) {
+                const idx = historyIdx.current + 1;
+                if (idx >= history.length) {
+                    historyIdx.current = -1;
+                    inputRef.current = "";
+                    setInput("");
+                }
+                else {
+                    historyIdx.current = idx;
+                    inputRef.current = history[idx];
+                    setInput(history[idx]);
+                }
+            }
+            return;
+        }
+        if (!key.ctrl && !key.meta && inputChar) {
+            inputRef.current += inputChar;
+            setInput(inputRef.current);
+        }
+    });
+    if (suppressed) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" });
+    }
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_TEAL, bold: true, children: ") " }), (0, jsx_runtime_1.jsx)(ink_1.Text, { children: input })] }));
+}
+function InkCliApp({ store, onSubmit, onExit }) {
+    const { exit } = (0, ink_1.useApp)();
+    const [, forceUpdate] = (0, react_1.useState)(0);
+    const [elapsed, setElapsed] = (0, react_1.useState)(0);
+    // Subscribe to store changes
+    (0, react_1.useEffect)(() => {
+        return store.subscribe(() => {
+            forceUpdate(n => n + 1);
+        });
+    }, [store]);
+    // Elapsed timer for spinner
+    (0, react_1.useEffect)(() => {
+        const iv = setInterval(() => {
+            setElapsed(store.getElapsedSeconds());
+        }, 1000);
+        return () => clearInterval(iv);
+    }, [store]);
+    // Ctrl-C handling
+    (0, ink_1.useInput)((_input, key) => {
+        if (key.ctrl && _input === "c") {
+            if (onExit) {
+                onExit();
+            }
+            else {
+                exit();
+            }
+        }
+    });
+    const state = store.getState();
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [state.bannerLines.length > 0 ? ((0, jsx_runtime_1.jsx)(ink_1.Box, { flexDirection: "column", children: state.bannerLines.map((line, i) => ((0, jsx_runtime_1.jsx)(ink_1.Text, { children: line }, i))) })) : null, state.streamingText ? ((0, jsx_runtime_1.jsx)(streaming_markdown_1.StreamingMarkdown, { text: state.streamingText })) : null, state.toolResults.map((tr, i) => {
+                const color = tr.success ? OURO_GREEN : "#e74c3c";
+                const icon = tr.success ? "\u2713" : "\u2717";
+                return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsxs)(ink_1.Text, { color: color, children: [icon, " "] }), (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_TEAL, bold: true, children: tr.name }), (0, jsx_runtime_1.jsxs)(ink_1.Text, { dimColor: true, children: [" ", tr.argSummary] })] }, i));
+            }), state.activeTool ? ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsx)(tool_render_1.ToolBadge, { name: state.activeTool.name }), (0, jsx_runtime_1.jsx)(tool_render_1.ToolParams, { name: state.activeTool.name, args: state.activeTool.args })] })) : null, state.loading ? ((0, jsx_runtime_1.jsx)(spinner_1.EnhancedSpinner, { elapsedSeconds: elapsed, phrase: state.spinnerPhrase })) : null, state.errorMessage ? ((0, jsx_runtime_1.jsx)(ink_1.Text, { color: "#e74c3c", children: state.errorMessage })) : null, state.kickMessage ? ((0, jsx_runtime_1.jsx)(ink_1.Text, { color: "#f39c12", children: state.kickMessage })) : null, (0, jsx_runtime_1.jsx)(InputArea, { onSubmit: onSubmit, suppressed: state.inputSuppressed })] }));
+}