@ouro.bot/cli 0.1.0-alpha.55 → 0.1.0-alpha.551

package/dist/senses/{bluebubbles-runtime-state.js → bluebubbles/runtime-state.js}

@@ -38,8 +38,8 @@ exports.readBlueBubblesRuntimeState = readBlueBubblesRuntimeState;
 exports.writeBlueBubblesRuntimeState = writeBlueBubblesRuntimeState;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const identity_1 = require("../heart/identity");
-const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
 const DEFAULT_RUNTIME_STATE = {
     upstreamStatus: "unknown",
     detail: "startup health probe pending",
@@ -53,6 +53,9 @@ function readBlueBubblesRuntimeState(agentName, agentRoot) {
     try {
         const raw = fs.readFileSync(filePath, "utf-8");
         const parsed = JSON.parse(raw);
+        const failedRecoveryCount = typeof parsed.failedRecoveryCount === "number" && Number.isFinite(parsed.failedRecoveryCount)
+            ? parsed.failedRecoveryCount
+            : undefined;
         return {
             upstreamStatus: parsed.upstreamStatus === "ok" || parsed.upstreamStatus === "error"
                 ? parsed.upstreamStatus
@@ -61,9 +64,31 @@ function readBlueBubblesRuntimeState(agentName, agentRoot) {
                 ? parsed.detail
                 : DEFAULT_RUNTIME_STATE.detail,
             lastCheckedAt: typeof parsed.lastCheckedAt === "string" ? parsed.lastCheckedAt : undefined,
+            proofMethod: typeof parsed.proofMethod === "string" && parsed.proofMethod.trim()
+                ? parsed.proofMethod
+                : undefined,
             pendingRecoveryCount: typeof parsed.pendingRecoveryCount === "number" && Number.isFinite(parsed.pendingRecoveryCount)
                 ? parsed.pendingRecoveryCount
                 : 0,
+            ...(typeof failedRecoveryCount === "number" ? { failedRecoveryCount } : {}),
+            oldestPendingRecoveryAt: typeof parsed.oldestPendingRecoveryAt === "string"
+                ? parsed.oldestPendingRecoveryAt
+                : undefined,
+            oldestPendingRecoveryAgeMs: typeof parsed.oldestPendingRecoveryAgeMs === "number" && Number.isFinite(parsed.oldestPendingRecoveryAgeMs)
+                ? parsed.oldestPendingRecoveryAgeMs
+                : undefined,
+            activeTurnCount: typeof parsed.activeTurnCount === "number" && Number.isFinite(parsed.activeTurnCount)
+                ? parsed.activeTurnCount
+                : undefined,
+            stalledTurnCount: typeof parsed.stalledTurnCount === "number" && Number.isFinite(parsed.stalledTurnCount)
+                ? parsed.stalledTurnCount
+                : undefined,
+            oldestActiveTurnStartedAt: typeof parsed.oldestActiveTurnStartedAt === "string"
+                ? parsed.oldestActiveTurnStartedAt
+                : undefined,
+            oldestActiveTurnAgeMs: typeof parsed.oldestActiveTurnAgeMs === "number" && Number.isFinite(parsed.oldestActiveTurnAgeMs)
+                ? parsed.oldestActiveTurnAgeMs
+                : undefined,
             lastRecoveredAt: typeof parsed.lastRecoveredAt === "string" ? parsed.lastRecoveredAt : undefined,
             lastRecoveredMessageGuid: typeof parsed.lastRecoveredMessageGuid === "string"
                 ? parsed.lastRecoveredMessageGuid
@@ -102,6 +127,9 @@ function writeBlueBubblesRuntimeState(agentName, state, agentRoot) {
             agentName,
             upstreamStatus: state.upstreamStatus,
             pendingRecoveryCount: state.pendingRecoveryCount,
+            failedRecoveryCount: state.failedRecoveryCount ?? 0,
+            activeTurnCount: state.activeTurnCount ?? 0,
+            stalledTurnCount: state.stalledTurnCount ?? 0,
             path: filePath,
         },
     });

package/dist/senses/{bluebubbles-session-cleanup.js → bluebubbles/session-cleanup.js}

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findObsoleteBlueBubblesThreadSessions = findObsoleteBlueBubblesThreadSessions;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const runtime_1 = require("../nerves/runtime");
+const runtime_1 = require("../../nerves/runtime");
 function findObsoleteBlueBubblesThreadSessions(trunkSessionPath) {
     const normalized = trunkSessionPath.trim();
     if (!normalized.endsWith(".json"))

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

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

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

@@ -0,0 +1,287 @@
+"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.IMAGE_EXTENSION_REGEX = void 0;
+exports.isImagePath = isImagePath;
+exports.unescapePath = unescapePath;
+exports.tryReadImage = tryReadImage;
+exports.formatImageRef = formatImageRef;
+exports.replacePathsWithRefs = replacePathsWithRefs;
+exports.processSubmitInput = processSubmitInput;
+exports.resolveImageContent = resolveImageContent;
+/**
+ * Image paste detection and resolution for the TUI.
+ *
+ * When a user drags an image file onto the terminal, macOS pastes the absolute
+ * path (often with backslash-escaped spaces). This module detects image paths
+ * in the input text, replaces them with `[Image #N]` references, reads the
+ * files, registers them as shared attachments, and produces OpenAI-compatible
+ * `image_url` content blocks.
+ */
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("fs/promises");
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../../heart/identity");
+const render_1 = require("../../heart/attachments/render");
+const store_1 = require("../../heart/attachments/store");
+const materialize_1 = require("../../heart/attachments/materialize");
+const cli_local_file_1 = require("../../heart/attachments/sources/cli-local-file");
+/** Matches image file extensions (case-insensitive) */
+exports.IMAGE_EXTENSION_REGEX = /\.(png|jpe?g|gif|webp)$/i;
+/** Check whether a string (possibly backslash-escaped) ends with an image extension */
+function isImagePath(str) {
+    return exports.IMAGE_EXTENSION_REGEX.test(unescapePath(str));
+}
+/** Strip shell escape backslashes from a path (macOS/Linux drag-drop format) */
+function unescapePath(str) {
+    // Handle double-backslashes first (actual backslash in filename)
+    // then remove single escape backslashes
+    return str.replace(/\\(.)/g, "$1");
+}
+/** Detect temp screenshot paths from macOS screencapture */
+const TEMP_SCREENSHOT_RE = /\/TemporaryItems\/.*screencaptureui.*\/Screenshot/i;
+/** Map file extension to MIME media type */
+function extensionToMediaType(ext) {
+    switch (ext.toLowerCase()) {
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".png":
+            return "image/png";
+        case ".gif":
+            return "image/gif";
+        case ".webp":
+            return "image/webp";
+        default:
+            return "image/png";
+    }
+}
+/**
+ * Read an image file and return base64 + media type.
+ * Falls back to clipboard for temp screenshot paths (macOS screencapture
+ * creates ephemeral files in TemporaryItems that are cleaned up quickly).
+ * Returns null on any error.
+ */
+async function tryReadImage(absolutePath) {
+    // Try reading the file directly first
+    try {
+        const buffer = await (0, promises_1.readFile)(absolutePath);
+        if (buffer.length > 0) {
+            const ext = path.extname(absolutePath);
+            return {
+                buffer: Buffer.from(buffer),
+                base64: Buffer.from(buffer).toString("base64"),
+                mediaType: extensionToMediaType(ext),
+                fromClipboard: false,
+            };
+        }
+    }
+    catch {
+        // File not found or permission denied — try clipboard fallback
+    }
+    // Clipboard fallback for macOS temp screenshots
+    /* v8 ignore start -- clipboard fallback requires real macOS screencapture @preserve */
+    if (process.platform === "darwin" && TEMP_SCREENSHOT_RE.test(absolutePath)) {
+        const clipboardImage = await getImageFromClipboard();
+        if (clipboardImage)
+            return clipboardImage;
+    }
+    /* v8 ignore stop */
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.image_read_error",
+        message: `Failed to read image: ${absolutePath}`,
+        meta: { path: absolutePath },
+    });
+    return null;
+}
+/**
+ * Read image data from macOS clipboard via osascript.
+ * Used as fallback when temp screenshot files are already cleaned up.
+ */
+/* v8 ignore start -- macOS clipboard integration @preserve */
+async function getImageFromClipboard() {
+    const tmpPath = "/tmp/ouro_clipboard_image.png";
+    try {
+        // Check if clipboard has image data
+        (0, child_process_1.execFileSync)("osascript", ["-e", "the clipboard as «class PNGf»"], { stdio: "pipe" });
+        // Save clipboard image to temp file
+        (0, child_process_1.execFileSync)("osascript", [
+            "-e", "set png_data to (the clipboard as «class PNGf»)",
+            "-e", `set fp to open for access POSIX file "${tmpPath}" with write permission`,
+            "-e", "write png_data to fp",
+            "-e", "close access fp",
+        ], { stdio: "pipe" });
+        const buffer = await (0, promises_1.readFile)(tmpPath);
+        void (0, promises_1.unlink)(tmpPath).catch(() => { });
+        if (buffer.length === 0)
+            return null;
+        return {
+            buffer: Buffer.from(buffer),
+            base64: Buffer.from(buffer).toString("base64"),
+            mediaType: "image/png",
+            fromClipboard: true,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/* v8 ignore stop */
+/** Format an image reference placeholder */
+function formatImageRef(n) {
+    return `[Image #${n}]`;
+}
+/**
+ * Scan input for absolute image file paths and replace with [Image #N] references.
+ * Handles backslash-escaped characters (macOS drag-drop) and paths with spaces.
+ */
+function replacePathsWithRefs(input) {
+    const images = new Map();
+    // Match absolute paths: start with /, contain non-whitespace or backslash-escaped chars,
+    // end with an image extension. The (?:\\.|\S) alternation allows `\ ` sequences.
+    const pathRegex = /(?:\/(?:\\.|[^\s])+\.(?:png|jpe?g|gif|webp))/gi;
+    let counter = 0;
+    const text = input.replace(pathRegex, (match) => {
+        counter++;
+        images.set(counter, unescapePath(match));
+        return formatImageRef(counter);
+    });
+    return { text, images };
+}
+/**
+ * Process submit input: detect image paths, replace with refs, return map.
+ * This is the entry point called by InputArea on submit.
+ */
+function processSubmitInput(text) {
+    return replacePathsWithRefs(text);
+}
+function extensionForMediaType(mediaType) {
+    switch (mediaType) {
+        case "image/jpeg":
+            return ".jpg";
+        case "image/gif":
+            return ".gif";
+        case "image/webp":
+            return ".webp";
+        default:
+            return ".png";
+    }
+}
+async function pathExists(targetPath) {
+    try {
+        await (0, promises_1.access)(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function persistClipboardImage(agentRoot, originalPath, image) {
+    const hash = (0, node_crypto_1.createHash)("sha1").update(originalPath).digest("hex").slice(0, 16);
+    const targetPath = path.join(agentRoot, "state", "attachments", "imports", "cli", `${hash}${extensionForMediaType(image.mediaType)}`);
+    await (0, promises_1.mkdir)(path.dirname(targetPath), { recursive: true });
+    await (0, promises_1.writeFile)(targetPath, image.buffer);
+    return targetPath;
+}
+/**
+ * Build OpenAI content parts from text + image map.
+ * For each image in the map, reads the file and creates an `image_url` content part.
+ * Images that fail to read are silently skipped.
+ * Returns `[{ type: "text", text }]` when no images resolve.
+ */
+async function resolveImageContent(text, images) {
+    if (images.size === 0) {
+        return [{ type: "text", text }];
+    }
+    const agentName = (0, identity_1.getAgentName)();
+    const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+    const parts = [];
+    const cachedAttachments = [];
+    // Read all images in parallel
+    const entries = Array.from(images.entries());
+    const results = await Promise.all(entries.map(async ([, absolutePath]) => {
+        const image = await tryReadImage(absolutePath);
+        if (!image)
+            return null;
+        const sourcePath = image.fromClipboard || !await pathExists(absolutePath)
+            ? await persistClipboardImage(agentRoot, absolutePath, image)
+            : absolutePath;
+        const attachment = (0, store_1.cacheRecentAttachment)(agentName, (0, cli_local_file_1.buildCliLocalFileAttachmentRecord)({
+            path: sourcePath,
+            mimeType: image.mediaType,
+            byteCount: image.buffer.length,
+        }), agentRoot);
+        cachedAttachments.push(attachment);
+        try {
+            const materialized = await (0, materialize_1.materializeAttachment)(agentName, attachment.id, {
+                agentRoot,
+                variant: "vision_safe",
+            });
+            const normalizedBuffer = await (0, promises_1.readFile)(materialized.path);
+            return {
+                attachment,
+                mediaType: materialized.mimeType ?? image.mediaType,
+                base64: Buffer.from(normalizedBuffer).toString("base64"),
+            };
+        }
+        catch {
+            return {
+                attachment,
+                mediaType: image.mediaType,
+                base64: image.base64,
+            };
+        }
+    }));
+    for (const result of results) {
+        if (result) {
+            parts.push({
+                type: "image_url",
+                image_url: { url: `data:${result.mediaType};base64,${result.base64}` },
+            });
+        }
+    }
+    // Always include the text part
+    const attachmentBlock = (0, render_1.renderAttachmentBlock)(cachedAttachments);
+    const textWithAttachments = [text, attachmentBlock].filter(Boolean).join("\n");
+    parts.push({ type: "text", text: textWithAttachments || text });
+    // If no images resolved, return just text
+    if (parts.length === 1) {
+        return [{ type: "text", text }];
+    }
+    return parts;
+}

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

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

package/dist/senses/cli/ink-app.js

@@ -0,0 +1,156 @@
+"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.InkApp = InkApp;
+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");
+/**
+ * Ouroboros CLI TUI — Ink application shell.
+ *
+ * Replaces the imperative readline-based CLI with a React/Ink component tree.
+ * Provides: message list, input area, spinner, tool result display.
+ *
+ * Design: Ouroboros-themed (green serpent), NOT Claude/Anthropic design language.
+ * Copy-paste integrity: no padding characters. Visual hierarchy via color/bold/dim only.
+ */
+// Ouroboros brand palette
+const OURO_GREEN = "#2ecc40";
+const OURO_TEAL = "#4ec9b0";
+const OURO_DIM = true;
+// Snake-themed spinner frames: serpent eating its own tail
+const SNAKE_FRAMES = [
+    "\u{1F40D}\u2003", // snake emoji
+    "\u25E0\u2003", // upper half circle
+    "\u25D4\u2003", // circle with upper right quadrant
+    "\u25D1\u2003", // circle with right half
+    "\u25D5\u2003", // circle with all but upper left quadrant
+    "\u25E1\u2003", // lower half circle
+    "\u{1F40D}\u2003", // snake emoji again
+    "\u25CB\u2003", // white circle (tail eaten)
+];
+function UserMessage({ content }) {
+    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: content })] }));
+}
+function AssistantMessage({ content }) {
+    return ((0, jsx_runtime_1.jsx)(ink_1.Box, { children: (0, jsx_runtime_1.jsx)(streaming_markdown_1.StreamingMarkdown, { text: content }) }));
+}
+function ToolCallDisplay({ toolCall }) {
+    let argSummary = "";
+    try {
+        const args = JSON.parse(toolCall.function.arguments);
+        const first = Object.values(args)[0];
+        if (typeof first === "string")
+            argSummary = first.length > 60 ? first.slice(0, 57) + "..." : first;
+    }
+    catch {
+        argSummary = toolCall.function.arguments.slice(0, 60);
+    }
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_GREEN, bold: true, children: toolCall.function.name }), argSummary ? (0, jsx_runtime_1.jsxs)(ink_1.Text, { dimColor: true, children: [" ", argSummary] }) : null] }));
+}
+function ToolResultDisplay({ result }) {
+    const color = result.success ? OURO_GREEN : "#e74c3c";
+    const icon = result.success ? "\u2713" : "\u2717";
+    const summary = result.result.length > 120
+        ? result.result.slice(0, 117) + "..."
+        : result.result;
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsxs)(ink_1.Text, { color: color, children: [icon, " ", result.name] }), (0, jsx_runtime_1.jsxs)(ink_1.Text, { dimColor: true, children: [" ", summary.replace(/\n/g, " ")] })] }));
+}
+function SpinnerComponent({ text, frame }) {
+    const char = SNAKE_FRAMES[frame % SNAKE_FRAMES.length];
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_GREEN, children: char }), (0, jsx_runtime_1.jsxs)(ink_1.Text, { dimColor: OURO_DIM, children: [text, "..."] })] }));
+}
+function InputArea({ onSubmit, }) {
+    const [input, setInput] = (0, react_1.useState)("");
+    // Ref tracks the latest input value so useInput callback always sees current state
+    const inputRef = (0, react_1.useRef)("");
+    (0, ink_1.useInput)((inputChar, key) => {
+        if (key.return) {
+            if (inputRef.current.trim() && onSubmit) {
+                onSubmit(inputRef.current);
+            }
+            inputRef.current = "";
+            setInput("");
+            return;
+        }
+        if (key.backspace || key.delete) {
+            inputRef.current = inputRef.current.slice(0, -1);
+            setInput(inputRef.current);
+            return;
+        }
+        if (!key.ctrl && !key.meta && inputChar) {
+            inputRef.current += inputChar;
+            setInput(inputRef.current);
+        }
+    });
+    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 MessageList({ messages, toolResults, }) {
+    const toolResultMap = new Map();
+    if (toolResults) {
+        for (const tr of toolResults) {
+            toolResultMap.set(tr.toolCallId, tr);
+        }
+    }
+    return ((0, jsx_runtime_1.jsx)(ink_1.Box, { flexDirection: "column", children: messages.map((msg, i) => {
+            if (msg.role === "user" && msg.content) {
+                return (0, jsx_runtime_1.jsx)(UserMessage, { content: msg.content }, i);
+            }
+            if (msg.role === "assistant") {
+                return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [msg.content ? (0, jsx_runtime_1.jsx)(AssistantMessage, { content: msg.content }) : null, msg.tool_calls?.map(tc => {
+                            const tr = toolResultMap.get(tc.id);
+                            return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [(0, jsx_runtime_1.jsx)(ToolCallDisplay, { toolCall: tc }), tr ? (0, jsx_runtime_1.jsx)(ToolResultDisplay, { result: tr }) : null] }, tc.id));
+                        })] }, i));
+            }
+            return null;
+        }) }));
+}
+function InkApp({ messages, onSubmit, loading, spinnerText, toolResults, }) {
+    const [spinnerFrame, setSpinnerFrame] = (0, react_1.useState)(0);
+    // Animate spinner
+    react_1.default.useEffect(() => {
+        if (!loading)
+            return;
+        const iv = setInterval(() => {
+            setSpinnerFrame(f => (f + 1) % SNAKE_FRAMES.length);
+        }, 120);
+        return () => clearInterval(iv);
+    }, [loading]);
+    const handleSubmit = (0, react_1.useCallback)((text) => {
+        onSubmit?.(text);
+    }, [onSubmit]);
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [(0, jsx_runtime_1.jsx)(MessageList, { messages: messages, toolResults: toolResults }), loading && spinnerText ? ((0, jsx_runtime_1.jsx)(SpinnerComponent, { text: spinnerText, frame: spinnerFrame })) : null, (0, jsx_runtime_1.jsx)(InputArea, { onSubmit: handleSubmit })] }));
+}