deepagentsdk 0.11.1 → 0.13.0

package/dist/cli/index.mjs

@@ -0,0 +1,3120 @@
+#!/usr/bin/env bun
+import { St as init_limits, _t as DEFAULT_EVICTION_TOKEN_LIMIT, bt as DEFAULT_SUMMARIZATION_THRESHOLD, gt as CONTEXT_WINDOW, l as estimateMessagesTokens, n as parseModelString, o as createDeepAgent, r as LocalSandbox, t as FileSaver, vt as DEFAULT_KEEP_MESSAGES } from "../file-saver-Hj5so3dV.mjs";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, render, useApp, useInput } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Badge, Spinner, StatusMessage } from "@inkjs/ui";
+
+//#region src/cli/hooks/useAgent.ts
+init_limits();
+/**
+* Hook for managing agent streaming and events.
+*/
+let eventCounter = 0;
+function createEventId() {
+	return `event-${++eventCounter}`;
+}
+const DEFAULT_CLI_INTERRUPT_ON = {
+	execute: true,
+	write_file: true,
+	edit_file: true,
+	web_search: true,
+	fetch_url: true
+};
+function useAgent(options) {
+	const [status, setStatus] = useState("idle");
+	const [streamingText, setStreamingText] = useState("");
+	const [lastCompletedText, setLastCompletedText] = useState("");
+	const [events, setEvents] = useState([]);
+	const [state, setState] = useState({
+		todos: [],
+		files: {}
+	});
+	const [messages, setMessages] = useState([]);
+	const [toolCalls, setToolCalls] = useState([]);
+	const [error, setError] = useState(null);
+	const [currentModel, setCurrentModel] = useState(options.model);
+	useEffect(() => {
+		const loadSession = async () => {
+			if (!options.sessionId || !options.checkpointer) return;
+			const checkpoint = await options.checkpointer.load(options.sessionId);
+			if (checkpoint) {
+				setState(checkpoint.state);
+				setMessages(checkpoint.messages);
+				messagesRef.current = checkpoint.messages;
+				addEvent({
+					type: "checkpoint-loaded",
+					threadId: options.sessionId,
+					step: checkpoint.step,
+					messagesCount: checkpoint.messages.length
+				});
+			}
+		};
+		loadSession().catch(console.error);
+	}, [options.sessionId]);
+	const [promptCachingEnabled, setPromptCachingEnabled] = useState(options.enablePromptCaching ?? false);
+	const [evictionLimit, setEvictionLimit] = useState(options.toolResultEvictionLimit ?? 0);
+	const [summarizationEnabled, setSummarizationEnabled] = useState(options.summarization?.enabled ?? false);
+	const [summarizationConfig, setSummarizationConfig] = useState(options.summarization);
+	const [autoApproveEnabled, setAutoApproveEnabled] = useState(false);
+	const [pendingApproval, setPendingApproval] = useState(null);
+	const approvalResolverRef = useRef(null);
+	const abortControllerRef = useRef(null);
+	const accumulatedTextRef = useRef("");
+	const totalTextRef = useRef("");
+	const messagesRef = useRef([]);
+	const toolCallsRef = useRef([]);
+	const pendingToolCallsRef = useRef(/* @__PURE__ */ new Map());
+	const features = {
+		promptCaching: promptCachingEnabled,
+		eviction: evictionLimit > 0,
+		summarization: summarizationEnabled
+	};
+	const agentRef = useRef(createDeepAgent({
+		model: parseModelString(currentModel),
+		maxSteps: options.maxSteps,
+		systemPrompt: options.systemPrompt,
+		backend: options.backend,
+		enablePromptCaching: promptCachingEnabled,
+		toolResultEvictionLimit: evictionLimit,
+		summarization: summarizationConfig,
+		interruptOn: autoApproveEnabled ? void 0 : options.interruptOn ?? DEFAULT_CLI_INTERRUPT_ON,
+		checkpointer: options.checkpointer
+	}));
+	const addEvent = useCallback((event) => {
+		setEvents((prev) => [...prev, {
+			id: createEventId(),
+			type: event.type,
+			event,
+			timestamp: /* @__PURE__ */ new Date()
+		}]);
+	}, []);
+	const flushTextSegment = useCallback(() => {
+		if (accumulatedTextRef.current.trim()) {
+			addEvent({
+				type: "text-segment",
+				text: accumulatedTextRef.current
+			});
+			accumulatedTextRef.current = "";
+			setStreamingText("");
+		}
+	}, [addEvent]);
+	/**
+	* Common pattern: flush text, set status to "tool-call", add event
+	*/
+	const handleToolEvent = (event, ctx) => {
+		ctx.flushTextSegment();
+		ctx.setStatus("tool-call");
+		ctx.addEvent(event);
+	};
+	/**
+	* Handle text streaming events.
+	* Accumulates text and updates streaming display.
+	*/
+	const handleTextEvent = (event, ctx) => {
+		if (event.type !== "text") return;
+		ctx.setStatus("streaming");
+		ctx.accumulatedTextRef.current += event.text;
+		ctx.totalTextRef.current += event.text;
+		setStreamingText(ctx.accumulatedTextRef.current);
+	};
+	/**
+	* Handle step-start events.
+	* Marks beginning of a new reasoning step.
+	*/
+	const handleStepStartEvent = (event, ctx) => {
+		if (event.type !== "step-start") return;
+		if (event.stepNumber > 1) ctx.addEvent(event);
+	};
+	/**
+	* Handle tool-call events.
+	* Tracks pending tool calls until results arrive.
+	*/
+	const handleToolCallEvent = (event, ctx) => {
+		if (event.type !== "tool-call") return;
+		ctx.flushTextSegment();
+		ctx.setStatus("tool-call");
+		const pendingToolCall = {
+			toolName: event.toolName,
+			args: event.args,
+			status: "success"
+		};
+		ctx.pendingToolCallsRef.current.set(event.toolCallId, pendingToolCall);
+		ctx.addEvent(event);
+	};
+	/**
+	* Handle tool-result events.
+	* Updates pending tool call with result and moves to completed list.
+	*/
+	const handleToolResultEvent = (event, ctx) => {
+		if (event.type !== "tool-result") return;
+		const completedToolCall = ctx.pendingToolCallsRef.current.get(event.toolCallId);
+		if (completedToolCall) {
+			completedToolCall.result = event.result;
+			ctx.toolCallsRef.current.push(completedToolCall);
+			ctx.setToolCalls([...ctx.toolCallsRef.current]);
+			ctx.pendingToolCallsRef.current.delete(event.toolCallId);
+		}
+		ctx.addEvent(event);
+	};
+	/**
+	* Handle todos-changed events.
+	* Updates the todos list in state.
+	*/
+	const handleTodosChangedEvent = (event, ctx) => {
+		if (event.type !== "todos-changed") return;
+		ctx.flushTextSegment();
+		ctx.setStatus("tool-call");
+		ctx.setState((prev) => ({
+			...prev,
+			todos: event.todos
+		}));
+		ctx.addEvent(event);
+	};
+	/**
+	* Handle file-write-start events.
+	*/
+	const handleFileWriteStartEvent = (event, ctx) => {
+		if (event.type !== "file-write-start") return;
+		handleToolEvent(event, ctx);
+	};
+	/**
+	* Handle file-written events.
+	*/
+	const handleFileWrittenEvent = (event, ctx) => {
+		if (event.type !== "file-written") return;
+		ctx.setStatus("tool-call");
+		ctx.addEvent(event);
+	};
+	/**
+	* Handle file-edited events.
+	*/
+	const handleFileEditedEvent = (event, ctx) => {
+		if (event.type !== "file-edited") return;
+		ctx.setStatus("tool-call");
+		ctx.addEvent(event);
+	};
+	/**
+	* Handle file-read events.
+	*/
+	const handleFileReadEvent = (event, ctx) => {
+		if (event.type !== "file-read") return;
+		handleToolEvent(event, ctx);
+	};
+	/**
+	* Handle ls events.
+	*/
+	const handleLsEvent = (event, ctx) => {
+		if (event.type !== "ls") return;
+		handleToolEvent(event, ctx);
+	};
+	/**
+	* Handle glob events.
+	*/
+	const handleGlobEvent = (event, ctx) => {
+		if (event.type !== "glob") return;
+		handleToolEvent(event, ctx);
+	};
+	/**
+	* Handle grep events.
+	*/
+	const handleGrepEvent = (event, ctx) => {
+		if (event.type !== "grep") return;
+		handleToolEvent(event, ctx);
+	};
+	/**
+	* Handle web-search-start events.
+	*/
+	const handleWebSearchStartEvent = (event, ctx) => {
+		if (event.type !== "web-search-start") return;
+		handleToolEvent(event, ctx);
+	};
+	/**
+	* Handle web-search-finish events.
+	*/
+	const handleWebSearchFinishEvent = (event, ctx) => {
+		if (event.type !== "web-search-finish") return;
+		ctx.setStatus("tool-call");
+		ctx.addEvent(event);
+	};
+	/**
+	* Handle http-request-start events.
+	*/
+	const handleHttpRequestStartEvent = (event, ctx) => {
+		if (event.type !== "http-request-start") return;
+		handleToolEvent(event, ctx);
+	};
+	/**
+	* Handle http-request-finish events.
+	*/
+	const handleHttpRequestFinishEvent = (event, ctx) => {
+		if (event.type !== "http-request-finish") return;
+		ctx.setStatus("tool-call");
+		ctx.addEvent(event);
+	};
+	/**
+	* Handle fetch-url-start events.
+	*/
+	const handleFetchUrlStartEvent = (event, ctx) => {
+		if (event.type !== "fetch-url-start") return;
+		handleToolEvent(event, ctx);
+	};
+	/**
+	* Handle fetch-url-finish events.
+	*/
+	const handleFetchUrlFinishEvent = (event, ctx) => {
+		if (event.type !== "fetch-url-finish") return;
+		ctx.setStatus("tool-call");
+		ctx.addEvent(event);
+	};
+	/**
+	* Handle subagent-start events.
+	*/
+	const handleSubagentStartEvent = (event, ctx) => {
+		if (event.type !== "subagent-start") return;
+		ctx.setStatus("subagent");
+		ctx.addEvent(event);
+	};
+	/**
+	* Handle subagent-finish events.
+	*/
+	const handleSubagentFinishEvent = (event, ctx) => {
+		if (event.type !== "subagent-finish") return;
+		ctx.addEvent(event);
+	};
+	/**
+	* Handle approval-requested events.
+	* Already handled in onApprovalRequest callback, so no-op here.
+	*/
+	const handleApprovalRequestedEvent = (event, ctx) => {};
+	/**
+	* Handle approval-response events.
+	* Already handled in respondToApproval callback, so no-op here.
+	*/
+	const handleApprovalResponseEvent = (event, ctx) => {};
+	/**
+	* Handle done events.
+	* Flushes remaining text and updates final state.
+	*/
+	const handleDoneEvent = (event, ctx) => {
+		if (event.type !== "done") return;
+		ctx.flushTextSegment();
+		ctx.setStatus("done");
+		ctx.setState(event.state);
+		if (event.messages) {
+			ctx.setMessages(event.messages);
+			ctx.messagesRef.current = event.messages;
+		}
+		ctx.addEvent(event);
+	};
+	/**
+	* Handle error events.
+	* Flushes remaining text and marks pending tool calls as failed.
+	*/
+	const handleErrorEvent = (event, ctx) => {
+		if (event.type !== "error") return;
+		ctx.flushTextSegment();
+		ctx.setStatus("error");
+		ctx.setError(event.error);
+		for (const [id, tc] of ctx.pendingToolCallsRef.current) {
+			tc.status = "error";
+			ctx.toolCallsRef.current.push(tc);
+		}
+		ctx.pendingToolCallsRef.current.clear();
+		ctx.setToolCalls([...ctx.toolCallsRef.current]);
+		ctx.addEvent(event);
+	};
+	/**
+	* Event handler map.
+	* Maps event types to their handler functions.
+	*/
+	const EVENT_HANDLERS = {
+		"text": handleTextEvent,
+		"step-start": handleStepStartEvent,
+		"tool-call": handleToolCallEvent,
+		"tool-result": handleToolResultEvent,
+		"todos-changed": handleTodosChangedEvent,
+		"file-write-start": handleFileWriteStartEvent,
+		"file-written": handleFileWrittenEvent,
+		"file-edited": handleFileEditedEvent,
+		"file-read": handleFileReadEvent,
+		"ls": handleLsEvent,
+		"glob": handleGlobEvent,
+		"grep": handleGrepEvent,
+		"web-search-start": handleWebSearchStartEvent,
+		"web-search-finish": handleWebSearchFinishEvent,
+		"http-request-start": handleHttpRequestStartEvent,
+		"http-request-finish": handleHttpRequestFinishEvent,
+		"fetch-url-start": handleFetchUrlStartEvent,
+		"fetch-url-finish": handleFetchUrlFinishEvent,
+		"subagent-start": handleSubagentStartEvent,
+		"subagent-finish": handleSubagentFinishEvent,
+		"approval-requested": handleApprovalRequestedEvent,
+		"approval-response": handleApprovalResponseEvent,
+		"done": handleDoneEvent,
+		"error": handleErrorEvent
+	};
+	const sendPrompt = useCallback(async (prompt) => {
+		setStatus("thinking");
+		setStreamingText("");
+		setToolCalls([]);
+		setError(null);
+		accumulatedTextRef.current = "";
+		totalTextRef.current = "";
+		toolCallsRef.current = [];
+		pendingToolCallsRef.current.clear();
+		addEvent({
+			type: "user-message",
+			content: prompt
+		});
+		messagesRef.current = messages;
+		abortControllerRef.current = new AbortController();
+		const inputMessages = messagesRef.current.length > 0 ? [...messagesRef.current, {
+			role: "user",
+			content: prompt
+		}] : [{
+			role: "user",
+			content: prompt
+		}];
+		try {
+			for await (const event of agentRef.current.streamWithEvents({
+				messages: inputMessages,
+				state,
+				threadId: options.sessionId,
+				abortSignal: abortControllerRef.current.signal,
+				onApprovalRequest: async (request) => {
+					if (autoApproveEnabled) {
+						addEvent({
+							type: "approval-requested",
+							...request
+						});
+						addEvent({
+							type: "approval-response",
+							approvalId: request.approvalId,
+							approved: true
+						});
+						return true;
+					}
+					setPendingApproval({
+						approvalId: request.approvalId,
+						toolName: request.toolName,
+						args: request.args
+					});
+					addEvent({
+						type: "approval-requested",
+						...request
+					});
+					return new Promise((resolve) => {
+						approvalResolverRef.current = resolve;
+					});
+				}
+			})) {
+				const eventHandlerContext = {
+					setStatus,
+					setState,
+					setMessages,
+					setToolCalls,
+					setError,
+					addEvent,
+					flushTextSegment,
+					accumulatedTextRef,
+					totalTextRef,
+					toolCallsRef,
+					pendingToolCallsRef,
+					messagesRef
+				};
+				const handler = EVENT_HANDLERS[event.type];
+				if (handler) handler(event, eventHandlerContext);
+			}
+			const finalText = totalTextRef.current;
+			const finalToolCalls = [...toolCallsRef.current];
+			setLastCompletedText(finalText);
+			setStatus("idle");
+			return {
+				text: finalText,
+				toolCalls: finalToolCalls
+			};
+		} catch (err) {
+			if (err.name === "AbortError") {
+				flushTextSegment();
+				setStatus("idle");
+				return {
+					text: totalTextRef.current,
+					toolCalls: toolCallsRef.current
+				};
+			} else {
+				flushTextSegment();
+				setStatus("error");
+				setError(err);
+				return {
+					text: "",
+					toolCalls: []
+				};
+			}
+		} finally {
+			abortControllerRef.current = null;
+		}
+	}, [
+		state,
+		messages,
+		addEvent,
+		flushTextSegment,
+		autoApproveEnabled
+	]);
+	const abort = useCallback(() => {
+		if (abortControllerRef.current) {
+			abortControllerRef.current.abort();
+			setStatus("idle");
+		}
+	}, []);
+	const clear = useCallback(() => {
+		setEvents([]);
+		setStreamingText("");
+		setLastCompletedText("");
+		setMessages([]);
+		setToolCalls([]);
+		messagesRef.current = [];
+		toolCallsRef.current = [];
+		pendingToolCallsRef.current.clear();
+		setError(null);
+		setStatus("idle");
+	}, []);
+	const clearStreamingText = useCallback(() => {
+		setStreamingText("");
+		setEvents([]);
+	}, []);
+	const clearEvents = useCallback(() => {
+		setEvents([]);
+	}, []);
+	const recreateAgent = useCallback((overrides = {}) => {
+		const newModel = overrides.model ?? currentModel;
+		const newPromptCaching = overrides.promptCaching ?? promptCachingEnabled;
+		const newEvictionLimit = overrides.evictionLimit ?? evictionLimit;
+		const newSummarization = overrides.summarization ?? summarizationConfig;
+		let newInterruptOn;
+		if (overrides.interruptOn === null) newInterruptOn = void 0;
+		else if (overrides.interruptOn !== void 0) newInterruptOn = overrides.interruptOn;
+		else newInterruptOn = autoApproveEnabled ? void 0 : options.interruptOn ?? DEFAULT_CLI_INTERRUPT_ON;
+		agentRef.current = createDeepAgent({
+			model: parseModelString(newModel),
+			maxSteps: options.maxSteps,
+			systemPrompt: options.systemPrompt,
+			backend: options.backend,
+			enablePromptCaching: newPromptCaching,
+			toolResultEvictionLimit: newEvictionLimit,
+			summarization: newSummarization,
+			interruptOn: newInterruptOn
+		});
+	}, [
+		currentModel,
+		promptCachingEnabled,
+		evictionLimit,
+		summarizationConfig,
+		autoApproveEnabled,
+		options.maxSteps,
+		options.systemPrompt,
+		options.backend,
+		options.interruptOn
+	]);
+	const setModel = useCallback((model) => {
+		setCurrentModel(model);
+		recreateAgent({ model });
+	}, [recreateAgent]);
+	const setPromptCaching = useCallback((enabled) => {
+		setPromptCachingEnabled(enabled);
+		recreateAgent({ promptCaching: enabled });
+	}, [recreateAgent]);
+	const setEviction = useCallback((enabled) => {
+		const newLimit = enabled ? options.toolResultEvictionLimit || 2e4 : 0;
+		setEvictionLimit(newLimit);
+		recreateAgent({ evictionLimit: newLimit });
+	}, [recreateAgent, options.toolResultEvictionLimit]);
+	const setSummarization = useCallback((enabled) => {
+		setSummarizationEnabled(enabled);
+		const newConfig = enabled ? {
+			enabled: true,
+			tokenThreshold: options.summarization?.tokenThreshold,
+			keepMessages: options.summarization?.keepMessages
+		} : void 0;
+		setSummarizationConfig(newConfig);
+		recreateAgent({ summarization: newConfig });
+	}, [recreateAgent, options.summarization]);
+	const respondToApproval = useCallback((approved) => {
+		if (approvalResolverRef.current) {
+			approvalResolverRef.current(approved);
+			approvalResolverRef.current = null;
+			const currentApproval = pendingApproval;
+			setPendingApproval(null);
+			if (currentApproval) addEvent({
+				type: "approval-response",
+				approvalId: currentApproval.approvalId,
+				approved
+			});
+		}
+	}, [addEvent]);
+	return {
+		status,
+		streamingText,
+		lastCompletedText,
+		events,
+		state,
+		messages,
+		toolCalls,
+		error,
+		sendPrompt,
+		abort,
+		clear,
+		clearStreamingText,
+		clearEvents,
+		setModel,
+		currentModel,
+		features,
+		setPromptCaching,
+		setEviction,
+		setSummarization,
+		pendingApproval,
+		respondToApproval,
+		autoApproveEnabled,
+		setAutoApprove: useCallback((enabled) => {
+			setAutoApproveEnabled(enabled);
+			if (enabled && approvalResolverRef.current) respondToApproval(true);
+			recreateAgent({ interruptOn: enabled ? null : options.interruptOn ?? DEFAULT_CLI_INTERRUPT_ON });
+		}, [
+			recreateAgent,
+			options.interruptOn,
+			respondToApproval
+		])
+	};
+}
+
+//#endregion
+//#region src/cli/theme.ts
+/**
+* Theme constants for the Ink CLI.
+* Colors, emoji, and styling values.
+*/
+/**
+* Color palette for the CLI.
+* Uses chalk-compatible color names.
+*/
+const colors = {
+	primary: "cyan",
+	secondary: "magenta",
+	accent: "yellow",
+	success: "green",
+	error: "red",
+	warning: "yellow",
+	info: "blue",
+	muted: "gray",
+	highlight: "white",
+	tool: "magenta",
+	file: "blue",
+	user: "cyan",
+	agent: "green"
+};
+/**
+* Status emoji for todo items and events.
+*/
+const emoji = {
+	pending: "⏳",
+	in_progress: "🔄",
+	completed: "✅",
+	cancelled: "❌",
+	robot: "🤖",
+	thinking: "💭",
+	tool: "🔧",
+	file: "📁",
+	edit: "✏️",
+	todo: "📋",
+	done: "🎉",
+	error: "💥",
+	warning: "⚠️",
+	info: "ℹ️",
+	user: "👤",
+	subagent: "🤝",
+	key: "🔑",
+	model: "🧠"
+};
+const SLASH_COMMANDS = [
+	{
+		command: "/todos",
+		aliases: ["/t", "/todo"],
+		description: "Show current todo list"
+	},
+	{
+		command: "/files",
+		aliases: ["/f", "/file"],
+		description: "Show files in working directory"
+	},
+	{
+		command: "/read",
+		aliases: ["/r"],
+		description: "Read a file (usage: /read <path>)"
+	},
+	{
+		command: "/apikey",
+		aliases: ["/key", "/api"],
+		description: "Manage API keys (interactive)"
+	},
+	{
+		command: "/model",
+		aliases: [],
+		description: "Show available models or change model (usage: /model [model-name])"
+	},
+	{
+		command: "/features",
+		aliases: ["/feat"],
+		description: "Show enabled features (caching, eviction, summarization)"
+	},
+	{
+		command: "/tokens",
+		aliases: ["/tok"],
+		description: "Show estimated token count for conversation"
+	},
+	{
+		command: "/cache",
+		aliases: [],
+		description: "Toggle prompt caching (usage: /cache on|off)"
+	},
+	{
+		command: "/eviction",
+		aliases: ["/evict"],
+		description: "Toggle tool result eviction (usage: /eviction on|off)"
+	},
+	{
+		command: "/summarize",
+		aliases: ["/sum"],
+		description: "Toggle auto-summarization (usage: /summarize on|off)"
+	},
+	{
+		command: "/approve",
+		aliases: [],
+		description: "Toggle auto-approve mode for tool executions"
+	},
+	{
+		command: "/clear",
+		aliases: ["/c"],
+		description: "Clear chat history"
+	},
+	{
+		command: "/sessions",
+		aliases: ["/session-list"],
+		description: "List saved sessions"
+	},
+	{
+		command: "/session",
+		aliases: [],
+		description: "Session management (usage: /session clear)"
+	},
+	{
+		command: "/help",
+		aliases: ["/h", "/?"],
+		description: "Show help"
+	},
+	{
+		command: "/quit",
+		aliases: ["/q", "/exit"],
+		description: "Exit the CLI"
+	}
+];
+/**
+* Filter commands by prefix.
+*/
+function filterCommands(prefix) {
+	if (!prefix) return SLASH_COMMANDS;
+	const normalizedPrefix = prefix.startsWith("/") ? prefix : `/${prefix}`;
+	return SLASH_COMMANDS.filter((cmd) => {
+		if (cmd.command.toLowerCase().startsWith(normalizedPrefix.toLowerCase())) return true;
+		return cmd.aliases.some((alias) => alias.toLowerCase().startsWith(normalizedPrefix.toLowerCase()));
+	});
+}
+/**
+* Parse a slash command from input.
+*/
+function parseCommand(input) {
+	const trimmed = input.trim();
+	if (!trimmed.startsWith("/")) return { isCommand: false };
+	const parts = trimmed.slice(1).split(/\s+/);
+	return {
+		isCommand: true,
+		command: parts[0]?.toLowerCase(),
+		args: parts.slice(1).join(" ") || void 0
+	};
+}
+
+//#endregion
+//#region src/cli/components/Welcome.tsx
+function Welcome({ model, workDir }) {
+	const displayDir = workDir ? workDir.replace(process.env.HOME || "", "~") : process.cwd().replace(process.env.HOME || "", "~");
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: colors.muted,
+		paddingX: 2,
+		paddingY: 1,
+		marginBottom: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsxs(Text, {
+				bold: true,
+				color: colors.primary,
+				children: [">", "_"]
+			}), /* @__PURE__ */ jsx(Text, {
+				bold: true,
+				children: " Deep Agent"
+			})] }),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			/* @__PURE__ */ jsxs(Box, { children: [
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "model:"
+				}),
+				/* @__PURE__ */ jsxs(Text, { children: ["     ", model || "anthropic/claude-haiku-4-5-20251001"] }),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "  /model to change"
+				})
+			] }),
+			/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "directory:"
+			}), /* @__PURE__ */ jsxs(Text, { children: [" ", displayDir] })] })
+		]
+	});
+}
+/**
+* Compact help text shown below the welcome banner.
+*/
+function WelcomeHint() {
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		marginBottom: 1,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "To get started, describe a task or try one of these commands:"
+			}),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			/* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				children: [
+					/* @__PURE__ */ jsxs(Text, { children: [/* @__PURE__ */ jsx(Text, {
+						color: colors.info,
+						children: "/help"
+					}), /* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: " - show available commands"
+					})] }),
+					/* @__PURE__ */ jsxs(Text, { children: [/* @__PURE__ */ jsx(Text, {
+						color: colors.info,
+						children: "/features"
+					}), /* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: " - show enabled features"
+					})] }),
+					/* @__PURE__ */ jsxs(Text, { children: [/* @__PURE__ */ jsx(Text, {
+						color: colors.info,
+						children: "/model"
+					}), /* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: " - change the model"
+					})] })
+				]
+			})
+		]
+	});
+}
+
+//#endregion
+//#region src/cli/components/SlashMenu.tsx
+function SlashMenu({ filter, maxItems = 8 }) {
+	if (!filter.startsWith("/")) return null;
+	const filtered = filterCommands(filter);
+	if (filtered.length === 0) return /* @__PURE__ */ jsx(Box, {
+		paddingLeft: 2,
+		marginTop: 1,
+		children: /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "No matching commands"
+		})
+	});
+	const displayItems = filtered.slice(0, maxItems);
+	const hasMore = filtered.length > maxItems;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		marginTop: 1,
+		paddingLeft: 2,
+		children: [displayItems.map((cmd) => /* @__PURE__ */ jsx(SlashMenuItem, { command: cmd }, cmd.command)), hasMore && /* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				"... and ",
+				filtered.length - maxItems,
+				" more"
+			]
+		})]
+	});
+}
+function SlashMenuItem({ command }) {
+	const aliases = command.aliases.length > 0 ? ` (${command.aliases.join(", ")})` : "";
+	return /* @__PURE__ */ jsxs(Box, { children: [
+		/* @__PURE__ */ jsx(Text, {
+			color: colors.info,
+			children: command.command
+		}),
+		/* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: aliases
+		}),
+		/* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [" - ", command.description]
+		})
+	] });
+}
+/**
+* Full slash menu panel for /help command.
+*/
+function SlashMenuPanel() {
+	const commands = filterCommands();
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: colors.muted,
+		paddingX: 2,
+		paddingY: 1,
+		marginY: 1,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				bold: true,
+				color: colors.info,
+				children: "Available Commands"
+			}),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			commands.map((cmd) => /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				marginBottom: 1,
+				children: [/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+					color: colors.info,
+					children: cmd.command
+				}), cmd.aliases.length > 0 && /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [
+						" (",
+						cmd.aliases.join(", "),
+						")"
+					]
+				})] }), /* @__PURE__ */ jsx(Box, {
+					paddingLeft: 2,
+					children: /* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: cmd.description
+					})
+				})]
+			}, cmd.command))
+		]
+	});
+}
+
+//#endregion
+//#region src/cli/components/Input.tsx
+/**
+* Text input component with slash command suggestions.
+* Clean, minimal design inspired by Claude Code and OpenAI Codex.
+*/
+const inputHistory = [];
+const MAX_HISTORY = 100;
+function Input({ onSubmit, disabled = false, placeholder = "Plan, search, build anything" }) {
+	const [value, setValue] = useState("");
+	const [cursorPos, setCursorPos] = useState(0);
+	const showMenu = value.startsWith("/") && !disabled;
+	const [historyIndex, setHistoryIndex] = useState(-1);
+	const savedInputRef = useRef("");
+	const deleteWord = () => {
+		if (cursorPos === 0) return;
+		let end = cursorPos;
+		while (end > 0 && value[end - 1] === " ") end--;
+		while (end > 0 && value[end - 1] !== " ") end--;
+		setValue(value.slice(0, end) + value.slice(cursorPos));
+		setCursorPos(end);
+	};
+	useInput((input, key) => {
+		if (disabled) return;
+		if (key.return) {
+			if (value.trim()) {
+				if (inputHistory.length === 0 || inputHistory[0] !== value) {
+					inputHistory.unshift(value);
+					if (inputHistory.length > MAX_HISTORY) inputHistory.pop();
+				}
+				onSubmit(value);
+				setValue("");
+				setCursorPos(0);
+				setHistoryIndex(-1);
+				savedInputRef.current = "";
+			}
+			return;
+		}
+		if (key.upArrow) {
+			if (inputHistory.length === 0) return;
+			if (historyIndex === -1) savedInputRef.current = value;
+			const newIndex = Math.min(historyIndex + 1, inputHistory.length - 1);
+			if (newIndex !== historyIndex) {
+				const historyValue = inputHistory[newIndex];
+				if (historyValue !== void 0) {
+					setHistoryIndex(newIndex);
+					setValue(historyValue);
+					setCursorPos(historyValue.length);
+				}
+			}
+			return;
+		}
+		if (key.downArrow) {
+			if (historyIndex === -1) return;
+			const newIndex = historyIndex - 1;
+			if (newIndex === -1) {
+				setHistoryIndex(-1);
+				setValue(savedInputRef.current);
+				setCursorPos(savedInputRef.current.length);
+			} else {
+				const historyValue = inputHistory[newIndex];
+				if (historyValue !== void 0) {
+					setHistoryIndex(newIndex);
+					setValue(historyValue);
+					setCursorPos(historyValue.length);
+				}
+			}
+			return;
+		}
+		if (key.leftArrow) {
+			if (key.meta || key.ctrl) {
+				let pos = cursorPos;
+				while (pos > 0 && value[pos - 1] === " ") pos--;
+				while (pos > 0 && value[pos - 1] !== " ") pos--;
+				setCursorPos(pos);
+			} else setCursorPos((prev) => Math.max(0, prev - 1));
+			return;
+		}
+		if (key.rightArrow) {
+			if (key.meta || key.ctrl) {
+				let pos = cursorPos;
+				while (pos < value.length && value[pos] !== " ") pos++;
+				while (pos < value.length && value[pos] === " ") pos++;
+				setCursorPos(pos);
+			} else setCursorPos((prev) => Math.min(value.length, prev + 1));
+			return;
+		}
+		if (key.ctrl && input === "a") {
+			setCursorPos(0);
+			return;
+		}
+		if (key.ctrl && input === "e") {
+			setCursorPos(value.length);
+			return;
+		}
+		if ((key.backspace || key.delete) && key.meta) {
+			deleteWord();
+			return;
+		}
+		if (key.ctrl && input === "w") {
+			deleteWord();
+			return;
+		}
+		if (key.ctrl && input === "u") {
+			setValue(value.slice(cursorPos));
+			setCursorPos(0);
+			return;
+		}
+		if (key.ctrl && input === "k") {
+			setValue(value.slice(0, cursorPos));
+			return;
+		}
+		if (key.backspace || key.delete) {
+			if (cursorPos > 0) {
+				setValue((prev) => prev.slice(0, cursorPos - 1) + prev.slice(cursorPos));
+				setCursorPos((prev) => prev - 1);
+			}
+			return;
+		}
+		if (key.tab && value.startsWith("/")) return;
+		if (key.ctrl || key.meta || key.escape || key.tab) return;
+		if (input) {
+			const printable = input.split("").filter((char) => char >= " " || char === "	").join("");
+			if (printable) {
+				if (historyIndex !== -1) {
+					setHistoryIndex(-1);
+					savedInputRef.current = "";
+				}
+				setValue((prev) => prev.slice(0, cursorPos) + printable + prev.slice(cursorPos));
+				setCursorPos((prev) => prev + printable.length);
+			}
+		}
+	}, { isActive: !disabled });
+	const renderTextWithCursor = () => {
+		if (!value) return /* @__PURE__ */ jsxs(Text, { children: [/* @__PURE__ */ jsx(Text, {
+			color: colors.primary,
+			children: "▌"
+		}), /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: placeholder
+		})] });
+		const beforeCursor = value.slice(0, cursorPos);
+		const afterCursor = value.slice(cursorPos);
+		return /* @__PURE__ */ jsxs(Text, { children: [
+			beforeCursor,
+			/* @__PURE__ */ jsx(Text, {
+				color: colors.primary,
+				children: "▌"
+			}),
+			afterCursor
+		] });
+	};
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+			color: colors.muted,
+			children: "→ "
+		}), disabled ? /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "..."
+		}) : renderTextWithCursor()] }), showMenu && /* @__PURE__ */ jsx(SlashMenu, { filter: value })]
+	});
+}
+
+//#endregion
+//#region src/cli/components/TodoList.tsx
+function TodoList({ todos, showPanel = true }) {
+	const completed = todos.filter((t) => t.status === "completed").length;
+	const inProgress = todos.filter((t) => t.status === "in_progress").length;
+	const pending = todos.filter((t) => t.status === "pending").length;
+	const total = todos.length;
+	const content = /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsxs(Box, {
+				marginBottom: 1,
+				children: [/* @__PURE__ */ jsxs(Text, {
+					bold: true,
+					color: colors.info,
+					children: [emoji.todo, " Todo List"]
+				}), /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [
+						" ",
+						"(",
+						completed,
+						"/",
+						total,
+						" done)"
+					]
+				})]
+			}),
+			todos.length === 0 ? /* @__PURE__ */ jsx(Box, {
+				paddingLeft: 2,
+				children: /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "No todos yet."
+				})
+			}) : /* @__PURE__ */ jsx(Box, {
+				flexDirection: "column",
+				children: todos.map((todo) => /* @__PURE__ */ jsx(TodoItemRow, { todo }, todo.id))
+			}),
+			todos.length > 0 && /* @__PURE__ */ jsxs(Box, {
+				marginTop: 1,
+				gap: 2,
+				children: [
+					inProgress > 0 && /* @__PURE__ */ jsxs(Text, {
+						color: colors.warning,
+						children: [inProgress, " in progress"]
+					}),
+					pending > 0 && /* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						children: [pending, " pending"]
+					}),
+					completed > 0 && /* @__PURE__ */ jsxs(Text, {
+						color: colors.success,
+						children: [completed, " completed"]
+					})
+				]
+			})
+		]
+	});
+	if (!showPanel) return content;
+	return /* @__PURE__ */ jsx(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: colors.muted,
+		paddingX: 2,
+		paddingY: 1,
+		marginY: 1,
+		children: content
+	});
+}
+function TodoItemRow({ todo }) {
+	const statusEmoji = emoji[todo.status] || "•";
+	const isFinished = todo.status === "completed" || todo.status === "cancelled";
+	const badgeColor = {
+		pending: "gray",
+		in_progress: "yellow",
+		completed: "green",
+		cancelled: "red"
+	}[todo.status];
+	return /* @__PURE__ */ jsxs(Box, {
+		paddingLeft: 2,
+		children: [
+			/* @__PURE__ */ jsxs(Text, { children: [statusEmoji, " "] }),
+			/* @__PURE__ */ jsx(Badge, {
+				color: badgeColor,
+				children: todo.status.replace("_", " ")
+			}),
+			/* @__PURE__ */ jsx(Text, { children: " " }),
+			isFinished ? /* @__PURE__ */ jsx(Text, {
+				strikethrough: true,
+				dimColor: true,
+				children: todo.content
+			}) : /* @__PURE__ */ jsx(Text, { children: todo.content })
+		]
+	});
+}
+
+//#endregion
+//#region src/cli/components/FilePreview.tsx
+function FilePreview({ path, content, maxLines = 20, isWrite = false }) {
+	const lines = content.split("\n");
+	const totalLines = lines.length;
+	const displayLines = lines.slice(0, maxLines);
+	const truncated = totalLines > maxLines;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: colors.muted,
+		marginY: 1,
+		children: [/* @__PURE__ */ jsxs(Box, {
+			paddingX: 2,
+			paddingY: 1,
+			borderBottom: true,
+			children: [
+				/* @__PURE__ */ jsxs(Text, {
+					color: colors.info,
+					children: [
+						emoji.file,
+						" ",
+						isWrite ? "Writing:" : "Reading:",
+						" "
+					]
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					color: colors.file,
+					children: path
+				}),
+				/* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [
+						" (",
+						totalLines,
+						" lines)"
+					]
+				})
+			]
+		}), /* @__PURE__ */ jsxs(Box, {
+			flexDirection: "column",
+			paddingX: 2,
+			paddingY: 1,
+			children: [displayLines.map((line, index) => /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [String(index + 1).padStart(4, " "), " "]
+			}), /* @__PURE__ */ jsx(Text, { children: truncateLine(line, 70) })] }, index)), truncated && /* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [
+						"... ",
+						totalLines - maxLines,
+						" more lines ..."
+					]
+				})
+			})]
+		})]
+	});
+}
+/**
+* Truncate a line if too long.
+*/
+function truncateLine(line, maxLength) {
+	if (line.length <= maxLength) return line;
+	return line.substring(0, maxLength - 3) + "...";
+}
+function FileWritten({ path }) {
+	return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+		color: colors.success,
+		children: "✓ Wrote: "
+	}), /* @__PURE__ */ jsx(Text, {
+		color: colors.file,
+		children: path
+	})] });
+}
+function FileEdited({ path, occurrences }) {
+	return /* @__PURE__ */ jsxs(Box, { children: [
+		/* @__PURE__ */ jsxs(Text, {
+			color: colors.success,
+			children: [emoji.edit, " Edited: "]
+		}),
+		/* @__PURE__ */ jsx(Text, {
+			color: colors.file,
+			children: path
+		}),
+		/* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				" ",
+				"(",
+				occurrences,
+				" change",
+				occurrences === 1 ? "" : "s",
+				")"
+			]
+		})
+	] });
+}
+function FileRead({ path, lines }) {
+	return /* @__PURE__ */ jsxs(Box, { children: [
+		/* @__PURE__ */ jsx(Text, {
+			color: colors.info,
+			children: "📖 Read: "
+		}),
+		/* @__PURE__ */ jsx(Text, {
+			color: colors.file,
+			children: path
+		}),
+		/* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				" (",
+				lines,
+				" lines)"
+			]
+		})
+	] });
+}
+function LsResult({ path, count }) {
+	return /* @__PURE__ */ jsxs(Box, { children: [
+		/* @__PURE__ */ jsx(Text, {
+			color: colors.info,
+			children: "📂 Listed: "
+		}),
+		/* @__PURE__ */ jsx(Text, {
+			color: colors.file,
+			children: path
+		}),
+		/* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				" (",
+				count,
+				" item",
+				count === 1 ? "" : "s",
+				")"
+			]
+		})
+	] });
+}
+function GlobResult({ pattern, count }) {
+	return /* @__PURE__ */ jsxs(Box, { children: [
+		/* @__PURE__ */ jsx(Text, {
+			color: colors.info,
+			children: "🔍 Glob: "
+		}),
+		/* @__PURE__ */ jsx(Text, {
+			color: colors.tool,
+			children: pattern
+		}),
+		/* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				" (",
+				count,
+				" match",
+				count === 1 ? "" : "es",
+				")"
+			]
+		})
+	] });
+}
+function GrepResult({ pattern, count }) {
+	return /* @__PURE__ */ jsxs(Box, { children: [
+		/* @__PURE__ */ jsx(Text, {
+			color: colors.info,
+			children: "🔎 Grep: "
+		}),
+		/* @__PURE__ */ jsx(Text, {
+			color: colors.tool,
+			children: pattern
+		}),
+		/* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				" (",
+				count,
+				" match",
+				count === 1 ? "" : "es",
+				")"
+			]
+		})
+	] });
+}
+function FileList({ files, workDir }) {
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: colors.muted,
+		paddingX: 2,
+		paddingY: 1,
+		marginY: 1,
+		children: [/* @__PURE__ */ jsxs(Box, {
+			marginBottom: 1,
+			children: [/* @__PURE__ */ jsxs(Text, {
+				bold: true,
+				color: colors.info,
+				children: [emoji.file, " Files"]
+			}), workDir && /* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [" in ", workDir]
+			})]
+		}), files.length === 0 ? /* @__PURE__ */ jsx(Box, {
+			paddingLeft: 2,
+			children: /* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "No files found."
+			})
+		}) : /* @__PURE__ */ jsx(Box, {
+			flexDirection: "column",
+			children: files.map((file) => /* @__PURE__ */ jsxs(Box, {
+				paddingLeft: 2,
+				children: [
+					/* @__PURE__ */ jsxs(Text, { children: [file.is_dir ? "📁" : "📄", " "] }),
+					/* @__PURE__ */ jsx(Text, {
+						color: colors.file,
+						children: file.path
+					}),
+					file.size !== void 0 && /* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						children: [
+							" (",
+							file.size,
+							" bytes)"
+						]
+					})
+				]
+			}, file.path))
+		})]
+	});
+}
+
+//#endregion
+//#region src/cli/components/ToolCall.tsx
+function ToolCall({ toolName, isExecuting = true }) {
+	if (isExecuting) return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Spinner, { label: toolName }) });
+	return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+		color: colors.success,
+		children: "✓"
+	}), /* @__PURE__ */ jsxs(Text, { children: [" ", toolName] })] });
+}
+/**
+* Thinking indicator with animated spinner.
+*/
+function ThinkingIndicator() {
+	return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+		color: colors.warning,
+		children: "● "
+	}), /* @__PURE__ */ jsx(Spinner, { label: "" })] });
+}
+function DoneIndicator({ todosCompleted, todosTotal, filesCount }) {
+	const hasTodos = todosTotal > 0;
+	const hasFiles = filesCount > 0;
+	if (!hasTodos && !hasFiles) return /* @__PURE__ */ jsx(Fragment, {});
+	return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, {
+		dimColor: true,
+		children: [
+			hasTodos && `${todosCompleted}/${todosTotal} tasks`,
+			hasTodos && hasFiles && " · ",
+			hasFiles && `${filesCount} files`
+		]
+	}) });
+}
+function ErrorDisplay({ error }) {
+	const message = error instanceof Error ? error.message : error;
+	return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, {
+		color: colors.error,
+		children: ["✗ ", message]
+	}) });
+}
+
+//#endregion
+//#region src/cli/components/Subagent.tsx
+function SubagentStart({ name, task, maxTaskLength = 60 }) {
+	const shortTask = task.length > maxTaskLength ? task.substring(0, maxTaskLength) + "..." : task;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		marginY: 1,
+		children: [/* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Spinner, { label: `${emoji.subagent} Starting subagent: ${name}` }) }), /* @__PURE__ */ jsx(Box, {
+			paddingLeft: 4,
+			children: /* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: ["└─ ", shortTask]
+			})
+		})]
+	});
+}
+function SubagentFinish({ name }) {
+	return /* @__PURE__ */ jsx(Box, {
+		marginY: 1,
+		children: /* @__PURE__ */ jsxs(StatusMessage, {
+			variant: "success",
+			children: [
+				emoji.subagent,
+				" Subagent ",
+				name,
+				" completed"
+			]
+		})
+	});
+}
+
+//#endregion
+//#region src/cli/components/StatusBar.tsx
+function StatusBar({ workDir, model, status = "idle", features, autoApproveEnabled = false, sessionId }) {
+	const shortModel = model.split("/").pop() || model;
+	const getStatusDisplay = () => {
+		switch (status) {
+			case "thinking": return /* @__PURE__ */ jsx(Text, {
+				color: colors.warning,
+				children: "●"
+			});
+			case "streaming": return /* @__PURE__ */ jsx(Text, {
+				color: colors.success,
+				children: "●"
+			});
+			case "tool-call": return /* @__PURE__ */ jsx(Text, {
+				color: colors.tool,
+				children: "●"
+			});
+			case "subagent": return /* @__PURE__ */ jsx(Text, {
+				color: colors.secondary,
+				children: "●"
+			});
+			case "error": return /* @__PURE__ */ jsx(Text, {
+				color: colors.error,
+				children: "●"
+			});
+			case "done": return /* @__PURE__ */ jsx(Text, {
+				color: colors.success,
+				children: "●"
+			});
+			default: return /* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "○"
+			});
+		}
+	};
+	const featureBadges = [];
+	if (features?.promptCaching) featureBadges.push("⚡");
+	if (features?.eviction) featureBadges.push("📦");
+	if (features?.summarization) featureBadges.push("📝");
+	return /* @__PURE__ */ jsx(Box, {
+		marginTop: 1,
+		children: /* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				getStatusDisplay(),
+				" ",
+				shortModel,
+				featureBadges.length > 0 && ` ${featureBadges.join(" ")}`,
+				" · ",
+				autoApproveEnabled ? /* @__PURE__ */ jsx(Text, {
+					color: colors.success,
+					children: "🟢 Auto-approve"
+				}) : /* @__PURE__ */ jsx(Text, {
+					color: colors.warning,
+					children: "🔴 Safe mode"
+				}),
+				sessionId && /* @__PURE__ */ jsxs(Fragment, { children: [" · ", /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: ["Session: ", sessionId]
+				})] }),
+				" · ",
+				"? for shortcuts"
+			]
+		})
+	});
+}
+
+//#endregion
+//#region src/cli/utils/model-list.ts
+const modelCache = {};
+const CACHE_TTL_MS = 1440 * 60 * 1e3;
+/**
+* Simple hash function for API key to detect changes.
+*/
+function hashApiKey(key) {
+	if (!key) return "";
+	return `${key.substring(0, 10)}...${key.substring(key.length - 4)}`;
+}
+/**
+* Check if cache is valid for a provider.
+*/
+function isCacheValid(provider) {
+	const entry = modelCache[provider];
+	if (!entry) return false;
+	if (Date.now() - entry.timestamp > CACHE_TTL_MS) return false;
+	const currentKeyHash = provider === "anthropic" ? hashApiKey(process.env.ANTHROPIC_API_KEY) : hashApiKey(process.env.OPENAI_API_KEY);
+	return entry.apiKeyHash === currentKeyHash;
+}
+/**
+* Get cached models for a provider.
+*/
+function getCachedModels(provider) {
+	if (isCacheValid(provider)) return modelCache[provider].models;
+	return null;
+}
+/**
+* Set cached models for a provider.
+*/
+function setCachedModels(provider, models) {
+	const apiKeyHash = provider === "anthropic" ? hashApiKey(process.env.ANTHROPIC_API_KEY) : hashApiKey(process.env.OPENAI_API_KEY);
+	modelCache[provider] = {
+		models,
+		timestamp: Date.now(),
+		apiKeyHash
+	};
+}
+/**
+* Detect which API keys are available in the environment.
+*/
+function detectAvailableProviders() {
+	return {
+		anthropic: !!process.env.ANTHROPIC_API_KEY,
+		openai: !!process.env.OPENAI_API_KEY
+	};
+}
+/**
+* Fetch available models from Anthropic API.
+* Returns empty array if no API key is set.
+*/
+async function fetchAnthropicModels() {
+	const apiKey = process.env.ANTHROPIC_API_KEY;
+	if (!apiKey) return {
+		models: [],
+		error: "No Anthropic API key configured"
+	};
+	const cached = getCachedModels("anthropic");
+	if (cached) return { models: cached };
+	try {
+		const response = await fetch("https://api.anthropic.com/v1/models?limit=100", {
+			method: "GET",
+			headers: {
+				"X-Api-Key": apiKey,
+				"anthropic-version": "2023-06-01"
+			}
+		});
+		if (!response.ok) {
+			const errorText = await response.text();
+			if (response.status === 401) return {
+				models: [],
+				error: "Invalid Anthropic API key"
+			};
+			return {
+				models: [],
+				error: `Anthropic API error: ${response.status} ${errorText}`
+			};
+		}
+		const models = (await response.json()).data.map((model) => ({
+			id: `anthropic/${model.id}`,
+			name: model.id,
+			provider: "anthropic",
+			description: model.display_name,
+			createdAt: model.created_at
+		}));
+		models.sort((a, b) => {
+			if (!a.createdAt || !b.createdAt) return 0;
+			return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+		});
+		setCachedModels("anthropic", models);
+		return { models };
+	} catch (error) {
+		return {
+			models: [],
+			error: `Failed to fetch Anthropic models: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+/**
+* Fetch available models from OpenAI API.
+* Returns empty array if no API key is set.
+*/
+async function fetchOpenAIModels() {
+	const apiKey = process.env.OPENAI_API_KEY;
+	if (!apiKey) return {
+		models: [],
+		error: "No OpenAI API key configured"
+	};
+	const cached = getCachedModels("openai");
+	if (cached) return { models: cached };
+	try {
+		const response = await fetch("https://api.openai.com/v1/models", {
+			method: "GET",
+			headers: { Authorization: `Bearer ${apiKey}` }
+		});
+		if (!response.ok) {
+			const errorText = await response.text();
+			if (response.status === 401) return {
+				models: [],
+				error: "Invalid OpenAI API key"
+			};
+			return {
+				models: [],
+				error: `OpenAI API error: ${response.status} ${errorText}`
+			};
+		}
+		const models = (await response.json()).data.filter((model) => model.id.startsWith("gpt-") || model.id.startsWith("o1") || model.id.startsWith("o3") || model.id.includes("chatgpt")).map((model) => ({
+			id: `openai/${model.id}`,
+			name: model.id,
+			provider: "openai",
+			description: getOpenAIModelDescription(model.id),
+			createdAt: (/* @__PURE__ */ new Date(model.created * 1e3)).toISOString()
+		}));
+		models.sort((a, b) => {
+			if (!a.createdAt || !b.createdAt) return 0;
+			return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+		});
+		setCachedModels("openai", models);
+		return { models };
+	} catch (error) {
+		return {
+			models: [],
+			error: `Failed to fetch OpenAI models: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+/**
+* Generate a description for OpenAI models based on their ID.
+*/
+function getOpenAIModelDescription(modelId) {
+	if (modelId.includes("gpt-4o-mini")) return "Fast and affordable GPT-4 variant";
+	if (modelId.includes("gpt-4o")) return "Latest GPT-4 optimized model";
+	if (modelId.includes("gpt-4-turbo")) return "GPT-4 Turbo";
+	if (modelId.includes("gpt-4")) return "GPT-4";
+	if (modelId.includes("gpt-3.5-turbo")) return "Fast and affordable";
+	if (modelId.startsWith("o1")) return "OpenAI o1 reasoning model";
+	if (modelId.startsWith("o3")) return "OpenAI o3 reasoning model";
+	return "";
+}
+/**
+* Get list of available models from all configured providers.
+* Only fetches from providers that have API keys configured.
+*/
+async function getAvailableModels() {
+	const providers = detectAvailableProviders();
+	const allModels = [];
+	const errors = [];
+	const promises = [];
+	if (providers.anthropic) promises.push(fetchAnthropicModels().then((result) => {
+		allModels.push(...result.models);
+		if (result.error) errors.push({
+			provider: "Anthropic",
+			error: result.error
+		});
+	}));
+	if (providers.openai) promises.push(fetchOpenAIModels().then((result) => {
+		allModels.push(...result.models);
+		if (result.error) errors.push({
+			provider: "OpenAI",
+			error: result.error
+		});
+	}));
+	await Promise.all(promises);
+	return {
+		models: allModels,
+		errors,
+		loading: false
+	};
+}
+/**
+* Get models grouped by provider.
+*/
+async function getModelsByProvider() {
+	const result = await getAvailableModels();
+	const grouped = { errors: result.errors };
+	for (const model of result.models) {
+		if (!grouped[model.provider]) grouped[model.provider] = [];
+		grouped[model.provider].push(model);
+	}
+	return grouped;
+}
+
+//#endregion
+//#region src/cli/components/ModelSelection.tsx
+/**
+* Model Selection Panel - Interactive model selection with arrow keys.
+*/
+function ModelSelectionPanel({ currentModel, onModelSelect, onClose }) {
+	const providers = detectAvailableProviders();
+	const hasAnyKey = providers.anthropic || providers.openai;
+	const [state, setState] = useState({
+		loading: true,
+		anthropicModels: [],
+		openaiModels: [],
+		errors: []
+	});
+	const [selectedIndex, setSelectedIndex] = useState(0);
+	const allModels = useMemo(() => {
+		const models = [];
+		if (state.anthropicModels.length > 0) models.push(...state.anthropicModels);
+		if (state.openaiModels.length > 0) models.push(...state.openaiModels);
+		return models;
+	}, [state.anthropicModels, state.openaiModels]);
+	useEffect(() => {
+		if (allModels.length > 0 && currentModel) {
+			const currentIndex = allModels.findIndex((m) => isCurrentModel(currentModel, m));
+			if (currentIndex >= 0) setSelectedIndex(currentIndex);
+		}
+	}, [allModels, currentModel]);
+	useInput((input, key) => {
+		if (state.loading) return;
+		if (key.upArrow) setSelectedIndex((prev) => prev > 0 ? prev - 1 : allModels.length - 1);
+		else if (key.downArrow) setSelectedIndex((prev) => prev < allModels.length - 1 ? prev + 1 : 0);
+		else if (key.return) {
+			const selectedModel = allModels[selectedIndex];
+			if (selectedModel) {
+				onModelSelect?.(selectedModel.id);
+				onClose?.();
+			}
+		} else if (key.escape) onClose?.();
+	});
+	useEffect(() => {
+		if (!hasAnyKey) {
+			setState({
+				loading: false,
+				anthropicModels: [],
+				openaiModels: [],
+				errors: []
+			});
+			return;
+		}
+		let cancelled = false;
+		async function loadModels() {
+			try {
+				const result = await getModelsByProvider();
+				if (!cancelled) setState({
+					loading: false,
+					anthropicModels: result.anthropic || [],
+					openaiModels: result.openai || [],
+					errors: result.errors
+				});
+			} catch (error) {
+				if (!cancelled) setState({
+					loading: false,
+					anthropicModels: [],
+					openaiModels: [],
+					errors: [{
+						provider: "Unknown",
+						error: String(error)
+					}]
+				});
+			}
+		}
+		loadModels();
+		return () => {
+			cancelled = true;
+		};
+	}, [hasAnyKey]);
+	if (!hasAnyKey) return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: colors.warning,
+		paddingX: 2,
+		paddingY: 1,
+		marginY: 1,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				bold: true,
+				color: colors.warning,
+				children: "⚠️ No API Keys Found"
+			}),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			/* @__PURE__ */ jsx(Text, { children: "Add an API key first to see available models." }),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			/* @__PURE__ */ jsx(Text, {
+				color: colors.primary,
+				children: "Run /apikey to add your API key"
+			}),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "Supported providers:"
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "  • Anthropic (Claude)"
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "  • OpenAI (GPT)"
+			})
+		]
+	});
+	if (state.loading) return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: colors.muted,
+		paddingX: 2,
+		paddingY: 1,
+		marginY: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				bold: true,
+				color: colors.info,
+				children: [emoji.model, " Select Model"]
+			}),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			/* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Spinner, { label: "Fetching models from API..." }) })
+		]
+	});
+	if (!(allModels.length > 0) && state.errors.length > 0) return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: colors.error,
+		paddingX: 2,
+		paddingY: 1,
+		marginY: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				bold: true,
+				color: colors.error,
+				children: [emoji.error, " Failed to Fetch Models"]
+			}),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			state.errors.map((err, i) => /* @__PURE__ */ jsxs(Text, {
+				color: colors.error,
+				children: [
+					err.provider,
+					": ",
+					err.error
+				]
+			}, i)),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "Check your API key and try again with /apikey"
+			})
+		]
+	});
+	let anthropicOffset = 0;
+	let openaiOffset = state.anthropicModels.length;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: colors.primary,
+		paddingX: 2,
+		paddingY: 1,
+		marginY: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				bold: true,
+				color: colors.info,
+				children: [emoji.model, " Select Model"]
+			}),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			state.errors.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [state.errors.map((err, i) => /* @__PURE__ */ jsxs(Text, {
+				color: colors.warning,
+				children: [
+					emoji.warning,
+					" ",
+					err.provider,
+					": ",
+					err.error
+				]
+			}, i)), /* @__PURE__ */ jsx(Box, { height: 1 })] }),
+			state.anthropicModels.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx(Text, {
+					bold: true,
+					color: colors.primary,
+					children: "Anthropic Claude"
+				}),
+				state.anthropicModels.map((model, index) => {
+					return /* @__PURE__ */ jsx(ModelItem, {
+						model,
+						isSelected: anthropicOffset + index === selectedIndex,
+						isCurrent: isCurrentModel(currentModel, model)
+					}, model.id);
+				}),
+				/* @__PURE__ */ jsx(Box, { height: 1 })
+			] }),
+			state.openaiModels.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx(Text, {
+					bold: true,
+					color: colors.primary,
+					children: "OpenAI GPT"
+				}),
+				state.openaiModels.map((model, index) => {
+					return /* @__PURE__ */ jsx(ModelItem, {
+						model,
+						isSelected: openaiOffset + index === selectedIndex,
+						isCurrent: isCurrentModel(currentModel, model)
+					}, model.id);
+				}),
+				/* @__PURE__ */ jsx(Box, { height: 1 })
+			] }),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "↑/↓ Navigate • Enter Select • Esc Cancel"
+			})
+		]
+	});
+}
+/**
+* Check if a model matches the current model.
+*/
+function isCurrentModel(currentModel, model) {
+	if (!currentModel) return false;
+	return currentModel === model.id || currentModel === model.name || currentModel === `${model.provider}/${model.name}` || currentModel.startsWith(`${model.provider}/`) && currentModel === model.id;
+}
+function ModelItem({ model, isSelected, isCurrent }) {
+	let indicator = "  ";
+	let textColor = void 0;
+	let isBold = false;
+	if (isSelected) {
+		indicator = "▸ ";
+		textColor = colors.primary;
+		isBold = true;
+	}
+	if (isCurrent) {
+		indicator = isSelected ? "▸✓" : " ✓";
+		textColor = isSelected ? colors.primary : colors.success;
+	}
+	return /* @__PURE__ */ jsxs(Box, {
+		marginLeft: 1,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: isSelected ? colors.primary : isCurrent ? colors.success : void 0,
+				children: indicator
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				color: textColor,
+				bold: isBold,
+				children: model.id
+			}),
+			model.description && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: " - "
+			}), /* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: model.description
+			})] })
+		]
+	});
+}
+
+//#endregion
+//#region src/cli/components/ApiKeyInput.tsx
+/**
+* API Key Input Panel - Interactive provider selection and key input.
+* Shows current status and allows adding/updating keys.
+*/
+function ApiKeyInputPanel({ onKeySaved, onClose }) {
+	const [step, setStep] = useState("select-provider");
+	const [selectedProvider, setSelectedProvider] = useState(null);
+	const [apiKey, setApiKey] = useState("");
+	const [error, setError] = useState(null);
+	const anthropicKey = process.env.ANTHROPIC_API_KEY;
+	const openaiKey = process.env.OPENAI_API_KEY;
+	const maskKey = (key) => {
+		if (!key) return null;
+		if (key.length <= 8) return "•".repeat(key.length);
+		return key.substring(0, 10) + "..." + key.substring(key.length - 4);
+	};
+	useInput((input, key) => {
+		if (step === "select-provider") {
+			if (input === "1" || input.toLowerCase() === "a") {
+				setSelectedProvider("anthropic");
+				setStep("enter-key");
+				setError(null);
+				if (anthropicKey) setApiKey(anthropicKey);
+			} else if (input === "2" || input.toLowerCase() === "o") {
+				setSelectedProvider("openai");
+				setStep("enter-key");
+				setError(null);
+				if (openaiKey) setApiKey(openaiKey);
+			} else if (key.escape) onClose?.();
+		} else if (step === "enter-key") {
+			if (key.escape) {
+				setStep("select-provider");
+				setApiKey("");
+				setSelectedProvider(null);
+				setError(null);
+			} else if (key.return) {
+				if (!apiKey.trim()) {
+					setError("API key cannot be empty");
+					return;
+				}
+				if (selectedProvider === "anthropic" && !apiKey.startsWith("sk-ant-")) {
+					setError("Anthropic API keys typically start with 'sk-ant-'");
+					return;
+				}
+				if (selectedProvider === "openai" && !apiKey.startsWith("sk-")) {
+					setError("OpenAI API keys typically start with 'sk-'");
+					return;
+				}
+				if (selectedProvider === "anthropic") process.env.ANTHROPIC_API_KEY = apiKey.trim();
+				else if (selectedProvider === "openai") process.env.OPENAI_API_KEY = apiKey.trim();
+				setStep("success");
+				onKeySaved?.(selectedProvider, apiKey.trim());
+				setTimeout(() => {
+					setStep("select-provider");
+					setApiKey("");
+					setSelectedProvider(null);
+				}, 1500);
+			} else if (key.backspace || key.delete) {
+				setApiKey((prev) => prev.slice(0, -1));
+				setError(null);
+			} else if (input && !key.ctrl && !key.meta) {
+				setApiKey((prev) => prev + input);
+				setError(null);
+			}
+		} else if (step === "success") {
+			if (key.return || key.escape) {
+				setStep("select-provider");
+				setApiKey("");
+				setSelectedProvider(null);
+			}
+		}
+	});
+	const maskKeyForInput = (key) => {
+		if (key.length <= 8) return "•".repeat(key.length);
+		return key.substring(0, 7) + "•".repeat(Math.min(key.length - 11, 20)) + key.substring(key.length - 4);
+	};
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: colors.primary,
+		paddingX: 2,
+		paddingY: 1,
+		marginY: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				bold: true,
+				color: colors.info,
+				children: [emoji.key, " API Key Management"]
+			}),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			/* @__PURE__ */ jsx(Text, {
+				bold: true,
+				children: "Current Status:"
+			}),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			/* @__PURE__ */ jsx(Box, {
+				marginLeft: 2,
+				children: anthropicKey ? /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(Text, {
+						color: colors.success,
+						children: "✓ "
+					}),
+					/* @__PURE__ */ jsx(Text, { children: "Anthropic: " }),
+					/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: maskKey(anthropicKey)
+					})
+				] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(Text, {
+						color: colors.warning,
+						children: "✗ "
+					}),
+					/* @__PURE__ */ jsx(Text, { children: "Anthropic: " }),
+					/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: "not set"
+					})
+				] })
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				marginLeft: 2,
+				children: openaiKey ? /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(Text, {
+						color: colors.success,
+						children: "✓ "
+					}),
+					/* @__PURE__ */ jsx(Text, { children: "OpenAI: " }),
+					/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: maskKey(openaiKey)
+					})
+				] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(Text, {
+						color: colors.warning,
+						children: "✗ "
+					}),
+					/* @__PURE__ */ jsx(Text, { children: "OpenAI: " }),
+					/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: "not set"
+					})
+				] })
+			}),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			step === "select-provider" && /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx(Text, {
+					bold: true,
+					children: "Add or Update Key:"
+				}),
+				/* @__PURE__ */ jsx(Box, { height: 1 }),
+				/* @__PURE__ */ jsxs(Box, {
+					marginLeft: 2,
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							color: colors.primary,
+							children: "[1]"
+						}),
+						/* @__PURE__ */ jsx(Text, { children: " Anthropic (Claude)" }),
+						anthropicKey && /* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							children: " (overwrite)"
+						})
+					]
+				}),
+				/* @__PURE__ */ jsxs(Box, {
+					marginLeft: 2,
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							color: colors.primary,
+							children: "[2]"
+						}),
+						/* @__PURE__ */ jsx(Text, { children: " OpenAI (GPT)" }),
+						openaiKey && /* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							children: " (overwrite)"
+						})
+					]
+				}),
+				/* @__PURE__ */ jsx(Box, { height: 1 }),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "Press 1 or 2 to select, Esc to close"
+				})
+			] }),
+			step === "enter-key" && selectedProvider && /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsxs(Text, { children: [
+					"Enter your",
+					" ",
+					/* @__PURE__ */ jsx(Text, {
+						color: colors.primary,
+						children: selectedProvider === "anthropic" ? "Anthropic" : "OpenAI"
+					}),
+					" ",
+					"API key:",
+					selectedProvider === "anthropic" && anthropicKey && /* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						children: [
+							" (current: ",
+							maskKey(anthropicKey),
+							")"
+						]
+					}),
+					selectedProvider === "openai" && openaiKey && /* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						children: [
+							" (current: ",
+							maskKey(openaiKey),
+							")"
+						]
+					})
+				] }),
+				/* @__PURE__ */ jsx(Box, { height: 1 }),
+				/* @__PURE__ */ jsxs(Box, { children: [
+					/* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						children: [">", " "]
+					}),
+					/* @__PURE__ */ jsx(Text, { children: apiKey ? maskKeyForInput(apiKey) : /* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: "Paste your API key here..."
+					}) }),
+					/* @__PURE__ */ jsx(Text, {
+						color: colors.primary,
+						children: "█"
+					})
+				] }),
+				error && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Box, { height: 1 }), /* @__PURE__ */ jsxs(Text, {
+					color: colors.error,
+					children: [
+						emoji.warning,
+						" ",
+						error
+					]
+				})] }),
+				/* @__PURE__ */ jsx(Box, { height: 1 }),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "Press Enter to save, Esc to go back"
+				})
+			] }),
+			step === "success" && selectedProvider && /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsxs(Text, {
+					color: colors.success,
+					children: [
+						emoji.completed,
+						" API key saved for",
+						" ",
+						selectedProvider === "anthropic" ? "Anthropic" : "OpenAI",
+						"!"
+					]
+				}),
+				/* @__PURE__ */ jsx(Box, { height: 1 }),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "Press Enter or Esc to return to menu"
+				})
+			] })
+		]
+	});
+}
+
+//#endregion
+//#region src/cli/components/ToolApproval.tsx
+function ToolApproval({ toolName, args, onApprove, onDeny, onApproveAll }) {
+	useInput((input, key) => {
+		if (input === "y" || input === "Y") onApprove();
+		else if (input === "n" || input === "N" || key.escape) onDeny();
+		else if ((input === "a" || input === "A") && onApproveAll) onApproveAll();
+	});
+	const argsDisplay = JSON.stringify(args, null, 2);
+	const truncatedArgs = argsDisplay.length > 500 ? argsDisplay.slice(0, 500) + "\n... (truncated)" : argsDisplay;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		borderStyle: "round",
+		borderColor: "yellow",
+		paddingX: 1,
+		marginY: 1,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				bold: true,
+				color: "yellow",
+				children: "🛑 Tool Approval Required"
+			}),
+			/* @__PURE__ */ jsxs(Text, { children: ["Tool: ", /* @__PURE__ */ jsx(Text, {
+				bold: true,
+				children: toolName
+			})] }),
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "Arguments:"
+				})
+			}),
+			/* @__PURE__ */ jsx(Text, { children: truncatedArgs }),
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsxs(Text, { children: [
+					"Press ",
+					/* @__PURE__ */ jsx(Text, {
+						bold: true,
+						color: "green",
+						children: "[Y]"
+					}),
+					" to approve,",
+					" ",
+					/* @__PURE__ */ jsx(Text, {
+						bold: true,
+						color: "red",
+						children: "[N]"
+					}),
+					" to deny",
+					onApproveAll && /* @__PURE__ */ jsxs(Fragment, { children: [
+						", ",
+						/* @__PURE__ */ jsx(Text, {
+							bold: true,
+							color: "blue",
+							children: "[A]"
+						}),
+						" to approve all (enable auto-approve)"
+					] })
+				] })
+			})
+		]
+	});
+}
+
+//#endregion
+//#region src/cli/index.tsx
+/**
+* Deep Agent CLI - Interactive terminal interface using Ink.
+*
+* Usage:
+*   ANTHROPIC_API_KEY=xxx bunx deep-agent-ink
+*   ANTHROPIC_API_KEY=xxx bun src/cli-ink/index.tsx
+*
+* Or with options:
+*   ANTHROPIC_API_KEY=xxx bunx deep-agent-ink --model anthropic/claude-sonnet-4-20250514
+*/
+const DEFAULT_PROMPT_CACHING = true;
+const DEFAULT_EVICTION_LIMIT = DEFAULT_EVICTION_TOKEN_LIMIT;
+const DEFAULT_SUMMARIZATION = true;
+const DEFAULT_SUMMARIZATION_THRESHOLD_VALUE = DEFAULT_SUMMARIZATION_THRESHOLD;
+const DEFAULT_SUMMARIZATION_KEEP = DEFAULT_KEEP_MESSAGES;
+function parseArgs() {
+	const args = process.argv.slice(2);
+	const options = {
+		enablePromptCaching: DEFAULT_PROMPT_CACHING,
+		toolResultEvictionLimit: DEFAULT_EVICTION_LIMIT,
+		enableSummarization: DEFAULT_SUMMARIZATION,
+		summarizationThreshold: DEFAULT_SUMMARIZATION_THRESHOLD_VALUE,
+		summarizationKeepMessages: DEFAULT_SUMMARIZATION_KEEP
+	};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--model" || arg === "-m") options.model = args[++i];
+		else if (arg === "--max-steps" || arg === "-s") {
+			const val = args[++i];
+			if (val) options.maxSteps = parseInt(val, 10);
+		} else if (arg === "--prompt" || arg === "-p") options.systemPrompt = args[++i];
+		else if (arg === "--dir" || arg === "-d") options.workDir = args[++i];
+		else if (arg === "--cache" || arg === "--prompt-caching") options.enablePromptCaching = true;
+		else if (arg === "--no-cache" || arg === "--no-prompt-caching") options.enablePromptCaching = false;
+		else if (arg === "--eviction-limit" || arg === "-e") {
+			const val = args[++i];
+			if (val) options.toolResultEvictionLimit = parseInt(val, 10);
+		} else if (arg === "--no-eviction") options.toolResultEvictionLimit = 0;
+		else if (arg === "--summarize" || arg === "--auto-summarize") options.enableSummarization = true;
+		else if (arg === "--no-summarize" || arg === "--no-auto-summarize") options.enableSummarization = false;
+		else if (arg === "--summarize-threshold") {
+			const val = args[++i];
+			if (val) {
+				options.summarizationThreshold = parseInt(val, 10);
+				options.enableSummarization = true;
+			}
+		} else if (arg === "--summarize-keep") {
+			const val = args[++i];
+			if (val) {
+				options.summarizationKeepMessages = parseInt(val, 10);
+				options.enableSummarization = true;
+			}
+		} else if (arg === "--session") {
+			const val = args[++i];
+			if (val) options.session = val;
+		} else if (arg && arg.startsWith("--session=")) {
+			const sessionVal = arg.split("=")[1];
+			if (sessionVal) options.session = sessionVal;
+		} else if (arg === "--help" || arg === "-h") {
+			printHelp();
+			process.exit(0);
+		}
+	}
+	return options;
+}
+const DEEP_AGENTS_ASCII = `
+  █████╗  ██╗      ███████╗ ██████╗  ██╗  ██╗
+ ██╔══██╗ ██║      ██╔════╝ ██╔══██╗ ██║ ██╔╝
+ ███████║ ██║█████╗███████╗ ██║  ██║ █████╔╝
+ ██╔══██║ ██║╚════╝╚════██║ ██║  ██║ ██╔═██╗
+ ██║  ██║ ██║      ███████║ ██████╔╝ ██║  ██╗
+ ╚═╝  ╚═╝ ╚═╝      ╚══════╝ ╚═════╝  ╚═╝  ╚═╝
+
+ ██████╗  ███████╗ ███████╗ ██████╗
+ ██╔══██╗ ██╔════╝ ██╔════╝ ██╔══██╗
+ ██║  ██║ █████╗   █████╗   ██████╔╝
+ ██║  ██║ ██╔══╝   ██╔══╝   ██╔═══╝
+ ██████╔╝ ███████╗ ███████╗ ██║
+ ╚═════╝  ╚══════╝ ╚══════╝ ╚═╝
+
+  █████╗   ██████╗  ███████╗ ███╗   ██╗ ████████╗
+ ██╔══██╗ ██╔════╝  ██╔════╝ ████╗  ██║ ╚══██╔══╝
+ ███████║ ██║  ███╗ █████╗   ██╔██╗ ██║    ██║
+ ██╔══██║ ██║   ██║ ██╔══╝   ██║╚██╗██║    ██║
+ ██║  ██║ ╚██████╔╝ ███████╗ ██║ ╚████║    ██║
+ ╚═╝  ╚═╝  ╚═════╝  ╚══════╝ ╚═╝  ╚═══╝    ╚═╝
+`;
+function printHelp() {
+	console.log(`
+${DEEP_AGENTS_ASCII}
+
+Usage:
+  bun src/cli-ink/index.tsx [options]
+
+Options:
+  --model, -m <model>       Model to use (default: anthropic/claude-haiku-4-5-20251001)
+  --max-steps, -s <number>  Maximum steps per generation (default: 100)
+  --prompt, -p <prompt>     Custom system prompt
+  --dir, -d <directory>     Working directory for file operations (default: current dir)
+  --help, -h                Show this help
+
+Performance & Memory (all enabled by default):
+  --no-cache                Disable prompt caching (enabled by default for Anthropic)
+  --no-eviction             Disable tool result eviction (enabled by default: 20k tokens)
+  --eviction-limit, -e <n>  Set custom eviction token limit
+  --no-summarize            Disable auto-summarization (enabled by default)
+  --summarize-threshold <n> Token threshold to trigger summarization (default: 170000)
+  --summarize-keep <n>      Number of recent messages to keep intact (default: 6)
+
+Runtime Commands:
+  /cache on|off             Toggle prompt caching
+  /eviction on|off          Toggle tool result eviction
+  /summarize on|off         Toggle auto-summarization
+  /features                 Show current feature status
+
+API Keys:
+  The CLI automatically loads API keys from:
+  1. Environment variables (ANTHROPIC_API_KEY, OPENAI_API_KEY, TAVILY_API_KEY)
+  2. .env or .env.local file in the working directory
+
+  Example .env file:
+    ANTHROPIC_API_KEY=sk-ant-...
+    OPENAI_API_KEY=sk-...
+    TAVILY_API_KEY=tvly-...  # For web_search tool
+
+Examples:
+  bun src/cli-ink/index.tsx                                    # uses .env file
+  bun src/cli-ink/index.tsx --dir ./my-project                 # loads .env from ./my-project
+  ANTHROPIC_API_KEY=xxx bun src/cli-ink/index.tsx              # env var takes precedence
+  bun src/cli-ink/index.tsx --model anthropic/claude-sonnet-4-20250514
+`);
+}
+function App({ options, backend }) {
+	const { exit } = useApp();
+	const summarizationConfig = options.enableSummarization ? {
+		enabled: true,
+		tokenThreshold: options.summarizationThreshold,
+		keepMessages: options.summarizationKeepMessages
+	} : void 0;
+	const checkpointer = options.session ? new FileSaver({ dir: "./.checkpoints" }) : void 0;
+	const agent = useAgent({
+		model: options.model || "anthropic/claude-haiku-4-5-20251001",
+		maxSteps: options.maxSteps || 100,
+		systemPrompt: options.systemPrompt,
+		backend,
+		enablePromptCaching: options.enablePromptCaching,
+		toolResultEvictionLimit: options.toolResultEvictionLimit,
+		summarization: summarizationConfig,
+		sessionId: options.session,
+		checkpointer,
+		interruptOn: {
+			execute: true,
+			write_file: true,
+			edit_file: true
+		}
+	});
+	const [messages, setMessages] = useState([]);
+	const [showWelcome, setShowWelcome] = useState(true);
+	const [panel, setPanel] = useState({ view: "none" });
+	useInput((input, key) => {
+		if (key.ctrl && input === "c") if (agent.status !== "idle") agent.abort();
+		else exit();
+		if (key.ctrl && input === "d") exit();
+	});
+	const handleSubmit = useCallback(async (input) => {
+		const trimmed = input.trim();
+		if (!trimmed) return;
+		if (showWelcome) setShowWelcome(false);
+		const { isCommand, command, args } = parseCommand(trimmed);
+		if (isCommand) {
+			await handleCommand(command, args);
+			return;
+		}
+		setPanel({ view: "none" });
+		await agent.sendPrompt(trimmed);
+	}, [showWelcome, agent]);
+	const handleCommand = async (command, args) => {
+		if (!command || command === "") {
+			setPanel({ view: "help" });
+			return;
+		}
+		switch (command) {
+			case "todos":
+			case "todo":
+			case "t":
+				setPanel({ view: "todos" });
+				break;
+			case "files":
+			case "file":
+			case "f":
+				try {
+					setPanel({
+						view: "files",
+						files: await backend.lsInfo(".")
+					});
+				} catch (err) {}
+				break;
+			case "read":
+			case "r":
+				if (!args) return;
+				try {
+					setPanel({
+						view: "file-content",
+						filePath: args,
+						fileContent: await backend.read(args)
+					});
+				} catch (err) {}
+				break;
+			case "apikey":
+			case "key":
+			case "api":
+				setPanel({ view: "apikey-input" });
+				break;
+			case "model":
+				if (args) agent.setModel(args.trim());
+				else setPanel({ view: "models" });
+				break;
+			case "features":
+			case "feat":
+				setPanel({ view: "features" });
+				break;
+			case "tokens":
+			case "tok":
+				setPanel({
+					view: "tokens",
+					tokenCount: estimateMessagesTokens(agent.messages)
+				});
+				break;
+			case "sessions":
+			case "session-list":
+				if (checkpointer) {
+					const sessions = await checkpointer.list();
+					if (sessions.length > 0) {
+						const sessionList = sessions.map((s) => `  - ${s}`).join("\n");
+						setMessages((prev) => [...prev, {
+							id: `session-list-${Date.now()}`,
+							role: "assistant",
+							content: `Saved sessions:\n${sessionList}`,
+							timestamp: /* @__PURE__ */ new Date()
+						}]);
+					} else setMessages((prev) => [...prev, {
+						id: `session-list-empty-${Date.now()}`,
+						role: "assistant",
+						content: "No saved sessions",
+						timestamp: /* @__PURE__ */ new Date()
+					}]);
+				} else setMessages((prev) => [...prev, {
+					id: `session-error-${Date.now()}`,
+					role: "assistant",
+					content: "Checkpointing not enabled. Use --session to enable.",
+					timestamp: /* @__PURE__ */ new Date()
+				}]);
+				break;
+			case "session":
+				if (!args) {
+					setMessages((prev) => [...prev, {
+						id: `session-usage-${Date.now()}`,
+						role: "assistant",
+						content: "Usage: /session clear",
+						timestamp: /* @__PURE__ */ new Date()
+					}]);
+					return;
+				}
+				if (args.trim() === "clear" && options.session && checkpointer) {
+					await checkpointer.delete(options.session);
+					setMessages([]);
+					agent.clear();
+					setShowWelcome(true);
+					setPanel({ view: "none" });
+					setMessages((prev) => [...prev, {
+						id: `session-cleared-${Date.now()}`,
+						role: "assistant",
+						content: "Session cleared.",
+						timestamp: /* @__PURE__ */ new Date()
+					}]);
+				}
+				break;
+			case "clear":
+			case "c":
+				setMessages([]);
+				agent.clear();
+				setShowWelcome(true);
+				setPanel({ view: "none" });
+				break;
+			case "cache":
+				if (args === "on" || args === "true" || args === "1") agent.setPromptCaching(true);
+				else if (args === "off" || args === "false" || args === "0") agent.setPromptCaching(false);
+				else agent.setPromptCaching(!agent.features.promptCaching);
+				setPanel({ view: "features" });
+				break;
+			case "eviction":
+			case "evict":
+				if (args === "on" || args === "true" || args === "1") agent.setEviction(true);
+				else if (args === "off" || args === "false" || args === "0") agent.setEviction(false);
+				else agent.setEviction(!agent.features.eviction);
+				setPanel({ view: "features" });
+				break;
+			case "summarize":
+			case "sum":
+				if (args === "on" || args === "true" || args === "1") agent.setSummarization(true);
+				else if (args === "off" || args === "false" || args === "0") agent.setSummarization(false);
+				else agent.setSummarization(!agent.features.summarization);
+				setPanel({ view: "features" });
+				break;
+			case "approve":
+				const newValue = !agent.autoApproveEnabled;
+				agent.setAutoApprove(newValue);
+				return;
+			case "help":
+			case "h":
+			case "?":
+				setPanel({ view: "help" });
+				break;
+			case "quit":
+			case "exit":
+			case "q":
+				exit();
+				break;
+			case "state":
+				console.log(JSON.stringify(agent.state, null, 2));
+				break;
+		}
+	};
+	const isGenerating = agent.status !== "idle" && agent.status !== "done" && agent.status !== "error";
+	const isInteractivePanel = panel.view === "apikey-input" || panel.view === "models";
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		padding: 1,
+		children: [
+			showWelcome && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Welcome, {
+				model: agent.currentModel,
+				workDir: options.workDir || process.cwd()
+			}), /* @__PURE__ */ jsx(WelcomeHint, {})] }),
+			panel.view === "help" && /* @__PURE__ */ jsx(SlashMenuPanel, {}),
+			panel.view === "todos" && /* @__PURE__ */ jsx(TodoList, { todos: agent.state.todos }),
+			panel.view === "files" && panel.files && /* @__PURE__ */ jsx(FileList, { files: panel.files }),
+			panel.view === "file-content" && panel.filePath && panel.fileContent && /* @__PURE__ */ jsx(FilePreview, {
+				path: panel.filePath,
+				content: panel.fileContent
+			}),
+			panel.view === "apikey-input" && /* @__PURE__ */ jsx(ApiKeyInputPanel, {
+				onKeySaved: () => {},
+				onClose: () => setPanel({ view: "none" })
+			}),
+			panel.view === "features" && /* @__PURE__ */ jsx(FeaturesPanel, {
+				features: agent.features,
+				options
+			}),
+			panel.view === "tokens" && /* @__PURE__ */ jsx(TokensPanel, {
+				tokenCount: panel.tokenCount || 0,
+				messageCount: agent.messages.length
+			}),
+			panel.view === "models" && /* @__PURE__ */ jsx(ModelSelectionPanel, {
+				currentModel: agent.currentModel,
+				onModelSelect: (modelId) => {
+					agent.setModel(modelId);
+				},
+				onClose: () => setPanel({ view: "none" })
+			}),
+			agent.events.length > 0 && /* @__PURE__ */ jsx(Box, {
+				flexDirection: "column",
+				children: agent.events.map((event) => /* @__PURE__ */ jsx(EventRenderer, { event }, event.id))
+			}),
+			isGenerating && /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				children: [agent.streamingText && /* @__PURE__ */ jsx(Box, {
+					marginY: 1,
+					children: /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+						color: colors.success,
+						children: "● "
+					}), /* @__PURE__ */ jsxs(Text, { children: [agent.streamingText, /* @__PURE__ */ jsx(Text, {
+						color: colors.muted,
+						children: "▌"
+					})] })] })
+				}), (agent.status === "thinking" || agent.status === "tool-call") && !agent.streamingText && /* @__PURE__ */ jsx(Box, {
+					marginY: 1,
+					children: /* @__PURE__ */ jsx(ThinkingIndicator, {})
+				})]
+			}),
+			agent.error && /* @__PURE__ */ jsx(ErrorDisplay, { error: agent.error }),
+			agent.pendingApproval && !agent.autoApproveEnabled && /* @__PURE__ */ jsx(ToolApproval, {
+				toolName: agent.pendingApproval.toolName,
+				args: agent.pendingApproval.args,
+				onApprove: () => agent.respondToApproval(true),
+				onDeny: () => agent.respondToApproval(false),
+				onApproveAll: () => {
+					agent.setAutoApprove(true);
+					agent.respondToApproval(true);
+				}
+			}),
+			!isInteractivePanel && /* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsx(Input, {
+					onSubmit: handleSubmit,
+					disabled: isGenerating
+				})
+			}),
+			/* @__PURE__ */ jsx(StatusBar, {
+				workDir: options.workDir || process.cwd(),
+				model: agent.currentModel,
+				status: agent.status,
+				features: agent.features,
+				autoApproveEnabled: agent.autoApproveEnabled,
+				sessionId: options.session
+			})
+		]
+	});
+}
+const TOOLS_WITH_SPECIFIC_EVENTS = new Set([
+	"read_file",
+	"ls",
+	"glob",
+	"grep",
+	"write_file",
+	"edit_file",
+	"write_todos",
+	"web_search",
+	"http_request",
+	"fetch_url"
+]);
+function EventRenderer({ event }) {
+	const e = event.event;
+	switch (e.type) {
+		case "user-message": return /* @__PURE__ */ jsxs(Box, {
+			marginBottom: 1,
+			children: [/* @__PURE__ */ jsx(Text, {
+				color: colors.muted,
+				bold: true,
+				children: "> "
+			}), /* @__PURE__ */ jsx(Text, {
+				bold: true,
+				children: e.content
+			})]
+		});
+		case "text-segment":
+			if (!e.text.trim()) return null;
+			return /* @__PURE__ */ jsx(Box, {
+				marginY: 1,
+				children: /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+					color: colors.success,
+					children: "● "
+				}), /* @__PURE__ */ jsx(Text, { children: e.text })] })
+			});
+		case "step-start": return /* @__PURE__ */ jsx(Box, {
+			marginTop: 1,
+			children: /* @__PURE__ */ jsxs(Text, {
+				color: colors.muted,
+				children: [
+					"─── step ",
+					e.stepNumber,
+					" ───"
+				]
+			})
+		});
+		case "tool-call":
+			if (TOOLS_WITH_SPECIFIC_EVENTS.has(e.toolName)) return null;
+			return /* @__PURE__ */ jsx(ToolCall, {
+				toolName: e.toolName,
+				isExecuting: true
+			});
+		case "todos-changed": return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+			color: colors.info,
+			children: "📋 Todos: "
+		}), /* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				e.todos.filter((t) => t.status === "completed").length,
+				"/",
+				e.todos.length,
+				" completed"
+			]
+		})] });
+		case "file-write-start": return /* @__PURE__ */ jsx(FilePreview, {
+			path: e.path,
+			content: e.content,
+			isWrite: true,
+			maxLines: 10
+		});
+		case "file-written": return /* @__PURE__ */ jsx(FileWritten, { path: e.path });
+		case "file-edited": return /* @__PURE__ */ jsx(FileEdited, {
+			path: e.path,
+			occurrences: e.occurrences
+		});
+		case "file-read": return /* @__PURE__ */ jsx(FileRead, {
+			path: e.path,
+			lines: e.lines
+		});
+		case "ls": return /* @__PURE__ */ jsx(LsResult, {
+			path: e.path,
+			count: e.count
+		});
+		case "glob": return /* @__PURE__ */ jsx(GlobResult, {
+			pattern: e.pattern,
+			count: e.count
+		});
+		case "grep": return /* @__PURE__ */ jsx(GrepResult, {
+			pattern: e.pattern,
+			count: e.count
+		});
+		case "web-search-start": return /* @__PURE__ */ jsxs(Box, { children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: colors.info,
+				children: "🔍 "
+			}),
+			/* @__PURE__ */ jsx(Text, { children: "Searching web: " }),
+			/* @__PURE__ */ jsx(Text, {
+				color: colors.muted,
+				children: e.query
+			})
+		] });
+		case "web-search-finish": return /* @__PURE__ */ jsxs(Box, { children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: colors.success,
+				children: "✓ "
+			}),
+			/* @__PURE__ */ jsx(Text, { children: "Found " }),
+			/* @__PURE__ */ jsx(Text, {
+				color: colors.info,
+				children: e.resultCount
+			}),
+			/* @__PURE__ */ jsx(Text, { children: " results" })
+		] });
+		case "http-request-start": return /* @__PURE__ */ jsxs(Box, { children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: colors.info,
+				children: "🌐 "
+			}),
+			/* @__PURE__ */ jsxs(Text, { children: [e.method, " "] }),
+			/* @__PURE__ */ jsx(Text, {
+				color: colors.muted,
+				children: e.url
+			})
+		] });
+		case "http-request-finish": return /* @__PURE__ */ jsxs(Box, { children: [
+			/* @__PURE__ */ jsxs(Text, {
+				color: e.statusCode >= 200 && e.statusCode < 300 ? colors.success : colors.error,
+				children: [e.statusCode >= 200 && e.statusCode < 300 ? "✓" : "✗", " "]
+			}),
+			/* @__PURE__ */ jsx(Text, { children: "Status: " }),
+			/* @__PURE__ */ jsx(Text, {
+				color: e.statusCode >= 200 && e.statusCode < 300 ? colors.success : colors.error,
+				children: e.statusCode
+			})
+		] });
+		case "fetch-url-start": return /* @__PURE__ */ jsxs(Box, { children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: colors.info,
+				children: "📄 "
+			}),
+			/* @__PURE__ */ jsx(Text, { children: "Fetching: " }),
+			/* @__PURE__ */ jsx(Text, {
+				color: colors.muted,
+				children: e.url
+			})
+		] });
+		case "fetch-url-finish": return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsxs(Text, {
+			color: e.success ? colors.success : colors.error,
+			children: [e.success ? "✓" : "✗", " "]
+		}), /* @__PURE__ */ jsx(Text, { children: e.success ? "Content fetched" : "Failed to fetch" })] });
+		case "subagent-start": return /* @__PURE__ */ jsx(SubagentStart, {
+			name: e.name,
+			task: e.task
+		});
+		case "subagent-finish": return /* @__PURE__ */ jsx(SubagentFinish, { name: e.name });
+		case "done": return /* @__PURE__ */ jsx(DoneIndicator, {
+			todosCompleted: e.state.todos.filter((t) => t.status === "completed").length,
+			todosTotal: e.state.todos.length,
+			filesCount: Object.keys(e.state.files).length
+		});
+		case "error": return /* @__PURE__ */ jsx(ErrorDisplay, { error: e.error });
+		default: return null;
+	}
+}
+function FeaturesPanel({ features, options }) {
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: colors.muted,
+		paddingX: 2,
+		paddingY: 1,
+		marginY: 1,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				bold: true,
+				color: colors.info,
+				children: "⚙️ Feature Status"
+			}),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			/* @__PURE__ */ jsx(Box, { children: features.promptCaching ? /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx(Text, {
+					color: colors.success,
+					children: "✓ "
+				}),
+				/* @__PURE__ */ jsx(Text, { children: "Prompt Caching: " }),
+				/* @__PURE__ */ jsx(Text, {
+					color: colors.success,
+					children: "enabled"
+				})
+			] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "✗ "
+				}),
+				/* @__PURE__ */ jsx(Text, { children: "Prompt Caching: " }),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "disabled"
+				})
+			] }) }),
+			/* @__PURE__ */ jsx(Box, { children: features.eviction ? /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx(Text, {
+					color: colors.success,
+					children: "✓ "
+				}),
+				/* @__PURE__ */ jsx(Text, { children: "Tool Eviction: " }),
+				/* @__PURE__ */ jsxs(Text, {
+					color: colors.success,
+					children: [
+						"enabled (",
+						options.toolResultEvictionLimit,
+						" tokens)"
+					]
+				})
+			] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "✗ "
+				}),
+				/* @__PURE__ */ jsx(Text, { children: "Tool Eviction: " }),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "disabled"
+				})
+			] }) }),
+			/* @__PURE__ */ jsx(Box, { children: features.summarization ? /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx(Text, {
+					color: colors.success,
+					children: "✓ "
+				}),
+				/* @__PURE__ */ jsx(Text, { children: "Auto-Summarization: " }),
+				/* @__PURE__ */ jsxs(Text, {
+					color: colors.success,
+					children: [
+						"enabled (",
+						options.summarizationThreshold || DEFAULT_SUMMARIZATION_THRESHOLD,
+						" tokens, keep ",
+						options.summarizationKeepMessages || DEFAULT_KEEP_MESSAGES,
+						" msgs)"
+					]
+				})
+			] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "✗ "
+				}),
+				/* @__PURE__ */ jsx(Text, { children: "Auto-Summarization: " }),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "disabled"
+				})
+			] }) }),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			/* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [
+					"Enable with: --cache --eviction-limit ",
+					DEFAULT_EVICTION_LIMIT,
+					" --summarize"
+				]
+			})
+		]
+	});
+}
+function TokensPanel({ tokenCount, messageCount }) {
+	const formatNumber = (n) => n.toLocaleString();
+	const percentage = Math.round(tokenCount / CONTEXT_WINDOW * 100);
+	let usageColor = colors.success;
+	if (percentage > 80) usageColor = colors.error;
+	else if (percentage > 50) usageColor = colors.warning;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: colors.muted,
+		paddingX: 2,
+		paddingY: 1,
+		marginY: 1,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				bold: true,
+				color: colors.info,
+				children: "📊 Token Usage"
+			}),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, { children: "Messages: " }), /* @__PURE__ */ jsx(Text, {
+				color: colors.primary,
+				children: messageCount
+			})] }),
+			/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, { children: "Estimated Tokens: " }), /* @__PURE__ */ jsx(Text, {
+				color: usageColor,
+				children: formatNumber(tokenCount)
+			})] }),
+			/* @__PURE__ */ jsxs(Box, { children: [
+				/* @__PURE__ */ jsx(Text, { children: "Context Usage: " }),
+				/* @__PURE__ */ jsxs(Text, {
+					color: usageColor,
+					children: [percentage, "%"]
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: " (of ~200k)"
+				})
+			] }),
+			/* @__PURE__ */ jsx(Box, { height: 1 }),
+			percentage > 50 && /* @__PURE__ */ jsx(Text, {
+				color: colors.warning,
+				children: "⚠️ Consider enabling --summarize to manage context"
+			})
+		]
+	});
+}
+/**
+* Load environment variables from .env file in the working directory.
+* Bun automatically loads .env from cwd, but we want to also check the
+* specified working directory if different.
+*/
+async function loadEnvFile(workDir) {
+	const envPaths = [`${workDir}/.env`, `${workDir}/.env.local`];
+	const keysToCheck = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY"];
+	const result = {
+		loaded: false,
+		keysFound: []
+	};
+	for (const envPath of envPaths) try {
+		const file = Bun.file(envPath);
+		if (await file.exists()) {
+			const lines = (await file.text()).split("\n");
+			for (const line of lines) {
+				const trimmed = line.trim();
+				if (!trimmed || trimmed.startsWith("#")) continue;
+				const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+				if (match) {
+					const key = match[1];
+					const rawValue = match[2];
+					if (!key || rawValue === void 0) continue;
+					let value = rawValue.trim();
+					if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+					if (!process.env[key] && value) {
+						process.env[key] = value;
+						if (keysToCheck.includes(key)) result.keysFound.push(key);
+					}
+				}
+			}
+			result.loaded = true;
+			result.path = envPath;
+			break;
+		}
+	} catch {}
+	for (const key of keysToCheck) if (process.env[key] && !result.keysFound.includes(key)) {}
+	return result;
+}
+async function main() {
+	const options = parseArgs();
+	const workDir = options.workDir || process.cwd();
+	const envResult = await loadEnvFile(workDir);
+	if (envResult.loaded && envResult.keysFound.length > 0) console.log(`\x1b[32m✓\x1b[0m Loaded API keys from ${envResult.path}: ${envResult.keysFound.join(", ")}`);
+	if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) console.log(`\x1b[33m⚠\x1b[0m No API keys found. Set ANTHROPIC_API_KEY or OPENAI_API_KEY in environment or .env file.`);
+	render(/* @__PURE__ */ jsx(App, {
+		options,
+		backend: new LocalSandbox({ cwd: workDir })
+	}));
+}
+main();
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.mjs.map