@bubblebrain-ai/bubble 0.0.6 → 0.0.8

package/dist/tui-ink/run.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { App } from "./app.js";
+export async function runTui(agent, args, options = {}) {
+    const instance = render(_jsx(App, { agent: agent, args: args, sessionManager: options.sessionManager, createProvider: options.createProvider, registry: options.registry, skillRegistry: options.skillRegistry, planHandlerRef: options.planHandlerRef, approvalHandlerRef: options.approvalHandlerRef, questionController: options.questionController, bashAllowlist: options.bashAllowlist, settingsManager: options.settingsManager, lspService: options.lspService, mcpManager: options.mcpManager, flushMemory: options.flushMemory, runMemoryCompaction: options.runMemoryCompaction, runMemorySummary: options.runMemorySummary, runMemoryRefresh: options.runMemoryRefresh, bypassEnabled: options.bypassEnabled, onExit: () => {
+            // The app already called useApp().exit() inside requestExit, which
+            // triggers Ink's own unmount + TTY restore. waitUntilExit() below is
+            // the canonical signal that we're done — we deliberately do *not*
+            // call instance.unmount() again here to avoid double-teardown
+            // warnings on React 19.
+        } }), {
+        kittyKeyboard: {
+            mode: "enabled",
+            flags: ["disambiguateEscapeCodes"],
+        },
+    });
+    await instance.waitUntilExit();
+    // zsh's PROMPT_SP prints a reverse-video `%` if the previous program left
+    // the cursor mid-line. Ink's interactive teardown (log-update.done) doesn't
+    // emit a trailing newline, so mirror Ink's non-interactive branch and align
+    // the cursor to column 0 before handing control back to the shell.
+    if (process.stdout.isTTY) {
+        process.stdout.write("\n");
+    }
+}

package/dist/tui-ink/theme.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Lightweight color theme for the TUI.
+ */
+export declare const theme: {
+    readonly user: "green";
+    readonly agent: "blue";
+    readonly error: "red";
+    readonly warning: "yellow";
+    readonly success: "green";
+    readonly accent: "cyan";
+    readonly border: "gray";
+    readonly borderActive: "cyan";
+    readonly inputBorder: "#8A7FC6";
+    readonly muted: "gray";
+    readonly dim: "gray";
+    readonly thinking: "magenta";
+    readonly thinkingDim: "gray";
+    readonly toolName: "cyan";
+    readonly toolResult: "gray";
+    readonly toolError: "red";
+    readonly toolPending: "yellow";
+    readonly code: "yellow";
+    readonly traceAction: "#E89A6B";
+    readonly traceCount: "#c9c1bd";
+    readonly traceDetail: "gray";
+    readonly traceCommand: "#59BCE8";
+    readonly tracePending: "yellow";
+    readonly userMessageBorder: "#8A7FC6";
+    readonly userMessageBg: "#2a2a34";
+    readonly userMessageText: "#f3f3f7";
+    readonly userRail: "#8A7FC6";
+    readonly diffAdd: "#1a3d1a";
+    readonly diffRemove: "#3d1a1a";
+    readonly diffAddFg: "#9CDCFE";
+    readonly diffRemoveFg: "#F48771";
+};
+export type ThemeColor = (typeof theme)[keyof typeof theme];

package/dist/tui-ink/theme.js

@@ -0,0 +1,42 @@
+/**
+ * Lightweight color theme for the TUI.
+ */
+export const theme = {
+    // Actors
+    user: "green",
+    agent: "blue",
+    error: "red",
+    warning: "yellow",
+    success: "green",
+    // UI chrome
+    accent: "cyan",
+    border: "gray",
+    borderActive: "cyan",
+    inputBorder: "#8A7FC6",
+    muted: "gray",
+    dim: "gray",
+    // Content
+    thinking: "magenta",
+    thinkingDim: "gray",
+    toolName: "cyan",
+    toolResult: "gray",
+    toolError: "red",
+    toolPending: "yellow",
+    code: "yellow",
+    traceAction: "#E89A6B",
+    traceCount: "#c9c1bd",
+    traceDetail: "gray",
+    traceCommand: "#59BCE8",
+    tracePending: "yellow",
+    // Message surfaces — user input uses a subtle fill plus a left rail so it is
+    // visually separate from assistant/tool trace output without becoming noisy.
+    userMessageBorder: "#8A7FC6",
+    userMessageBg: "#2a2a34",
+    userMessageText: "#f3f3f7",
+    userRail: "#8A7FC6",
+    // Diff
+    diffAdd: "#1a3d1a",
+    diffRemove: "#3d1a1a",
+    diffAddFg: "#9CDCFE",
+    diffRemoveFg: "#F48771",
+};

package/dist/tui-ink/todos.d.ts

@@ -0,0 +1,7 @@
+import type { Todo } from "../types.js";
+interface TodosPanelProps {
+    todos: Todo[];
+    terminalColumns: number;
+}
+export declare function TodosPanel({ todos, terminalColumns }: TodosPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/tui-ink/todos.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { theme } from "./theme.js";
+const MAX_ROWS = 8;
+export function TodosPanel({ todos, terminalColumns }) {
+    if (todos.length === 0) {
+        return null;
+    }
+    const rows = selectVisibleRows(todos);
+    const hiddenCount = todos.length - rows.length;
+    const contentWidth = Math.max(20, terminalColumns - 4);
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: theme.accent, bold: true, children: "\u25CF Todos" }), rows.map((todo, index) => (_jsx(TodoRow, { todo: todo, maxWidth: contentWidth }, index))), hiddenCount > 0 && (_jsxs(Text, { color: theme.muted, children: ["... ", hiddenCount, " more item", hiddenCount === 1 ? "" : "s", " hidden"] }))] }));
+}
+function selectVisibleRows(todos) {
+    if (todos.length <= MAX_ROWS) {
+        return todos;
+    }
+    // Prefer to show: all in_progress, the last N completed just before current, and upcoming pending.
+    const inProgressIdx = todos.findIndex((t) => t.status === "in_progress");
+    const anchor = inProgressIdx >= 0 ? inProgressIdx : todos.findIndex((t) => t.status === "pending");
+    const pivot = anchor >= 0 ? anchor : 0;
+    const half = Math.floor(MAX_ROWS / 2);
+    let start = Math.max(0, pivot - half);
+    let end = Math.min(todos.length, start + MAX_ROWS);
+    if (end - start < MAX_ROWS) {
+        start = Math.max(0, end - MAX_ROWS);
+    }
+    return todos.slice(start, end);
+}
+function TodoRow({ todo, maxWidth }) {
+    const { glyph, color, dim, label } = statusStyle(todo);
+    const text = label || todo.content;
+    const trimmed = text.length > maxWidth - 4 ? text.slice(0, maxWidth - 5) + "…" : text;
+    return (_jsx(Box, { height: 1, children: _jsxs(Text, { color: color, dimColor: dim, children: [glyph, " ", trimmed] }) }));
+}
+function statusStyle(todo) {
+    if (todo.status === "completed") {
+        return { glyph: "✔", color: theme.muted, dim: true, label: todo.content };
+    }
+    if (todo.status === "in_progress") {
+        return { glyph: "▶", color: theme.accent, dim: false, label: todo.activeForm || todo.content };
+    }
+    return { glyph: "○", color: theme.muted, dim: false, label: todo.content };
+}

package/dist/tui-ink/trace-groups.d.ts

@@ -0,0 +1,25 @@
+import type { DisplayToolCall } from "./display-history.js";
+export type TraceGroupKind = "list" | "read" | "search" | "execute" | "edit" | "write" | "other";
+export interface TraceGroup {
+    kind: TraceGroupKind;
+    title: string;
+    raw: DisplayToolCall[];
+    count?: number;
+    noun?: string;
+    command?: string;
+    items: string[];
+    previewLines: string[];
+    omitted: number;
+    pending: boolean;
+    hasError: boolean;
+    startedAt?: number;
+}
+export interface TraceGroupOptions {
+    maxItems?: number;
+    maxPreviewLines?: number;
+    homeDir?: string;
+}
+export declare function buildTraceGroups(toolCalls: DisplayToolCall[], options?: TraceGroupOptions): TraceGroup[];
+export declare function formatTracePath(value: unknown, homeDir?: string): string;
+export declare function formatElapsed(startedAt: number | undefined, now?: number): string | null;
+export declare function traceGroupLabel(group: TraceGroup): string;

package/dist/tui-ink/trace-groups.js

@@ -0,0 +1,310 @@
+import os from "node:os";
+import { getEditDiffDetails } from "./edit-diff.js";
+const DEFAULT_MAX_ITEMS = 6;
+const DEFAULT_MAX_PREVIEW_LINES = 8;
+export function buildTraceGroups(toolCalls, options = {}) {
+    const maxItems = options.maxItems ?? DEFAULT_MAX_ITEMS;
+    const maxPreviewLines = options.maxPreviewLines ?? DEFAULT_MAX_PREVIEW_LINES;
+    const homeDir = options.homeDir ?? os.homedir();
+    const groups = [];
+    let bucket = [];
+    let bucketClassifier = null;
+    const flush = () => {
+        if (bucket.length === 0 || !bucketClassifier)
+            return;
+        groups.push(buildTraceGroup(bucketClassifier, bucket, {
+            maxItems,
+            maxPreviewLines,
+            homeDir,
+        }));
+        bucket = [];
+        bucketClassifier = null;
+    };
+    for (const toolCall of toolCalls) {
+        const classifier = classifyTool(toolCall);
+        if (!classifier.groupable) {
+            flush();
+            groups.push(buildTraceGroup(classifier, [toolCall], {
+                maxItems,
+                maxPreviewLines,
+                homeDir,
+            }));
+            continue;
+        }
+        if (bucketClassifier?.bucketKey === classifier.bucketKey) {
+            bucket.push(toolCall);
+        }
+        else {
+            flush();
+            bucket = [toolCall];
+            bucketClassifier = classifier;
+        }
+    }
+    flush();
+    return groups;
+}
+export function formatTracePath(value, homeDir = os.homedir()) {
+    const text = String(value ?? "").trim();
+    if (!text)
+        return "";
+    if (text === homeDir)
+        return "~";
+    if (text.startsWith(homeDir + "/"))
+        return "~" + text.slice(homeDir.length);
+    return text;
+}
+export function formatElapsed(startedAt, now = Date.now()) {
+    if (!startedAt)
+        return null;
+    const seconds = Math.max(0, Math.floor((now - startedAt) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainder = seconds % 60;
+    return `${minutes}m${remainder.toString().padStart(2, "0")}s`;
+}
+export function traceGroupLabel(group) {
+    if (group.command)
+        return `${group.title} ${group.command}`;
+    if (group.count !== undefined && group.noun)
+        return `${group.title} ${group.count} ${group.noun}`;
+    return group.title;
+}
+function classifyTool(toolCall) {
+    switch (toolCall.name) {
+        case "glob": {
+            const pattern = String(toolCall.args.pattern ?? "");
+            const title = isDirectoryLikeGlob(pattern) ? "List Directory" : "Find Files";
+            return {
+                kind: "list",
+                title,
+                bucketKey: `list:${title}`,
+                groupable: true,
+            };
+        }
+        case "read":
+            return { kind: "read", title: "Read", bucketKey: "read", groupable: true };
+        case "grep":
+            return { kind: "search", title: "Search", bucketKey: "search", groupable: true };
+        case "bash":
+            return { kind: "execute", title: "Execute", bucketKey: `execute:${toolCall.id}`, groupable: false };
+        case "edit":
+            return { kind: "edit", title: "Edit", bucketKey: `edit:${toolCall.id}`, groupable: false };
+        case "write":
+            return { kind: "write", title: "Write", bucketKey: "write", groupable: true };
+        default:
+            return {
+                kind: "other",
+                title: displayToolName(toolCall.name),
+                bucketKey: `${toolCall.name}:${toolCall.id}`,
+                groupable: false,
+            };
+    }
+}
+function buildTraceGroup(classifier, raw, options) {
+    const pending = raw.some((tool) => isToolPending(tool));
+    const startedAt = raw
+        .filter((tool) => isToolPending(tool))
+        .map((tool) => tool.startedAt)
+        .filter((value) => typeof value === "number")
+        .sort((a, b) => a - b)[0];
+    const hasError = raw.some((tool) => !!tool.isError);
+    switch (classifier.kind) {
+        case "list":
+            return buildListGroup(classifier, raw, options, pending, startedAt, hasError);
+        case "read":
+            return buildPathGroup(classifier, raw, options, pending, startedAt, hasError, "files");
+        case "search":
+            return buildSearchGroup(classifier, raw, options, pending, startedAt, hasError);
+        case "execute":
+            return buildExecuteGroup(classifier, raw[0], options, pending, startedAt, hasError);
+        case "edit":
+        case "write":
+            return buildMutationGroup(classifier, raw, options, pending, startedAt, hasError);
+        default:
+            return buildOtherGroup(classifier, raw, options, pending, startedAt, hasError);
+    }
+}
+function buildListGroup(classifier, raw, options, pending, startedAt, hasError) {
+    const resultItems = raw.flatMap((tool) => resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir)));
+    const fallbackItems = raw
+        .map((tool) => String(tool.args.pattern ?? tool.args.path ?? "").trim())
+        .filter(Boolean)
+        .map((item) => formatTracePath(item, options.homeDir));
+    const sourceItems = resultItems.length > 0 ? resultItems : fallbackItems;
+    const { shown, omitted } = take(sourceItems, options.maxItems);
+    const count = resultItems.length > 0 ? resultItems.length : sourceItems.length || raw.length;
+    const noun = resultItems.length > 0 ? plural(count, "file", "files") : plural(count, "search", "searches");
+    return {
+        kind: "list",
+        title: classifier.title,
+        raw,
+        count,
+        noun,
+        items: shown,
+        previewLines: [],
+        omitted,
+        pending,
+        hasError,
+        startedAt,
+    };
+}
+function buildPathGroup(classifier, raw, options, pending, startedAt, hasError, nounBase) {
+    const items = raw
+        .map((tool) => formatTracePath(tool.args.path ?? tool.args.file ?? "", options.homeDir))
+        .filter(Boolean);
+    const { shown, omitted } = take(items, options.maxItems);
+    const count = items.length || raw.length;
+    return {
+        kind: classifier.kind,
+        title: classifier.title,
+        raw,
+        count,
+        noun: plural(count, nounBase.slice(0, -1), nounBase),
+        items: shown,
+        previewLines: [],
+        omitted,
+        pending,
+        hasError,
+        startedAt,
+    };
+}
+function buildSearchGroup(classifier, raw, options, pending, startedAt, hasError) {
+    const items = raw.map((tool) => {
+        const pattern = String(tool.args.pattern ?? tool.args.query ?? "").trim();
+        const scope = String(tool.args.path ?? tool.args.glob ?? tool.args.include ?? "").trim();
+        const patternText = pattern ? `"${pattern}"` : "(pattern)";
+        return scope ? `${patternText} in ${formatTracePath(scope, options.homeDir)}` : patternText;
+    });
+    const { shown, omitted } = take(items, options.maxItems);
+    const count = raw.length;
+    return {
+        kind: "search",
+        title: classifier.title,
+        raw,
+        count,
+        noun: plural(count, "search", "searches"),
+        items: shown,
+        previewLines: [],
+        omitted,
+        pending,
+        hasError,
+        startedAt,
+    };
+}
+function buildExecuteGroup(classifier, tool, options, pending, startedAt, hasError) {
+    const lines = resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
+    const { shown, omitted } = take(lines, options.maxPreviewLines);
+    return {
+        kind: "execute",
+        title: classifier.title,
+        raw: [tool],
+        command: normalizeCommand(tool.args.command ?? ""),
+        items: [],
+        previewLines: shown,
+        omitted,
+        pending,
+        hasError,
+        startedAt,
+    };
+}
+function buildMutationGroup(classifier, raw, options, pending, startedAt, hasError) {
+    const items = raw
+        .map((tool) => {
+        const path = formatTracePath(tool.args.path ?? "", options.homeDir);
+        const details = tool.name === "edit" ? getEditDiffDetails(tool) : null;
+        const suffix = details ? ` ${formatCompactEditStats(details.added, details.removed)}` : "";
+        return path ? `${path}${suffix}` : "";
+    })
+        .filter(Boolean);
+    const { shown, omitted } = take(items, options.maxItems);
+    const count = items.length || raw.length;
+    const errorPreview = hasError
+        ? raw
+            .filter((tool) => tool.isError)
+            .flatMap((tool) => resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir)))
+            .slice(0, options.maxPreviewLines)
+        : [];
+    return {
+        kind: classifier.kind,
+        title: classifier.title,
+        raw,
+        count,
+        noun: plural(count, "file", "files"),
+        items: shown,
+        previewLines: errorPreview,
+        omitted,
+        pending,
+        hasError,
+        startedAt,
+    };
+}
+function buildOtherGroup(classifier, raw, options, pending, startedAt, hasError) {
+    const tool = raw[0];
+    const header = toolHeader(tool, options.homeDir);
+    const preview = resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
+    const { shown, omitted } = take(preview, options.maxPreviewLines);
+    return {
+        kind: "other",
+        title: classifier.title,
+        raw,
+        count: header ? undefined : raw.length,
+        noun: header ? undefined : plural(raw.length, "call", "calls"),
+        items: header ? [header] : [],
+        previewLines: shown,
+        omitted,
+        pending,
+        hasError,
+        startedAt,
+    };
+}
+function isToolPending(tool) {
+    return tool.result === undefined;
+}
+function isDirectoryLikeGlob(pattern) {
+    const normalized = pattern.trim();
+    return normalized === "" || normalized === "*" || normalized === "**" || normalized === "**/*";
+}
+function resultLines(result) {
+    if (result === undefined)
+        return [];
+    return result
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .filter((line) => line.trim() !== "");
+}
+function take(items, max) {
+    const shown = items.slice(0, max);
+    return { shown, omitted: Math.max(0, items.length - shown.length) };
+}
+function plural(count, singular, pluralValue) {
+    return count === 1 ? singular : pluralValue;
+}
+function normalizeCommand(value) {
+    const command = String(value ?? "").replace(/\s+/g, " ").trim();
+    return command || "(command)";
+}
+function displayToolName(name) {
+    if (!name)
+        return "Tool";
+    return name.charAt(0).toUpperCase() + name.slice(1).replace(/_/g, " ");
+}
+function toolHeader(tool, homeDir) {
+    const args = tool.args || {};
+    for (const key of ["path", "command", "pattern", "query", "url"]) {
+        const value = args[key];
+        if (value !== undefined && value !== null && String(value).trim() !== "") {
+            return formatTracePath(value, homeDir);
+        }
+    }
+    return undefined;
+}
+function formatCompactEditStats(added, removed) {
+    const parts = [];
+    if (added > 0)
+        parts.push(`+${added}`);
+    if (removed > 0)
+        parts.push(`-${removed}`);
+    return parts.length > 0 ? `(${parts.join(" ")})` : "";
+}

package/dist/tui-ink/use-terminal-size.d.ts

@@ -0,0 +1,4 @@
+export declare function useTerminalSize(): {
+    columns: number;
+    rows: number;
+};

package/dist/tui-ink/use-terminal-size.js

@@ -0,0 +1,21 @@
+import { useEffect, useState } from "react";
+import { useStdout } from "ink";
+export function useTerminalSize() {
+    const { stdout } = useStdout();
+    const [size, setSize] = useState(() => ({
+        columns: stdout?.columns || 80,
+        rows: stdout?.rows || 24,
+    }));
+    useEffect(() => {
+        if (!stdout)
+            return;
+        const onResize = () => {
+            setSize({ columns: stdout.columns || 80, rows: stdout.rows || 24 });
+        };
+        stdout.on("resize", onResize);
+        return () => {
+            stdout.off("resize", onResize);
+        };
+    }, [stdout]);
+    return size;
+}

package/dist/tui-ink/welcome.d.ts

@@ -0,0 +1,18 @@
+import type { DisplayMessage } from "./display-history.js";
+interface WelcomeBannerProps {
+    terminalColumns: number;
+    modelLabel?: string;
+    cwd?: string;
+    tips: string[];
+    skillsCount?: number;
+    mcpConnectedCount?: number;
+    mcpTotalCount?: number;
+    hasAgentsFile?: boolean;
+}
+interface WelcomeVisibilityInput {
+    messages: Pick<DisplayMessage, "role" | "syntheticKind">[];
+    startedWithVisibleHistory: boolean;
+}
+export declare function shouldShowWelcomeBanner({ startedWithVisibleHistory, }: WelcomeVisibilityInput): boolean;
+export declare function WelcomeBanner({ terminalColumns, modelLabel, cwd, tips, skillsCount, mcpConnectedCount, mcpTotalCount, hasAgentsFile, }: WelcomeBannerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/tui-ink/welcome.js

@@ -0,0 +1,119 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from "react";
+import { Box, Text } from "ink";
+import { createRequire } from "node:module";
+import { theme } from "./theme.js";
+const require = createRequire(import.meta.url);
+const PACKAGE_VERSION = readPackageVersion();
+const BUBBLE_LOGO_LETTERS = [
+    [
+        "██████ ",
+        "██   ██",
+        "██   ██",
+        "██████ ",
+        "██   ██",
+        "██   ██",
+        "██████ ",
+    ],
+    [
+        "██   ██",
+        "██   ██",
+        "██   ██",
+        "██   ██",
+        "██   ██",
+        "██   ██",
+        " █████ ",
+    ],
+    [
+        "██████ ",
+        "██   ██",
+        "██   ██",
+        "██████ ",
+        "██   ██",
+        "██   ██",
+        "██████ ",
+    ],
+    [
+        "██████ ",
+        "██   ██",
+        "██   ██",
+        "██████ ",
+        "██   ██",
+        "██   ██",
+        "██████ ",
+    ],
+    [
+        "██     ",
+        "██     ",
+        "██     ",
+        "██     ",
+        "██     ",
+        "██     ",
+        "███████",
+    ],
+    [
+        "███████",
+        "██     ",
+        "██     ",
+        "██████ ",
+        "██     ",
+        "██     ",
+        "███████",
+    ],
+];
+const LOGO_COLORS = ["#f3f3f7", "#f3f3f7", "#d8c7ff", "#d8c7ff", "#a9c7ff", "#a9c7ff"];
+const COMPACT_LOGO = ["B", "U", "B", "B", "L", "E"];
+const WIDE_LOGO_MIN_WIDTH = 52;
+export function shouldShowWelcomeBanner({ startedWithVisibleHistory, }) {
+    // Banner is committed to Static scrollback once at session start. Flipping
+    // this flag back to false (e.g. when a picker opens) shrinks the Static
+    // items list — when the items grow back, ink replays the banner a second
+    // time into scrollback. Keep visibility decided purely by initial history.
+    if (startedWithVisibleHistory)
+        return false;
+    return true;
+}
+export function WelcomeBanner({ terminalColumns, modelLabel, cwd, tips, skillsCount = 0, mcpConnectedCount = 0, mcpTotalCount = 0, hasAgentsFile = false, }) {
+    const effectiveWidth = Math.max(20, Math.min(terminalColumns - 2, 118));
+    const useWideLogo = effectiveWidth >= WIDE_LOGO_MIN_WIDTH;
+    const actionableTips = tips
+        .filter((item) => !item.startsWith("Ready with") && item.trim().length > 0)
+        .slice(0, 2);
+    const tip = actionableTips.length > 0
+        ? actionableTips.join(" · ")
+        : "Type / for commands and @ to reference files";
+    const modelLine = modelLabel ? `${modelLabel}${cwd ? ` · ${cwd}` : ""}` : cwd;
+    return (_jsxs(Box, { width: effectiveWidth, flexDirection: "column", alignItems: "center", marginBottom: 1, children: [_jsx(Box, { flexDirection: "column", alignItems: "center", children: useWideLogo
+                    ? BUBBLE_LOGO_LETTERS[0].map((_, rowIndex) => (_jsx(LogoRow, { rowIndex: rowIndex }, `logo-row-${rowIndex}`)))
+                    : _jsx(CompactLogo, {}) }), _jsx(Box, { marginTop: 2, children: _jsx(Text, { bold: true, color: theme.muted, children: PACKAGE_VERSION }) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { bold: true, color: theme.userMessageText, children: "TIP: " }), _jsx(Text, { bold: true, color: theme.userMessageText, children: tip })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: "shift+tab to cycle modes \u00B7 ctrl+r for reasoning \u00B7 ctrl+o for trace" }) }), modelLine && (_jsx(Box, { children: _jsx(Text, { color: theme.muted, children: truncateToWidth(modelLine, effectiveWidth - 4) }) })), _jsxs(Box, { marginTop: 1, children: [_jsx(StatusItem, { label: "Skills", count: skillsCount, ok: skillsCount > 0 }), _jsx(Text, { color: theme.muted, children: "  " }), _jsx(StatusItem, { label: "MCPs", count: mcpConnectedCount, total: mcpTotalCount, ok: mcpTotalCount === 0 || mcpConnectedCount === mcpTotalCount }), _jsx(Text, { color: theme.muted, children: "  " }), _jsx(StatusItem, { label: "AGENTS.md", ok: hasAgentsFile })] })] }));
+}
+function LogoRow({ rowIndex }) {
+    return (_jsx(Box, { children: BUBBLE_LOGO_LETTERS.map((letter, index) => (_jsxs(React.Fragment, { children: [_jsx(Text, { bold: true, color: LOGO_COLORS[index], children: letter[rowIndex] }), index < BUBBLE_LOGO_LETTERS.length - 1 && _jsx(Text, { children: " " })] }, `${index}-${rowIndex}`))) }));
+}
+function CompactLogo() {
+    return (_jsx(Box, { children: COMPACT_LOGO.map((letter, index) => (_jsx(Text, { bold: true, color: LOGO_COLORS[index], children: letter }, `${letter}-${index}`))) }));
+}
+function StatusItem({ label, count, total, ok, }) {
+    const countText = count === undefined
+        ? ""
+        : total !== undefined && total > count
+            ? ` (${count}/${total})`
+            : ` (${count})`;
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, color: theme.muted, children: [label, countText, " "] }), _jsx(Text, { bold: true, color: ok ? theme.success : theme.error, children: ok ? "✓" : "×" })] }));
+}
+function readPackageVersion() {
+    try {
+        const pkg = require("../../package.json");
+        return pkg.version ? `v${pkg.version}` : "v0.0.0";
+    }
+    catch {
+        return "v0.0.0";
+    }
+}
+function truncateToWidth(text, maxWidth) {
+    if (maxWidth <= 0)
+        return "";
+    if (text.length <= maxWidth)
+        return text;
+    return text.slice(0, Math.max(1, maxWidth - 1)) + "…";
+}

package/dist/types.d.ts

@@ -101,6 +101,9 @@ export interface ToolResultMetadata {
     searchFamily?: string;
     reason?: string;
     arbiterNote?: string;
+    diff?: string;
+    addedLines?: number;
+    removedLines?: number;
     [key: string]: unknown;
 }
 export interface ToolResult {
@@ -299,6 +302,7 @@ export type AgentEvent = {
 } | {
     type: "turn_end";
     usage?: TokenUsage;
+    willContinue?: boolean;
 } | {
     type: "context_recovered";
     droppedMessages: number;