@prestyj/cli 4.2.56 → 4.2.75

package/dist/ui/App.js

@@ -27,8 +27,9 @@ import { TaskOverlay } from "./components/TaskOverlay.js";
 import { SkillsOverlay } from "./components/SkillsOverlay.js";
 import { BackgroundTasksBar } from "./components/BackgroundTasksBar.js";
 import { useTheme } from "./theme/theme.js";
-import { useAnimationTick, deriveFrame } from "./components/AnimationContext.js";
+import { useAnimationTick, useAnimationActive, deriveFrame, } from "./components/AnimationContext.js";
 import { useTerminalTitle } from "./hooks/useTerminalTitle.js";
+import { useTerminalProgress } from "./hooks/useTerminalProgress.js";
 import { getGitBranch } from "../utils/git.js";
 import { getModel, getContextWindow } from "../core/model-registry.js";
 import { SessionManager } from "../core/session-manager.js";
@@ -39,8 +40,10 @@ import { estimateConversationTokens } from "../core/compaction/token-estimator.j
 import { PROMPT_COMMANDS, getPromptCommand } from "../core/prompt-commands.js";
 import { loadCustomCommands } from "../core/custom-commands.js";
 import { buildSystemPrompt } from "../system-prompt.js";
+import { extractPlanSteps, findCompletedMarkers, markStepsCompleted, stripDoneMarkers, } from "../utils/plan-steps.js";
 import { getMCPServers } from "../core/mcp/index.js";
 import { trimFlushedItems, flushOnTurnText, flushOnTurnEnd } from "./live-item-flush.js";
+import { Buddy } from "./buddy/Buddy.js";
 // ── Provider Error Hints ──────────────────────────────────
 /** Detect provider-side errors and return a user-facing hint. */
 function getProviderErrorHint(message) {
@@ -102,6 +105,41 @@ function compactHistory(items) {
     return compacted;
 }
 // flushOnTurnText, flushOnTurnEnd are imported from ./live-item-flush.ts
+/** Check whether an item is still active (running spinner, pending result). */
+function isActiveItem(item) {
+    switch (item.kind) {
+        case "tool_start":
+        case "server_tool_start":
+        case "compacting":
+            return true;
+        case "tool_group":
+            return item.tools.some((t) => t.status === "running");
+        case "subagent_group":
+            return item.agents.some((a) => a.status === "running");
+        default:
+            return false;
+    }
+}
+/**
+ * Partition live items into completed (flushable to Static) and still-active.
+ * Completed items precede active ones — we flush the longest contiguous prefix
+ * of completed items to keep ordering stable.
+ */
+function partitionCompleted(items) {
+    // Find the first active item — everything before it is safe to flush
+    const firstActiveIdx = items.findIndex(isActiveItem);
+    if (firstActiveIdx === -1) {
+        // All items are completed
+        return { flushed: items, remaining: [] };
+    }
+    if (firstActiveIdx === 0) {
+        return { flushed: [], remaining: items };
+    }
+    return {
+        flushed: items.slice(0, firstActiveIdx),
+        remaining: items.slice(firstActiveIdx),
+    };
+}
 // ── Duration summary ─────────────────────────────────────
 function formatDuration(ms) {
     const totalSec = Math.round(ms / 1000);
@@ -276,10 +314,16 @@ export function App(props) {
     const messagesRef = useRef(props.messages);
     const [planAutoExpand, setPlanAutoExpand] = useState(false);
     const approvedPlanPathRef = useRef(undefined);
+    const planStepsRef = useRef([]);
+    const [planSteps, setPlanSteps] = useState([]);
     const nextIdRef = useRef(0);
     const sessionManagerRef = useRef(props.sessionsDir ? new SessionManager(props.sessionsDir) : null);
     const sessionPathRef = useRef(props.sessionPath);
     const persistedIndexRef = useRef(messagesRef.current.length);
+    /** Last actual API-reported input token count (from turn_end). */
+    const lastActualTokensRef = useRef(0);
+    /** Timestamp of last compaction — used for time-based cooldown. */
+    const lastCompactionTimeRef = useRef(0);
     const getId = () => String(nextIdRef.current++);
     // Two-phase flush: items waiting to be moved to Static history after the
     // live area has been cleared and Ink has committed the smaller output.
@@ -379,13 +423,15 @@ export function App(props) {
         persistedIndexRef.current = allMsgs.length;
     }, []);
     // ── Compaction ─────────────────────────────────────────
-    // Load settings for auto-compaction
+    // Load settings for auto-compaction + buddy
     const settingsRef = useRef(null);
+    const [buddyEnabled, setBuddyEnabled] = useState(false);
     useEffect(() => {
         if (props.settingsFile) {
             const sm = new SettingsManager(props.settingsFile);
             sm.load().then(() => {
                 settingsRef.current = sm;
+                setBuddyEnabled(sm.get("buddyEnabled") ?? false);
             });
         }
     }, [props.settingsFile]);
@@ -442,6 +488,11 @@ export function App(props) {
      * transformContext callback for the agent loop.
      * Called before each LLM call and on context overflow.
      * Checks if auto-compaction is needed and runs it.
+     *
+     * Uses actual API-reported token counts (from previous turn_end) when
+     * available, falling back to the character-based estimate. A 30-second
+     * cooldown prevents repeated compaction — matching the pattern used by
+     * Mysti, openclaw, and other real-world agent frameworks.
      */
     const transformContext = useCallback(async (messages, options) => {
         const settings = settingsRef.current;
@@ -449,13 +500,26 @@ export function App(props) {
         const threshold = settings?.get("compactThreshold") ?? 0.8;
         // Force-compact on context overflow regardless of settings
         if (options?.force) {
-            return compactConversation(messages);
+            const result = await compactConversation(messages);
+            lastCompactionTimeRef.current = Date.now();
+            lastActualTokensRef.current = 0; // Reset stale pre-compaction count
+            return result;
         }
         if (!autoCompact)
             return messages;
+        // Time-based cooldown: skip if compaction ran within the last 30 seconds
+        if (Date.now() - lastCompactionTimeRef.current < 30_000) {
+            log("INFO", "compaction", `Skipping compaction — cooldown active`);
+            return messages;
+        }
         const contextWindow = getContextWindow(currentModel);
-        if (shouldCompact(messages, contextWindow, threshold)) {
-            return compactConversation(messages);
+        // Prefer actual API-reported tokens over char-based estimate
+        const actualTokens = lastActualTokensRef.current > 0 ? lastActualTokensRef.current : undefined;
+        if (shouldCompact(messages, contextWindow, threshold, actualTokens)) {
+            const result = await compactConversation(messages);
+            lastCompactionTimeRef.current = Date.now();
+            lastActualTokensRef.current = 0; // Reset stale pre-compaction count
+            return result;
         }
         return messages;
     }, [currentModel, compactConversation]);
@@ -535,8 +599,33 @@ export function App(props) {
     }, {
         onComplete: useCallback(() => {
             persistNewMessages();
-        }, [persistNewMessages]),
+            // Auto-clear plan progress and approved plan when all steps are completed
+            const steps = planStepsRef.current;
+            if (steps.length > 0 && steps.every((s) => s.completed)) {
+                planStepsRef.current = [];
+                setPlanSteps([]);
+                approvedPlanPathRef.current = undefined;
+                // Rebuild system prompt to remove the completed plan from context
+                void (async () => {
+                    const newPrompt = await buildSystemPrompt(props.cwd, props.skills, planMode, undefined);
+                    if (messagesRef.current[0]?.role === "system") {
+                        messagesRef.current[0] = { role: "system", content: newPrompt };
+                    }
+                })();
+            }
+        }, [persistNewMessages, planMode, props.cwd, props.skills]),
         onTurnText: useCallback((text, thinking, thinkingMs) => {
+            // Track [DONE:n] markers for plan step progress
+            if (planStepsRef.current.length > 0) {
+                const completed = findCompletedMarkers(text);
+                if (completed.size > 0) {
+                    const updated = markStepsCompleted(planStepsRef.current, completed);
+                    if (updated !== planStepsRef.current) {
+                        planStepsRef.current = updated;
+                        setPlanSteps(updated);
+                    }
+                }
+            }
             // Flush all completed items from the previous turn to Static history.
             // This keeps liveItems bounded per-turn, preventing Ink's live area from
             // growing unbounded, which makes Ink's live-area re-renders expensive.
@@ -545,11 +634,22 @@ export function App(props) {
                 if (flushed.length > 0) {
                     setHistory((h) => compactHistory([...h, ...trimFlushedItems(flushed)]));
                 }
-                return [{ kind: "assistant", text, thinking, thinkingMs, id: getId() }];
+                const displayText = planStepsRef.current.length > 0 ? stripDoneMarkers(text) : text;
+                return [{ kind: "assistant", text: displayText, thinking, thinkingMs, id: getId() }];
             });
         }, []),
         onToolStart: useCallback((toolCallId, name, args) => {
             log("INFO", "tool", `Tool call started: ${name}`, { id: toolCallId });
+            // Flush completed items (assistant text, finished tools) to Static
+            // before adding tool UI. Keeping both in the live area makes it tall
+            // and causes Ink's cursor math to clip the top.
+            setLiveItems((prev) => {
+                const { flushed, remaining } = partitionCompleted(prev);
+                if (flushed.length > 0) {
+                    setHistory((h) => compactHistory([...h, ...trimFlushedItems(flushed)]));
+                }
+                return remaining;
+            });
             if (name === "subagent") {
                 // Create or update the sub-agent group item
                 const newAgent = {
@@ -656,7 +756,12 @@ export function App(props) {
                     };
                     const next = [...prev];
                     next[groupIdx] = { ...group, agents: updatedAgents };
-                    return next;
+                    // Flush completed items to Static to keep the live area small
+                    const { flushed, remaining } = partitionCompleted(next);
+                    if (flushed.length > 0) {
+                        setHistory((h) => compactHistory([...h, ...trimFlushedItems(flushed)]));
+                    }
+                    return remaining;
                 });
             }
             else {
@@ -664,59 +769,87 @@ export function App(props) {
                     // Check if this tool is in a tool_group
                     const groupIdx = prev.findIndex((item) => item.kind === "tool_group" &&
                         item.tools.some((t) => t.toolCallId === toolCallId));
+                    let updated;
                     if (groupIdx !== -1) {
                         const group = prev[groupIdx];
-                        const next = [...prev];
-                        next[groupIdx] = {
+                        updated = [...prev];
+                        updated[groupIdx] = {
                             ...group,
                             tools: group.tools.map((t) => t.toolCallId === toolCallId
                                 ? { ...t, status: "done", result, isError }
                                 : t),
                         };
-                        return next;
                     }
-                    // Find the matching tool_start and replace it with tool_done
-                    const startIdx = prev.findIndex((item) => item.kind === "tool_start" && item.toolCallId === toolCallId);
-                    if (startIdx !== -1) {
-                        const startItem = prev[startIdx];
-                        const doneItem = {
-                            kind: "tool_done",
-                            name,
-                            args: startItem.args,
-                            result,
-                            isError,
-                            durationMs,
-                            id: startItem.id,
-                        };
-                        const next = [...prev];
-                        next[startIdx] = doneItem;
-                        return next;
+                    else {
+                        // Find the matching tool_start and replace it with tool_done
+                        const startIdx = prev.findIndex((item) => item.kind === "tool_start" && item.toolCallId === toolCallId);
+                        if (startIdx !== -1) {
+                            const startItem = prev[startIdx];
+                            const doneItem = {
+                                kind: "tool_done",
+                                name,
+                                args: startItem.args,
+                                result,
+                                isError,
+                                durationMs,
+                                details,
+                                id: startItem.id,
+                            };
+                            updated = [...prev];
+                            updated[startIdx] = doneItem;
+                        }
+                        else {
+                            // Fallback: just append
+                            updated = [
+                                ...prev,
+                                {
+                                    kind: "tool_done",
+                                    name,
+                                    args: {},
+                                    result,
+                                    isError,
+                                    durationMs,
+                                    details,
+                                    id: getId(),
+                                },
+                            ];
+                        }
                     }
-                    // Fallback: just append
-                    return [
-                        ...prev,
-                        { kind: "tool_done", name, args: {}, result, isError, durationMs, id: getId() },
-                    ];
+                    // Flush completed items to Static to keep the live area small
+                    const { flushed, remaining } = partitionCompleted(updated);
+                    if (flushed.length > 0) {
+                        setHistory((h) => compactHistory([...h, ...trimFlushedItems(flushed)]));
+                    }
+                    return remaining;
                 });
             }
         }, []),
         onServerToolCall: useCallback((id, name, input) => {
             log("INFO", "server_tool", `Server tool call: ${name}`, { id });
-            setLiveItems((prev) => [
-                ...prev,
-                {
-                    kind: "server_tool_start",
-                    serverToolCallId: id,
-                    name,
-                    input,
-                    startedAt: Date.now(),
-                    id: getId(),
-                },
-            ]);
+            // Flush completed items (including assistant text) to Static before
+            // adding server tool UI — same rationale as onToolStart.
+            setLiveItems((prev) => {
+                const { flushed, remaining } = partitionCompleted(prev);
+                if (flushed.length > 0) {
+                    setHistory((h) => compactHistory([...h, ...trimFlushedItems(flushed)]));
+                }
+                return [
+                    ...remaining,
+                    {
+                        kind: "server_tool_start",
+                        serverToolCallId: id,
+                        name,
+                        input,
+                        startedAt: Date.now(),
+                        id: getId(),
+                    },
+                ];
+            });
         }, []),
         onServerToolResult: useCallback((toolUseId, resultType, data) => {
             log("INFO", "server_tool", `Server tool result`, { toolUseId, resultType });
             setLiveItems((prev) => {
+                let updated;
                 const startIdx = prev.findIndex((item) => item.kind === "server_tool_start" && item.serverToolCallId === toolUseId);
                 if (startIdx !== -1) {
                     const startItem = prev[startIdx];
@@ -729,22 +862,29 @@ export function App(props) {
                         durationMs: Date.now() - startItem.startedAt,
                         id: startItem.id,
                     };
-                    const next = [...prev];
-                    next[startIdx] = doneItem;
-                    return next;
+                    updated = [...prev];
+                    updated[startIdx] = doneItem;
                 }
-                return [
-                    ...prev,
-                    {
-                        kind: "server_tool_done",
-                        name: "unknown",
-                        input: {},
-                        resultType,
-                        data,
-                        durationMs: 0,
-                        id: getId(),
-                    },
-                ];
+                else {
+                    updated = [
+                        ...prev,
+                        {
+                            kind: "server_tool_done",
+                            name: "unknown",
+                            input: {},
+                            resultType,
+                            data,
+                            durationMs: 0,
+                            id: getId(),
+                        },
+                    ];
+                }
+                // Flush completed items to Static
+                const { flushed, remaining } = partitionCompleted(updated);
+                if (flushed.length > 0) {
+                    setHistory((h) => compactHistory([...h, ...trimFlushedItems(flushed)]));
+                }
+                return remaining;
             });
         }, []),
         onTurnEnd: useCallback((turn, stopReason, usage) => {
@@ -755,6 +895,9 @@ export function App(props) {
                 ...(usage.cacheRead != null && { cacheRead: String(usage.cacheRead) }),
                 ...(usage.cacheWrite != null && { cacheWrite: String(usage.cacheWrite) }),
             });
+            // Track actual token count for compaction decisions
+            lastActualTokensRef.current =
+                usage.inputTokens + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
             // For tool-only turns (no text), flush completed items to Static so
             // liveItems doesn't grow unbounded across consecutive tool-only turns.
             setLiveItems((prev) => {
@@ -901,7 +1044,10 @@ export function App(props) {
         setTitleRunning(agentLoop.isRunning);
         setTitleToolNames(agentLoop.activeToolCalls.map((tc) => tc.name));
     }, [agentLoop.activityPhase, agentLoop.isRunning, activeToolNamesKey]);
+    // Terminal progress bar (OSC 9;4) — pulsing bar in supported terminals
+    useTerminalProgress(agentLoop.isRunning, agentLoop.activeToolCalls.length > 0);
     // Animated thinking border — derived from global animation tick
+    useAnimationActive();
     const animTick = useAnimationTick();
     const thinkingBorderFrame = agentLoop.activityPhase === "thinking"
         ? deriveFrame(animTick, 1000, THINKING_BORDER_COLORS.length)
@@ -941,7 +1087,14 @@ export function App(props) {
             setHistory([{ kind: "banner", id: "banner" }]);
             setLiveItems([]);
             setDoneStatus(null);
-            messagesRef.current = messagesRef.current.slice(0, 1); // keep system prompt
+            approvedPlanPathRef.current = undefined;
+            planStepsRef.current = [];
+            setPlanSteps([]);
+            // Rebuild system prompt without the approved plan
+            void (async () => {
+                const newPrompt = await buildSystemPrompt(props.cwd, props.skills, planMode, undefined);
+                messagesRef.current = [{ role: "system", content: newPrompt }];
+            })();
             agentLoop.reset();
             setLiveItems([{ kind: "info", text: "Session cleared.", id: getId() }]);
             return;
@@ -968,6 +1121,40 @@ export function App(props) {
             ]);
             return;
         }
+        // Handle /clearplan — dismiss the approved plan
+        if (trimmed === "/clearplan") {
+            approvedPlanPathRef.current = undefined;
+            planStepsRef.current = [];
+            setPlanSteps([]);
+            // Rebuild system prompt without the plan
+            void (async () => {
+                const newPrompt = await buildSystemPrompt(props.cwd, props.skills, planMode, undefined);
+                if (messagesRef.current[0]?.role === "system") {
+                    messagesRef.current[0] = { role: "system", content: newPrompt };
+                }
+            })();
+            setLiveItems([{ kind: "info", text: "Approved plan dismissed.", id: getId() }]);
+            return;
+        }
+        // Handle /buddy — toggle companion
+        if (trimmed === "/buddy") {
+            const next = !buddyEnabled;
+            setBuddyEnabled(next);
+            if (settingsRef.current) {
+                settingsRef.current.set("buddyEnabled", next);
+            }
+            setLiveItems((items) => [
+                ...items,
+                {
+                    kind: "info",
+                    text: next
+                        ? "Buddy enabled! Your companion will appear near the prompt."
+                        : "Buddy disabled.",
+                    id: getId(),
+                },
+            ]);
+            return;
+        }
         // Handle /plans — open plan pane
         if (trimmed === "/plans") {
             stdout?.write("\x1b[2J\x1b[3J\x1b[H");
@@ -1113,6 +1300,12 @@ export function App(props) {
         };
         setLastUserMessage(input);
         setDoneStatus(null);
+        // Clear stale plan progress if there's no active approved plan
+        // (avoids lingering progress from a completed or abandoned plan run)
+        if (planStepsRef.current.length > 0 && !approvedPlanPathRef.current) {
+            planStepsRef.current = [];
+            setPlanSteps([]);
+        }
         setLiveItems([userItem]);
         // Run agent
         try {
@@ -1249,7 +1442,7 @@ export function App(props) {
             case "tool_start":
                 return _jsx(ToolExecution, { status: "running", name: item.name, args: item.args }, item.id);
             case "tool_done":
-                return (_jsx(ToolExecution, { status: "done", name: item.name, args: item.args, result: item.result, isError: item.isError }, item.id));
+                return (_jsx(ToolExecution, { status: "done", name: item.name, args: item.args, result: item.result, isError: item.isError, details: item.details }, item.id));
             case "tool_group":
                 return _jsx(ToolGroupExecution, { tools: item.tools }, item.id);
             case "server_tool_start":
@@ -1361,6 +1554,12 @@ export function App(props) {
                 }, onApprove: (planPath) => {
                     // Store approved plan path — will be injected into the new system prompt
                     approvedPlanPathRef.current = planPath;
+                    // Extract plan steps for progress tracking
+                    void import("node:fs/promises").then(({ readFile }) => readFile(planPath, "utf-8").then((content) => {
+                        const steps = extractPlanSteps(content);
+                        planStepsRef.current = steps;
+                        setPlanSteps(steps);
+                    }));
                     // Clear session for a fresh context focused on the plan
                     stdout?.write("\x1b[2J\x1b[3J\x1b[H");
                     setHistory([{ kind: "banner", id: "banner" }]);
@@ -1407,7 +1606,7 @@ export function App(props) {
                     void agentLoop.run(msg);
                 } })) : (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, paddingRight: 1, children: [liveItems.map((item) => renderItem(item)), _jsx(StreamingArea, { isRunning: agentLoop.isRunning, streamingText: agentLoop.streamingText, streamingThinking: agentLoop.streamingThinking, showThinking: props.showThinking, thinkingMs: agentLoop.thinkingMs, planMode: planMode })] }), agentLoop.isRunning && agentLoop.activityPhase !== "idle" ? (_jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: agentLoop.activityPhase === "thinking"
                             ? THINKING_BORDER_COLORS[thinkingBorderFrame]
-                            : "transparent", paddingLeft: 1, paddingRight: 1, width: columns, children: _jsx(ActivityIndicator, { phase: agentLoop.activityPhase, elapsedMs: agentLoop.elapsedMs, thinkingMs: agentLoop.thinkingMs, isThinking: agentLoop.isThinking, tokenEstimate: agentLoop.streamedTokenEstimate, userMessage: lastUserMessage, activeToolNames: agentLoop.activeToolCalls.map((tc) => tc.name), planMode: planMode }) })) : (doneStatus && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.success, children: ["✻ ", doneStatus.verb, " ", formatDuration(doneStatus.durationMs)] }) }))), agentLoop.queuedCount > 0 && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.accent, children: ["⏳ ", agentLoop.queuedCount, " message", agentLoop.queuedCount > 1 ? "s" : "", " queued"] }) })), _jsx(InputArea, { onSubmit: handleSubmit, onAbort: handleAbort, disabled: agentLoop.isRunning, isActive: !taskBarFocused && !overlay, onDownAtEnd: handleFocusTaskBar, onShiftTab: handleToggleThinking, onToggleTasks: () => {
+                            : "transparent", paddingLeft: 1, paddingRight: 1, width: columns, children: _jsx(ActivityIndicator, { phase: agentLoop.activityPhase, elapsedMs: agentLoop.elapsedMs, thinkingMs: agentLoop.thinkingMs, isThinking: agentLoop.isThinking, tokenEstimate: agentLoop.streamedTokenEstimate, charCountRef: agentLoop.charCountRef, realTokensAccumRef: agentLoop.realTokensAccumRef, userMessage: lastUserMessage, activeToolNames: agentLoop.activeToolCalls.map((tc) => tc.name), planMode: planMode, retryInfo: agentLoop.retryInfo, planDone: planSteps.filter((s) => s.completed).length, planTotal: planSteps.length }) })) : (doneStatus && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.success, children: ["✻ ", doneStatus.verb, " ", formatDuration(doneStatus.durationMs)] }) }))), agentLoop.queuedCount > 0 && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.accent, children: ["⏳ ", agentLoop.queuedCount, " message", agentLoop.queuedCount > 1 ? "s" : "", " queued"] }) })), _jsx(InputArea, { onSubmit: handleSubmit, onAbort: handleAbort, disabled: agentLoop.isRunning, isActive: !taskBarFocused && !overlay, onDownAtEnd: handleFocusTaskBar, onShiftTab: handleToggleThinking, onToggleTasks: () => {
                             stdout?.write("\x1b[2J\x1b[3J\x1b[H");
                             setOverlay("tasks");
                         }, onToggleSkills: () => {
@@ -1426,6 +1625,6 @@ export function App(props) {
                                     id: getId(),
                                 },
                             ]);
-                        }, cwd: props.cwd, commands: allCommands }), overlay === "model" ? (_jsx(ModelSelector, { onSelect: handleModelSelect, onCancel: () => setOverlay(null), loggedInProviders: props.loggedInProviders ?? [currentProvider], currentModel: currentModel, currentProvider: currentProvider })) : (_jsx(Footer, { model: currentModel, tokensIn: agentLoop.contextUsed, cwd: props.cwd, gitBranch: gitBranch, thinkingEnabled: thinkingEnabled, planMode: planMode })), bgTasks.length > 0 && (_jsx(BackgroundTasksBar, { tasks: bgTasks, focused: taskBarFocused, expanded: taskBarExpanded, selectedIndex: selectedTaskIndex, onExpand: handleTaskBarExpand, onCollapse: handleTaskBarCollapse, onKill: handleTaskKill, onExit: handleTaskBarExit, onNavigate: handleTaskNavigate }))] }))] }));
+                        }, cwd: props.cwd, commands: allCommands }), overlay === "model" ? (_jsx(ModelSelector, { onSelect: handleModelSelect, onCancel: () => setOverlay(null), loggedInProviders: props.loggedInProviders ?? [currentProvider], currentModel: currentModel, currentProvider: currentProvider })) : (_jsx(Footer, { model: currentModel, tokensIn: agentLoop.contextUsed, linesAdded: agentLoop.linesChanged.added, linesRemoved: agentLoop.linesChanged.removed, cwd: props.cwd, gitBranch: gitBranch, thinkingEnabled: thinkingEnabled, planMode: planMode })), buddyEnabled && _jsx(Buddy, { phase: agentLoop.activityPhase }), bgTasks.length > 0 && (_jsx(BackgroundTasksBar, { tasks: bgTasks, focused: taskBarFocused, expanded: taskBarExpanded, selectedIndex: selectedTaskIndex, onExpand: handleTaskBarExpand, onCollapse: handleTaskBarCollapse, onKill: handleTaskKill, onExit: handleTaskBarExit, onNavigate: handleTaskNavigate }))] }))] }));
 }
 //# sourceMappingURL=App.js.map