@bubblebrain-ai/bubble 0.0.49 → 0.0.50

package/dist/tui-ink/app.js

@@ -1,18 +1,17 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { Box, Text, useApp, useInput } from "ink";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
 import { AgentAbortError, INTERRUPTED_ASSISTANT_CONTENT } from "../agent.js";
-import { isHiddenToolMetadata } from "../agent/tool-visibility.js";
 import { SessionManager } from "../session.js";
 import { registry as slashRegistry } from "../slash-commands/index.js";
 import { UserConfig, maskKey } from "../config.js";
 import { InputBox, isCtrlCInput, isCtrlLetterInput, } from "./input-box.js";
 import { MessageList } from "./message-list.js";
 import { isMultiplexedTerminal } from "./terminal-env.js";
-import { appendTextPart, appendToolPart, contentFromParts, latestCompactionSummary, moveStatusMessageToEnd, nextDisplayMessageKey, setUserInputStatus, snapshotDisplayParts, stripInterruptedAssistantMarker, toolCallsFromParts, } from "./display-history.js";
+import { appendTextPart, appendToolPart, contentFromParts, latestCompactionSummary, moveStatusMessageToEnd, nextDisplayMessageKey, setUserInputStatus, snapshotDisplayParts, toolCallsFromParts, } from "./display-history.js";
 import { AgentRunInputQueue } from "../agent/input-controller.js";
-import { canvasBackgroundFor, paletteFor, ThemeProvider, useTheme } from "./theme.js";
-import { isPrintablePickerInput, ModelPicker, ProviderPicker, KeyPicker, SkillPicker } from "./model-picker.js";
+import { canvasBackgroundFor, paletteFor, ThemeProvider } from "./theme.js";
+import { ModelPicker, ProviderPicker, KeyPicker, SkillPicker } from "./model-picker.js";
 import { FeishuSetupPicker } from "./feishu-setup-picker.js";
 import { BUILTIN_PROVIDERS, ProviderRegistry, decodeModel, displayModel, isUserVisibleProvider } from "../provider-registry.js";
 import { buildSystemPrompt } from "../system-prompt.js";
@@ -49,234 +48,25 @@ import { tokenUsageTotal } from "../goal/usage.js";
 import { formatInternalContextBlock, isInternalBlockOnlyContent } from "../agent/internal-reminder-sanitizer.js";
 import { MAX_ACTIVE_LOOPS, decideLoopFiring, formatInterval, formatLoopList, parseLoopCommand, } from "../loop/engine.js";
 import { TaskWakeCoalescer, findDanglingTaskStarts, formatTaskWakeSummary, isPidAlive, shouldFireTaskWake, taskEligibleForWake, } from "../tasks/wake.js";
-const TASK_WAKE_DEBOUNCE_MS = 2000;
-import { collectUsageStatsBundle, formatStatsPanelBody, rangeLabel } from "../stats/usage.js";
+import { STREAMING_FLUSH_INTERVAL_MS, TASK_WAKE_DEBOUNCE_MS, buildTips, formatContextUsageLabel, friendlyCwd, parsePartialArgs, sessionBasename, slashResultNoticeKind, taskRowSummary, truncate, withMessageKey, } from "./app-helpers.js";
+import { reconstructDisplayMessages } from "./display-reconstruct.js";
+export { reconstructDisplayMessages } from "./display-reconstruct.js";
+import { INK_LOCAL_SLASH_COMMANDS, CommandPalette, McpReconnectPicker, buildCommandPaletteItems, buildMcpReconnectItems, } from "./command-palette.js";
+export { INK_LOCAL_SLASH_COMMANDS } from "./command-palette.js";
+import { RewindPicker } from "./rewind-picker.js";
+import { StatsPanel } from "./stats-panel.js";
+import { WaitingIndicator } from "./waiting-indicator.js";
+import { collectUsageStatsBundle } from "../stats/usage.js";
 import { GrokRuntimeError } from "../external-runtime/grok-errors.js";
-import { GROK_LOCAL_SLASH_COMMANDS, classifyGrokInput, isGrokLocalSlashCommand, } from "../external-runtime/grok-input-policy.js";
+import { GROK_LOCAL_SLASH_COMMANDS, classifyGrokInput, } from "../external-runtime/grok-input-policy.js";
 import { GROK_SUBSCRIPTION_PROVIDER_ID, isGrokSubscriptionProviderId, withGrokSubscriptionProvider, } from "../external-runtime/grok-provider.js";
 import { classifyExternalRuntimeBinding, stopExternalRuntimeForSessionSwitch, } from "../external-runtime/session-policy.js";
-import os from "node:os";
 import { rmSync } from "node:fs";
 import { execFile } from "node:child_process";
-function buildTips(agent, registry, grokActive = false) {
-    const tips = [];
-    if (grokActive) {
-        return [
-            "Grok Subscription is active with workspace tools and Bubble approvals",
-            "Use /model to choose the Grok model and reasoning effort",
-            "Use /logout grok to return to a fresh native session",
-        ];
-    }
-    const hasProvider = registry.getEnabled().length > 0;
-    if (!hasProvider) {
-        tips.push("Run /login or /provider --add to configure a model");
-    }
-    else if (agent.model) {
-        tips.push(`Ready with ${displayModel(agent.model)}`);
-    }
-    else {
-        tips.push("Run /model to pick a model");
-    }
-    tips.push("Type @ to reference a file");
-    tips.push("Type / for commands and skills");
-    return tips;
-}
-/**
- * Slash-command results arrive as plain strings; recognize the /model
- * confirmations by shape so they render as accent-colored UI notices — the
- * same treatment the picker path applies — instead of assistant prose.
- */
-function slashResultNoticeKind(result) {
-    return /^(Grok m|M)odel switched to /.test(result) ? "ui_notice" : undefined;
-}
 // Canonical implementation lives in the sanitizer module so non-TUI surfaces
 // (session pickers, desktop host) share it; re-exported here for existing users.
 export { isInternalBlockOnlyContent };
-/** Status-row summary for running background tasks (design §2.5). */
-function taskRowSummary(tasks, nowTick) {
-    const first = tasks[0];
-    const label = first.description?.trim() || first.command.replace(/\s+/g, " ").slice(0, 32);
-    const elapsed = Math.max(0, Math.round((nowTick - first.startedAt) / 1000));
-    return `${label} ${elapsed}s`;
-}
-function friendlyCwd(cwd) {
-    const home = os.homedir();
-    if (cwd === home)
-        return "~";
-    if (cwd.startsWith(home + "/"))
-        return "~" + cwd.slice(home.length);
-    return cwd;
-}
-function sessionBasename(sessionFile) {
-    if (!sessionFile)
-        return undefined;
-    const base = sessionFile.split("/").pop() ?? sessionFile;
-    return base.replace(/\.jsonl$/, "");
-}
-function truncate(value, max) {
-    if (value.length <= max)
-        return value;
-    return `${value.slice(0, Math.max(0, max - 1))}…`;
-}
-function formatCompactTokens(n) {
-    if (n < 1000)
-        return `${Math.round(n)}`;
-    if (n < 1_000_000)
-        return `${(n / 1000).toFixed(n >= 10000 ? 0 : 1)}K`;
-    return `${(n / 1_000_000).toFixed(n >= 10_000_000 ? 0 : 1)}M`;
-}
-function formatContextUsageLabel(snapshot) {
-    if (!snapshot.contextWindow || snapshot.contextWindow <= 0) {
-        return `${formatCompactTokens(snapshot.usedTokens)} context`;
-    }
-    const percent = (snapshot.usedTokens / snapshot.contextWindow) * 100;
-    const label = percent >= 10
-        ? `${Math.round(percent)}%`
-        : percent >= 0.05
-            ? `${percent.toFixed(1)}%`
-            : "<0.1%";
-    return `${label} context`;
-}
-export function reconstructDisplayMessages(agentMessages) {
-    const result = [];
-    for (const m of agentMessages) {
-        if (m.role === "system" || m.role === "tool")
-            continue;
-        if (m.role === "user") {
-            if (m.isMeta)
-                continue; // <system-reminder> injections are not user-visible
-            // Harness-initiated kicks (goal continuations, task wakes) persist as
-            // user-role messages wrapped in internal blocks so the model keeps
-            // them across resume — but they were hidden live and must stay hidden
-            // when the transcript is rebuilt.
-            if (isInternalBlockOnlyContent(m.content))
-                continue;
-            result.push({
-                key: nextDisplayMessageKey("user"),
-                role: "user",
-                content: typeof m.content === "string" ? m.content : "(multimedia)",
-            });
-        }
-        else if (m.role === "assistant") {
-            const toolCalls = [];
-            if (m.toolCalls) {
-                for (const tc of m.toolCalls) {
-                    let args = {};
-                    try {
-                        args = JSON.parse(tc.arguments || "{}");
-                    }
-                    catch {
-                        args = {};
-                    }
-                    const toolResult = agentMessages.find((tm) => tm.role === "tool" && tm.toolCallId === tc.id);
-                    if (isHiddenToolMetadata(toolResult ? toolResult.metadata : undefined))
-                        continue;
-                    toolCalls.push({
-                        id: tc.id,
-                        name: tc.name,
-                        args,
-                        result: toolResult ? toolResult.content : undefined,
-                        isError: toolResult ? toolResult.content?.startsWith?.("Error:") : false,
-                        metadata: toolResult ? toolResult.metadata : undefined,
-                    });
-                }
-            }
-            // An aborted assistant message carries the model-facing interruption
-            // note in its content. Render only what the assistant actually said
-            // (partial streamed text, if any) plus a dedicated interrupt row —
-            // never the note itself, which reads like a leaked system prompt.
-            const interrupted = m.error?.aborted === true;
-            const content = interrupted
-                ? stripInterruptedAssistantMarker(m.content, INTERRUPTED_ASSISTANT_CONTENT)
-                : m.content;
-            if (content || m.reasoning || toolCalls.length > 0 || m.systemFingerprint) {
-                result.push({
-                    key: nextDisplayMessageKey("asst"),
-                    role: "assistant",
-                    content,
-                    reasoning: m.reasoning || undefined,
-                    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-                    systemFingerprint: m.systemFingerprint,
-                });
-            }
-            if (interrupted) {
-                result.push({
-                    key: nextDisplayMessageKey("asst"),
-                    role: "assistant",
-                    content: "Interrupted by user",
-                    syntheticKind: "ui_interrupt",
-                });
-            }
-        }
-    }
-    return result;
-}
-/**
- * Streaming tool arguments arrive as an incomplete JSON buffer. We can't
- * JSON.parse() until the closing brace lands, but the user wants to see the
- * short identifying fields (path, command, …) as soon as the model emits
- * them so the tool row header reflects what's happening.
- *
- * Intentionally limited to short, single-line fields. Long fields like
- * `content` are *not* surfaced live: rendering thousands of partial lines
- * per delta floods the terminal and the partial value can break around
- * unescaped sequences. The final value lands when the tool actually
- * executes and tool_start delivers canonical args.
- */
-function parsePartialArgs(buffer, previous) {
-    // If the buffer is now valid JSON, prefer the real parse.
-    try {
-        const parsed = JSON.parse(buffer);
-        if (parsed && typeof parsed === "object")
-            return parsed;
-    }
-    catch {
-        // fall through to partial extraction below
-    }
-    const result = { ...previous };
-    const FIELDS = ["path", "command", "pattern", "url", "query"];
-    for (const field of FIELDS) {
-        // Match a complete-looking quoted string. Requires a closing quote so we
-        // don't surface half-typed paths that may still change as bytes arrive.
-        const match = buffer.match(new RegExp(`"${field}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)"`));
-        if (match) {
-            const raw = match[1] ?? "";
-            result[field] = raw
-                .replace(/\\n/g, "\n")
-                .replace(/\\t/g, "\t")
-                .replace(/\\"/g, '"')
-                .replace(/\\\\/g, "\\");
-        }
-    }
-    return result;
-}
-/**
- * Coerce a freshly-constructed DisplayMessage into one that carries a stable
- * `key`. Centralizes the safety net so callers don't have to remember to call
- * nextDisplayMessageKey on every push.
- */
-function withMessageKey(message) {
-    if (message.key)
-        return message;
-    const prefix = message.role === "user" ? "user" : message.role === "error" ? "err" : "asst";
-    return { ...message, key: nextDisplayMessageKey(prefix) };
-}
-// Batch streaming text deltas before committing them to React state. Without
-// <Static>, every commit re-renders the full-screen frame; per-token commits
-// would make Yoga re-lay-out the transcript for every few bytes of output.
-// 40ms keeps perceived latency invisible while capping layout work at 25fps.
-const STREAMING_FLUSH_INTERVAL_MS = 40;
-export const INK_LOCAL_SLASH_COMMANDS = [
-    {
-        name: "goal",
-        description: "Set/manage an autonomous goal (/goal <objective>|clear|pause|resume|edit)",
-    },
-    {
-        name: "loop",
-        description: "Run a prompt on a recurring interval (/loop 5m <prompt>|list|stop [id])",
-    },
-];
-export function App({ agent, args, sessionManager: initialSessionManager, switchSession, createProvider, registry, skillRegistry, planHandlerRef, approvalHandlerRef, questionController, bashAllowlist, settingsManager, lspService, mcpManager, themeMode: initialThemeMode, themeOverrides, detectedTheme, onThemeModeChange, flushMemory, runMemoryCompaction, runMemorySummary, runMemoryRefresh, goalStore, processManager, tasksAutoResume, promotionChannel, bypassEnabled, updateNotice, updateNoticeRefresh, hookController, externalRuntime, onExit }) {
+export function App({ agent, args, sessionManager: initialSessionManager, switchSession, createProvider, registry, skillRegistry, planHandlerRef, approvalHandlerRef, questionController, bashAllowlist, settingsManager, lspService, mcpManager, themeMode: initialThemeMode, themeOverrides, detectedTheme, onThemeModeChange, flushMemory, runMemoryCompaction, runMemorySummary, runMemoryRefresh, goalStore, processManager, tasksAutoResume, promotionChannel, updateNotice, updateNoticeRefresh, hookController, externalRuntime, onExit }) {
     const [sessionManager, setSessionManager] = useState(initialSessionManager);
     const [externalRuntimeBinding, setExternalRuntimeBinding] = useState(() => initialSessionManager?.getMetadata().externalRuntime);
     const sessionManagerRef = useRef(sessionManager);
@@ -372,8 +162,30 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
         });
         return () => { cancelled = true; };
     }, [args.cwd]);
+    // Push-based sync: the agent notifies on every resident-context mutation
+    // (message rewrites from /clear /compact /rewind and session switches,
+    // per-message appends during runs, model/provider switches), so this single
+    // subscription replaces the per-path manual refreshes that were easy to
+    // forget (the /clear footer bug). Initial read covers agents mounted with
+    // pre-existing history.
+    //
+    // Notifications are trailing-edge debounced: a snapshot run is O(all
+    // resident messages) (tiktoken providers measured ~225ms at 400 messages),
+    // and a tool-dense turn appends 5-15 messages synchronously — recomputing
+    // per append would block the run loop 1-3s. The footer is a human-facing
+    // readout; one recomputation 150ms after the last append is indistinguishable.
     useEffect(() => {
-        setContextUsage(formatContextUsageLabel(agent.getContextUsageSnapshot()));
+        let timer;
+        const update = () => setContextUsage(formatContextUsageLabel(agent.getContextUsageSnapshot()));
+        update();
+        const off = agent.onContextChanged(() => {
+            clearTimeout(timer);
+            timer = setTimeout(update, 150);
+        });
+        return () => {
+            clearTimeout(timer);
+            off();
+        };
     }, [agent]);
     const [currentUpdateNotice, setCurrentUpdateNotice] = useState(updateNotice);
     const [pendingPlan, setPendingPlan] = useState(null);
@@ -403,12 +215,19 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
     // MessageList so Ink discards its already-printed rows and re-prints the
     // rebuilt list onto a freshly-cleared screen instead of appending duplicates.
     const [staticGeneration, setStaticGeneration] = useState(0);
+    // The clear must go through Ink's stdout hook, not a raw process.stdout
+    // write: Ink replays its last dynamic frame after any external write
+    // (restoreLastOutput), which is the only repaint guarantee when the
+    // generation bump produces no new output — with zero settled rows (fresh
+    // welcome screen) <Static> emits nothing and the dynamic frame diffs equal,
+    // so Ink skips the write and a raw clear would leave the screen blank.
+    const { write: writeThroughInk } = useStdout();
     const reprintTranscript = useCallback(() => {
         if (process.stdout.isTTY) {
-            process.stdout.write("\x1b[0m\x1b[2J\x1b[3J\x1b[H");
+            writeThroughInk("\x1b[0m\x1b[2J\x1b[3J\x1b[H");
         }
         setStaticGeneration((generation) => generation + 1);
-    }, []);
+    }, [writeThroughInk]);
     // Steer/queue while the agent runs:
     // Enter steers the current run via the agent's input controller; Tab (or an
     // ineligible input) queues for the next turn. Both render placeholder user
@@ -1098,6 +917,11 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                 setThinkingLevel,
                 sessionManager: targetSessionManager,
             });
+            // Persist the resolved effort alongside the model so a fresh session
+            // restores both. Without this, the picker path only remembered the model
+            // and new sessions fell back to a stale config.json defaultThinkingLevel
+            // (e.g. picking glm-5.3 + max still restored "high" on next launch).
+            userConfig.setDefaultThinkingLevel(nextThinkingLevel);
             // Binary thinking toggles and thinking-only models use internal level
             // placeholders; do not present those placeholders as real effort grades.
             const decodedModel = decodeModel(model);
@@ -1107,7 +931,6 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
             const effortNote = nextThinkingLevel && nextThinkingLevel !== "off"
                 ? (isThinkingToggle || isThinkingOnly ? " in thinking mode" : ` with ${nextThinkingLevel} effort`)
                 : "";
-            setContextUsage(formatContextUsageLabel(agent.getContextUsageSnapshot()));
             addMessage("assistant", `Model switched to ${displayModel(model)}${effortNote}.`, "ui_notice");
             closePicker();
             return nextThinkingLevel;
@@ -1167,8 +990,10 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
             transitionToNative,
             onExternalRuntimeChange: refreshExternalRuntimeBinding,
         });
-        if (handled && result)
-            addMessage("assistant", result, slashResultNoticeKind(result));
+        if (handled) {
+            if (result)
+                addMessage("assistant", result, slashResultNoticeKind(result));
+        }
     }, [
         addMessage,
         agent,
@@ -1758,7 +1583,6 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                                     goalRunTokens += tokenUsageTotal(event.usage);
                                 }
                                 assistantSystemFingerprint = event.systemFingerprint;
-                                setContextUsage(formatContextUsageLabel(agent.getContextUsageSnapshot()));
                                 if (event.willContinue) {
                                     commitAssistantMessage();
                                     clearAssistantStream();
@@ -2562,416 +2386,3 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                             contextUsage: externalSessionBound ? undefined : (contextUsage || undefined),
                         }) }) }))] }) }));
 }
-function buildCommandPaletteItems(skillRegistry, grokSessionBound = false) {
-    const items = new Map();
-    const add = (item) => {
-        const key = `${item.action ?? "command"}:${item.value}`;
-        if (!items.has(key))
-            items.set(key, item);
-    };
-    if (!grokSessionBound) {
-        for (const command of INK_LOCAL_SLASH_COMMANDS) {
-            add({
-                label: `/${command.name}`,
-                detail: command.description,
-                value: command.name,
-                command: `/${command.name}`,
-            });
-        }
-    }
-    for (const command of slashRegistry.list()) {
-        if (grokSessionBound && !isGrokLocalSlashCommand(command.name))
-            continue;
-        const source = command.source === "mcp" ? " :mcp" : "";
-        const sourceLabel = command.sourceLabel ? `[${command.sourceLabel}] ` : "";
-        add({
-            label: `/${command.name}${source}`,
-            detail: `${sourceLabel}${command.description}`,
-            value: command.name,
-            command: `/${command.name}`,
-        });
-    }
-    if (!grokSessionBound) {
-        for (const skill of skillRegistry.summaries()) {
-            add({
-                label: `/${skill.name} :skill`,
-                detail: `[${skill.source}] ${skill.description}`,
-                value: skill.name,
-                command: `/${skill.name}`,
-                action: "insert-skill",
-            });
-        }
-    }
-    return [...items.values()];
-}
-function buildMcpReconnectItems(mcpManager) {
-    return (mcpManager?.getStates() ?? []).map((state) => {
-        let detail;
-        if (state.status.kind === "connected") {
-            const tools = state.status.tools.length;
-            const prompts = state.status.prompts.length;
-            detail = `connected · ${tools} tool${tools === 1 ? "" : "s"} · ${prompts} prompt${prompts === 1 ? "" : "s"}`;
-        }
-        else if (state.status.kind === "failed") {
-            detail = `failed · ${state.status.error}`;
-        }
-        else {
-            detail = "disabled";
-        }
-        return {
-            label: state.name,
-            detail,
-            value: state.name,
-            command: `/mcp reconnect ${state.name}`,
-        };
-    });
-}
-function CommandPalette({ items, terminalColumns, terminalRows, onSelect, onCancel, }) {
-    return (_jsx(PalettePicker, { title: "Commands", hint: "Type to filter \u00B7 Up/Down choose \u00B7 Enter run \u00B7 Esc cancel", emptyText: "No commands found.", items: items, terminalColumns: terminalColumns, terminalRows: terminalRows, searchable: true, onSelect: onSelect, onCancel: onCancel }));
-}
-function McpReconnectPicker({ items, terminalColumns, terminalRows, onSelect, onCancel, }) {
-    return (_jsx(PalettePicker, { title: "MCP servers", hint: "Up/Down choose \u00B7 Enter or r reconnect \u00B7 Esc cancel", emptyText: "No MCP servers configured.", items: items, terminalColumns: terminalColumns, terminalRows: terminalRows, reconnectAlias: true, onSelect: onSelect, onCancel: onCancel }));
-}
-function PalettePicker({ title, hint, emptyText, items, terminalColumns, terminalRows, searchable = false, reconnectAlias = false, onSelect, onCancel, }) {
-    const theme = useTheme();
-    const [query, setQuery] = useState("");
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    const maxVisible = Math.max(5, Math.min(12, terminalRows - 10));
-    const filtered = useMemo(() => {
-        const needle = query.trim().toLowerCase();
-        if (!needle)
-            return items;
-        return items.filter((item) => item.label.toLowerCase().includes(needle) ||
-            item.detail.toLowerCase().includes(needle) ||
-            item.value.toLowerCase().includes(needle));
-    }, [items, query]);
-    useEffect(() => {
-        setSelectedIndex((current) => Math.min(Math.max(0, filtered.length - 1), current));
-    }, [filtered.length]);
-    useInput((input, key) => {
-        if (isKeyReleaseEvent(key))
-            return;
-        if (key.escape) {
-            onCancel();
-            return;
-        }
-        if (key.return || (reconnectAlias && input.toLowerCase() === "r")) {
-            const item = filtered[selectedIndex];
-            if (item)
-                onSelect(item);
-            return;
-        }
-        if (key.upArrow) {
-            setSelectedIndex((index) => Math.max(0, index - 1));
-            return;
-        }
-        if (key.downArrow) {
-            setSelectedIndex((index) => Math.min(Math.max(0, filtered.length - 1), index + 1));
-            return;
-        }
-        if (key.pageUp) {
-            setSelectedIndex((index) => Math.max(0, index - maxVisible));
-            return;
-        }
-        if (key.pageDown) {
-            setSelectedIndex((index) => Math.min(Math.max(0, filtered.length - 1), index + maxVisible));
-            return;
-        }
-        if (!searchable)
-            return;
-        if (key.backspace || key.delete) {
-            setQuery((current) => current.slice(0, -1));
-            return;
-        }
-        if (isPrintablePickerInput(input) && !key.ctrl && !key.meta) {
-            setQuery((current) => current + input);
-        }
-    });
-    const start = clampWindowStartForIndex(filtered.length, selectedIndex, maxVisible);
-    const visible = filtered.slice(start, start + maxVisible);
-    const labelWidth = Math.max(18, Math.min(36, Math.floor(terminalColumns * 0.32)));
-    const detailWidth = Math.max(20, terminalColumns - labelWidth - 10);
-    return (_jsxs(Box, { flexDirection: "column", marginY: 1, paddingX: 1, borderStyle: "round", borderColor: theme.borderActive, children: [_jsx(Text, { bold: true, color: theme.accent, children: title }), searchable && (_jsxs(Text, { color: theme.muted, children: ["Filter: ", _jsx(Text, { color: theme.userMessageText, children: query || " " })] })), _jsx(Text, { color: theme.muted, children: hint }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [filtered.length === 0 && _jsx(Text, { color: theme.muted, children: emptyText }), visible.map((item, offset) => {
-                        const actualIndex = start + offset;
-                        const selected = actualIndex === selectedIndex;
-                        return (_jsxs(Box, { children: [_jsxs(Text, { color: selected ? theme.accent : undefined, children: [selected ? "> " : "  ", truncate(item.label, labelWidth)] }), _jsxs(Text, { color: theme.muted, children: [" ", truncate(item.detail, detailWidth)] })] }, `${item.action ?? "command"}-${item.value}`));
-                    })] })] }));
-}
-const REWIND_SCOPE_ORDER = ["all", "chat", "code"];
-const REWIND_SCOPE_LABEL = {
-    all: "chat + files",
-    chat: "chat only",
-    code: "files only",
-};
-function rewindCommand(turnIndex, scope) {
-    const base = `/rewind ${turnIndex + 1}`;
-    if (scope === "chat")
-        return `${base} --chat`;
-    if (scope === "code")
-        return `${base} --code`;
-    return base;
-}
-function cycleRewindScope(scope, direction) {
-    const index = REWIND_SCOPE_ORDER.indexOf(scope);
-    return REWIND_SCOPE_ORDER[(index + direction + REWIND_SCOPE_ORDER.length) % REWIND_SCOPE_ORDER.length];
-}
-function RewindPicker({ sessionManager, terminalColumns, terminalRows, onSelect, onCancel, }) {
-    const theme = useTheme();
-    const turns = useMemo(() => sessionManager.listUserTurns(), [sessionManager]);
-    const checkpoints = useMemo(() => sessionManager.getCheckpoints(), [sessionManager]);
-    const fileCounts = useMemo(() => {
-        const entries = checkpoints.listEntries();
-        const byTurn = new Map();
-        for (const entry of entries) {
-            const files = byTurn.get(entry.turn);
-            if (files)
-                files.add(entry.path);
-            else
-                byTurn.set(entry.turn, new Set([entry.path]));
-        }
-        return new Map(turns.map((turn) => [turn.id, byTurn.get(turn.id)?.size ?? 0]));
-    }, [checkpoints, turns]);
-    const [selectedIndex, setSelectedIndex] = useState(() => Math.max(0, turns.length - 1));
-    const [scope, setScope] = useState("all");
-    const maxVisible = Math.max(4, Math.min(10, terminalRows - 10));
-    useEffect(() => {
-        setSelectedIndex((current) => Math.min(Math.max(0, turns.length - 1), current));
-    }, [turns.length]);
-    useInput((input, key) => {
-        if (isKeyReleaseEvent(key))
-            return;
-        if (key.escape) {
-            onCancel();
-            return;
-        }
-        if (key.return) {
-            if (turns[selectedIndex])
-                onSelect(rewindCommand(selectedIndex, scope));
-            return;
-        }
-        if (key.upArrow) {
-            setSelectedIndex((index) => Math.max(0, index - 1));
-            return;
-        }
-        if (key.downArrow) {
-            setSelectedIndex((index) => Math.min(Math.max(0, turns.length - 1), index + 1));
-            return;
-        }
-        if (key.pageUp) {
-            setSelectedIndex((index) => Math.max(0, index - maxVisible));
-            return;
-        }
-        if (key.pageDown) {
-            setSelectedIndex((index) => Math.min(Math.max(0, turns.length - 1), index + maxVisible));
-            return;
-        }
-        if (key.tab || key.rightArrow || input === "l") {
-            setScope((current) => cycleRewindScope(current, 1));
-            return;
-        }
-        if (key.leftArrow || input === "h") {
-            setScope((current) => cycleRewindScope(current, -1));
-        }
-    });
-    const start = clampWindowStartForIndex(turns.length, selectedIndex, maxVisible);
-    const visibleTurns = turns.slice(start, start + maxVisible);
-    const previewWidth = Math.max(18, Math.min(76, terminalColumns - 34));
-    return (_jsxs(Box, { flexDirection: "column", marginY: 1, paddingX: 1, borderStyle: "round", borderColor: theme.borderActive, children: [_jsx(Text, { bold: true, color: theme.accent, children: "Rewind" }), _jsxs(Text, { color: theme.muted, children: ["Restore: ", _jsx(Text, { color: theme.accent, children: REWIND_SCOPE_LABEL[scope] }), "  ·  ", turns.length, " point", turns.length === 1 ? "" : "s"] }), _jsx(Text, { color: theme.muted, children: "Up/Down choose \u00B7 Left/Right scope \u00B7 Enter rewind \u00B7 Esc cancel" }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [turns.length === 0 && _jsx(Text, { color: theme.muted, children: "Nothing to rewind: no user messages in this session." }), visibleTurns.map((turn, offset) => {
-                        const actualIndex = start + offset;
-                        const isSelected = actualIndex === selectedIndex;
-                        const touched = fileCounts.get(turn.id) ?? 0;
-                        return (_jsx(RewindRow, { turn: turn, turnNumber: actualIndex + 1, selected: isSelected, fileCount: touched, previewWidth: previewWidth }, turn.id));
-                    })] })] }));
-}
-function RewindRow({ turn, turnNumber, selected, fileCount, previewWidth, }) {
-    const theme = useTheme();
-    const time = new Date(turn.timestamp).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
-    const fileNote = fileCount > 0 ? ` · ${fileCount} file${fileCount === 1 ? "" : "s"}` : "";
-    return (_jsxs(Box, { children: [_jsxs(Text, { color: selected ? theme.accent : undefined, children: [selected ? "> " : "  ", String(turnNumber).padStart(2, " "), " ", time, " ", truncate(turn.preview, previewWidth)] }), _jsx(Text, { color: theme.muted, children: fileNote })] }));
-}
-function clampWindowStartForIndex(total, selectedIndex, maxVisible) {
-    if (total <= maxVisible)
-        return 0;
-    const half = Math.floor(maxVisible / 2);
-    let start = Math.max(0, selectedIndex - half);
-    if (start + maxVisible > total)
-        start = total - maxVisible;
-    return Math.max(0, start);
-}
-function StatsPanel({ panel, terminalColumns, terminalRows, onRangeChange, onCancel, }) {
-    const theme = useTheme();
-    const [scroll, setScroll] = useState(0);
-    const bodyWidth = Math.max(48, Math.min(92, terminalColumns - 6));
-    const lines = useMemo(() => formatStatsPanelBody(panel.bundle.ranges[panel.range], bodyWidth).split("\n"), [bodyWidth, panel.bundle, panel.range]);
-    const maxVisible = Math.max(5, Math.min(16, terminalRows - 10));
-    const maxScroll = Math.max(0, lines.length - maxVisible);
-    useEffect(() => {
-        setScroll(0);
-    }, [panel.range]);
-    useEffect(() => {
-        setScroll((current) => Math.min(current, maxScroll));
-    }, [maxScroll]);
-    useInput((input, key) => {
-        if (isKeyReleaseEvent(key))
-            return;
-        if (key.escape) {
-            onCancel();
-            return;
-        }
-        if (key.tab) {
-            onRangeChange(panel.range === "30d" ? "7d" : "30d");
-            return;
-        }
-        if (key.leftArrow || input === "h") {
-            onRangeChange("7d");
-            return;
-        }
-        if (key.rightArrow || input === "l") {
-            onRangeChange("30d");
-            return;
-        }
-        if (key.upArrow) {
-            setScroll((current) => Math.max(0, current - 1));
-            return;
-        }
-        if (key.downArrow) {
-            setScroll((current) => Math.min(maxScroll, current + 1));
-            return;
-        }
-        if (key.pageUp) {
-            setScroll((current) => Math.max(0, current - maxVisible));
-            return;
-        }
-        if (key.pageDown) {
-            setScroll((current) => Math.min(maxScroll, current + maxVisible));
-        }
-    });
-    const visible = lines.slice(scroll, scroll + maxVisible);
-    const generatedAt = panel.bundle.generatedAt.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
-    return (_jsxs(Box, { flexDirection: "column", marginY: 1, paddingX: 1, borderStyle: "round", borderColor: theme.borderActive, children: [_jsx(Text, { bold: true, color: theme.accent, children: "Stats" }), _jsxs(Text, { color: theme.muted, children: [rangeLabel(panel.range), " \u00B7 generated ", generatedAt] }), _jsx(Text, { color: theme.muted, children: "Left/Right range \u00B7 Up/Down scroll \u00B7 Tab toggle \u00B7 Esc close" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: visible.map((line, index) => {
-                    const key = `${scroll + index}-${line}`;
-                    const heading = line === "Activity" || line === "Model usage" || line === "Summary";
-                    return (_jsx(Text, { color: heading ? theme.accent : undefined, bold: heading, children: line || " " }, key));
-                }) }), maxScroll > 0 && (_jsxs(Text, { color: theme.muted, children: [scroll + 1, "-", Math.min(lines.length, scroll + maxVisible), " of ", lines.length] }))] }));
-}
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const GENERIC_PHRASES = [
-    "mapping the workspace",
-    "reading the room",
-    "following the threads",
-    "connecting the pieces",
-    "sorting the context",
-    "scanning the structure",
-    "shaping the next step",
-    "gathering signal",
-    "checking the edges",
-    "lining up the answer",
-    "tracing the flow",
-    "building the picture",
-    "walking the graph",
-    "collecting the clues",
-    "framing the problem",
-    "locating the source",
-    "resolving the shape",
-    "untangling the state",
-    "comparing the paths",
-    "narrowing the target",
-    "tracking the changes",
-    "reading the patterns",
-    "weighing the options",
-    "assembling the context",
-    "following the signal",
-    "checking the assumptions",
-    "aligning the details",
-    "testing the shape",
-    "pulling the thread",
-    "cleaning the edges",
-    "refining the draft",
-    "verifying the route",
-    "making sense of it",
-    "looking for leverage",
-    "stitching the answer",
-    "holding the thread",
-    "distilling the noise",
-    "finding the seam",
-    "reading between the lines",
-    "preparing the response",
-];
-const TOOL_TARGET_PHRASES = {
-    read: "reading files",
-    write: "writing changes",
-    edit: "patching files",
-    grep: "searching the codebase",
-    glob: "scanning paths",
-    ls: "listing directories",
-    bash: "running command",
-    web_search: "searching the web",
-    web_fetch: "fetching a page",
-    task: "spawning subagent",
-};
-function formatTokensApprox(chars) {
-    const tokens = Math.max(0, Math.round(chars / 4));
-    if (tokens < 1000)
-        return `${tokens}`;
-    if (tokens < 10000)
-        return `${(tokens / 1000).toFixed(1)}k`;
-    return `${Math.round(tokens / 1000)}k`;
-}
-function WaitingIndicator({ tools, hasStreamingText, hasStreamingReasoning, streamedChars, nowTick, pendingSteerCount = 0, queuedCount = 0, }) {
-    void nowTick;
-    const theme = useTheme();
-    const [frameIndex, setFrameIndex] = useState(0);
-    const [idlePhrase, setIdlePhrase] = useState(() => GENERIC_PHRASES[0]);
-    // Frame timer is independent of the agent state — keeps animation smooth.
-    useEffect(() => {
-        const t = setInterval(() => {
-            setFrameIndex((i) => (i + 1) % SPINNER_FRAMES.length);
-        }, 100);
-        return () => clearInterval(t);
-    }, []);
-    // Determine state: active tool > streaming text > streaming reasoning > idle
-    const activeTool = [...tools].reverse().find((t) => !t.result);
-    const state = activeTool
-        ? "tool"
-        : hasStreamingText
-            ? "text"
-            : hasStreamingReasoning
-                ? "reasoning"
-                : "idle";
-    // Rotate idle phrases on a slower cadence; only matters in the idle state.
-    useEffect(() => {
-        if (state !== "idle")
-            return;
-        const t = setInterval(() => {
-            setIdlePhrase((current) => {
-                const candidates = GENERIC_PHRASES.filter((item) => item !== current);
-                return candidates[Math.floor(Math.random() * candidates.length)] || current;
-            });
-        }, 1500);
-        return () => clearInterval(t);
-    }, [state]);
-    let phrase;
-    if (state === "tool" && activeTool) {
-        phrase =
-            TOOL_TARGET_PHRASES[activeTool.name] || `running ${activeTool.name}`;
-    }
-    else if (state === "text") {
-        phrase = "writing the response";
-    }
-    else if (state === "reasoning") {
-        phrase = "working through the request";
-    }
-    else {
-        phrase = idlePhrase;
-    }
-    const tokenText = streamedChars > 0 ? `↓${formatTokensApprox(streamedChars)} tok` : "";
-    const hintParts = [];
-    if (tokenText)
-        hintParts.push(tokenText);
-    if (pendingSteerCount > 0)
-        hintParts.push(`${pendingSteerCount} pending steer${pendingSteerCount === 1 ? "" : "s"}`);
-    if (queuedCount > 0)
-        hintParts.push(`${queuedCount} queued`);
-    hintParts.push("enter steer", "tab queue", "esc stop");
-    return (_jsxs(Box, { children: [_jsx(Text, { color: theme.accent, children: SPINNER_FRAMES[frameIndex] }), _jsxs(Text, { color: theme.muted, children: [" ", phrase, " "] }), _jsxs(Text, { color: theme.muted, dimColor: true, children: ["(", hintParts.join(" · "), ")"] })] }));
-}