storkit/frontend/src/components/Chat.tsx

import * as React from "react";
import Markdown from "react-markdown";
import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
import { oneDark } from "react-syntax-highlighter/dist/esm/styles/prism";
import type { PipelineState } from "../api/client";
import { api, ChatWebSocket } from "../api/client";
import { useChatHistory } from "../hooks/useChatHistory";
import type { Message, ProviderConfig, ToolCall } from "../types";
import { AgentPanel } from "./AgentPanel";
import { ChatHeader } from "./ChatHeader";
import { LozengeFlyProvider } from "./LozengeFlyContext";
import { StagePanel } from "./StagePanel";

const { useCallback, useEffect, useRef, useState } = React;

const NARROW_BREAKPOINT = 900;

function formatToolActivity(toolName: string): string {
	switch (toolName) {
		// Built-in provider tool names
		case "read_file":
		case "Read":
			return "Reading file...";
		case "write_file":
		case "Write":
		case "Edit":
			return "Writing file...";
		case "list_directory":
		case "Glob":
			return "Listing files...";
		case "search_files":
		case "Grep":
			return "Searching files...";
		case "exec_shell":
		case "Bash":
			return "Executing command...";
		// Claude Code additional tool names
		case "Task":
			return "Running task...";
		case "WebFetch":
			return "Fetching web content...";
		case "WebSearch":
			return "Searching the web...";
		case "NotebookEdit":
			return "Editing notebook...";
		case "TodoWrite":
			return "Updating tasks...";
		default:
			return `Using ${toolName}...`;
	}
}

interface ChatProps {
	projectPath: string;
	onCloseProject: () => void;
}

export function Chat({ projectPath, onCloseProject }: ChatProps) {
	const { messages, setMessages, clearMessages } = useChatHistory(projectPath);
	const [input, setInput] = useState("");
	const [loading, setLoading] = useState(false);
	const [model, setModel] = useState("llama3.1");
	const [enableTools, setEnableTools] = useState(true);
	const [availableModels, setAvailableModels] = useState<string[]>([]);
	const [claudeModels, setClaudeModels] = useState<string[]>([]);
	const [streamingContent, setStreamingContent] = useState("");
	const [showApiKeyDialog, setShowApiKeyDialog] = useState(false);
	const [apiKeyInput, setApiKeyInput] = useState("");
	const [hasAnthropicKey, setHasAnthropicKey] = useState(false);
	const [pipeline, setPipeline] = useState<PipelineState>({
		upcoming: [],
		current: [],
		qa: [],
		merge: [],
	});
	const [claudeSessionId, setClaudeSessionId] = useState<string | null>(null);
	const [activityStatus, setActivityStatus] = useState<string | null>(null);
	const [permissionRequest, setPermissionRequest] = useState<{
		requestId: string;
		toolName: string;
		toolInput: Record<string, unknown>;
	} | null>(null);
	const [isNarrowScreen, setIsNarrowScreen] = useState(
		window.innerWidth < NARROW_BREAKPOINT,
	);
	const [reconciliationActive, setReconciliationActive] = useState(false);
	const [reconciliationEvents, setReconciliationEvents] = useState<
		{ id: string; storyId: string; status: string; message: string }[]
	>([]);
	const reconciliationEventIdRef = useRef(0);
	const [agentConfigVersion, setAgentConfigVersion] = useState(0);
	const [needsOnboarding, setNeedsOnboarding] = useState(false);
	const onboardingTriggeredRef = useRef(false);
	const [queuedMessages, setQueuedMessages] = useState<
		{ id: string; text: string }[]
	>([]);
	// Ref so stale WebSocket callbacks can read the current queued messages
	const queuedMessagesRef = useRef<{ id: string; text: string }[]>([]);
	const queueIdCounterRef = useRef(0);
	// Trigger state: set to a message string to fire auto-send after loading ends
	const [pendingAutoSend, setPendingAutoSend] = useState<string | null>(null);

	const wsRef = useRef<ChatWebSocket | null>(null);
	const messagesEndRef = useRef<HTMLDivElement>(null);
	const inputRef = useRef<HTMLTextAreaElement>(null);
	const scrollContainerRef = useRef<HTMLDivElement>(null);
	const shouldAutoScrollRef = useRef(true);
	const lastScrollTopRef = useRef(0);
	const userScrolledUpRef = useRef(false);
	const pendingMessageRef = useRef<string>("");

	const estimateTokens = (text: string): number => Math.ceil(text.length / 4);

	const getContextWindowSize = (modelName: string): number => {
		if (modelName.startsWith("claude-")) return 200000;
		if (modelName.includes("llama3")) return 8192;
		if (modelName.includes("qwen2.5")) return 32768;
		if (modelName.includes("deepseek")) return 16384;
		return 8192;
	};

	const calculateContextUsage = (): {
		used: number;
		total: number;
		percentage: number;
	} => {
		let totalTokens = 0;

		totalTokens += 200;

		for (const msg of messages) {
			totalTokens += estimateTokens(msg.content);
			if (msg.tool_calls) {
				totalTokens += estimateTokens(JSON.stringify(msg.tool_calls));
			}
		}

		if (streamingContent) {
			totalTokens += estimateTokens(streamingContent);
		}

		const contextWindow = getContextWindowSize(model);
		const percentage = Math.round((totalTokens / contextWindow) * 100);

		return {
			used: totalTokens,
			total: contextWindow,
			percentage,
		};
	};

	const contextUsage = calculateContextUsage();

	useEffect(() => {
		api
			.getOllamaModels()
			.then(async (models) => {
				if (models.length > 0) {
					const sortedModels = models.sort((a, b) =>
						a.toLowerCase().localeCompare(b.toLowerCase()),
					);
					setAvailableModels(sortedModels);

					try {
						const savedModel = await api.getModelPreference();
						if (savedModel) {
							setModel(savedModel);
						} else if (sortedModels.length > 0) {
							setModel(sortedModels[0]);
						}
					} catch (e) {
						console.error(e);
					}
				}
			})
			.catch((err) => console.error(err));

		api
			.getAnthropicApiKeyExists()
			.then((exists) => {
				setHasAnthropicKey(exists);
				if (!exists) return;
				return api.getAnthropicModels().then((models) => {
					if (models.length > 0) {
						const sortedModels = models.sort((a, b) =>
							a.toLowerCase().localeCompare(b.toLowerCase()),
						);
						setClaudeModels(sortedModels);
					} else {
						setClaudeModels([]);
					}
				});
			})
			.catch((err) => {
				console.error(err);
				setHasAnthropicKey(false);
				setClaudeModels([]);
			});
	}, []);

	useEffect(() => {
		const ws = new ChatWebSocket();
		wsRef.current = ws;

		ws.connect({
			onToken: (content) => {
				setStreamingContent((prev: string) => prev + content);
			},
			onUpdate: (history) => {
				setMessages(history);
				setStreamingContent("");
				const last = history[history.length - 1];
				if (last?.role === "assistant" && !last.tool_calls) {
					setLoading(false);
					setActivityStatus(null);
					const nextQueued = queuedMessagesRef.current.shift();
					if (nextQueued !== undefined) {
						setQueuedMessages([...queuedMessagesRef.current]);
						setPendingAutoSend(nextQueued.text);
					}
				}
			},
			onSessionId: (sessionId) => {
				setClaudeSessionId(sessionId);
			},
			onError: (message) => {
				console.error("WebSocket error:", message);
				setLoading(false);
				setActivityStatus(null);
				const nextQueued = queuedMessagesRef.current.shift();
				if (nextQueued !== undefined) {
					setQueuedMessages([...queuedMessagesRef.current]);
					setPendingAutoSend(nextQueued.text);
				}
			},
			onPipelineState: (state) => {
				setPipeline(state);
			},
			onPermissionRequest: (requestId, toolName, toolInput) => {
				setPermissionRequest({ requestId, toolName, toolInput });
			},
			onActivity: (toolName) => {
				setActivityStatus(formatToolActivity(toolName));
			},
			onReconciliationProgress: (storyId, status, message) => {
				if (status === "done") {
					setReconciliationActive(false);
				} else {
					setReconciliationActive(true);
					setReconciliationEvents((prev) => {
						const id = String(reconciliationEventIdRef.current++);
						const next = [...prev, { id, storyId, status, message }];
						// Keep only the last 8 events to avoid the banner growing too tall.
						return next.slice(-8);
					});
				}
			},
			onAgentConfigChanged: () => {
				setAgentConfigVersion((v) => v + 1);
			},
			onOnboardingStatus: (onboarding: boolean) => {
				setNeedsOnboarding(onboarding);
			},
		});

		return () => {
			ws.close();
			wsRef.current = null;
		};
	}, []);

	const scrollToBottom = useCallback(() => {
		const element = scrollContainerRef.current;
		if (element) {
			element.scrollTop = element.scrollHeight;
			lastScrollTopRef.current = element.scrollHeight;
		}
	}, []);

	const handleScroll = () => {
		const element = scrollContainerRef.current;
		if (!element) return;

		const currentScrollTop = element.scrollTop;
		const isAtBottom =
			element.scrollHeight - element.scrollTop - element.clientHeight < 5;

		if (currentScrollTop < lastScrollTopRef.current) {
			userScrolledUpRef.current = true;
			shouldAutoScrollRef.current = false;
		}

		if (isAtBottom) {
			userScrolledUpRef.current = false;
			shouldAutoScrollRef.current = true;
		}

		lastScrollTopRef.current = currentScrollTop;
	};

	const autoScrollKey = messages.length + streamingContent.length;

	useEffect(() => {
		if (
			autoScrollKey >= 0 &&
			shouldAutoScrollRef.current &&
			!userScrolledUpRef.current
		) {
			scrollToBottom();
		}
	}, [autoScrollKey, scrollToBottom]);

	useEffect(() => {
		inputRef.current?.focus();
	}, []);

	// Auto-send queued message when loading ends
	useEffect(() => {
		if (pendingAutoSend) {
			const msg = pendingAutoSend;
			setPendingAutoSend(null);
			sendMessage(msg);
		}
	}, [pendingAutoSend]);

	useEffect(() => {
		const handleResize = () =>
			setIsNarrowScreen(window.innerWidth < NARROW_BREAKPOINT);
		window.addEventListener("resize", handleResize);
		return () => window.removeEventListener("resize", handleResize);
	}, []);

	const cancelGeneration = async () => {
		// Discard any queued messages — do not auto-send after cancel
		queuedMessagesRef.current = [];
		setQueuedMessages([]);
		try {
			wsRef.current?.cancel();
			await api.cancelChat();

			if (streamingContent) {
				setMessages((prev: Message[]) => [
					...prev,
					{ role: "assistant", content: streamingContent },
				]);
				setStreamingContent("");
			}

			setLoading(false);
			setActivityStatus(null);
		} catch (e) {
			console.error("Failed to cancel chat:", e);
		}
	};

	const sendMessage = async (messageOverride?: string) => {
		const messageToSend = messageOverride ?? input;
		if (!messageToSend.trim()) return;

		// Agent is busy — queue the message instead of dropping it
		if (loading) {
			const newItem = {
				id: String(queueIdCounterRef.current++),
				text: messageToSend,
			};
			queuedMessagesRef.current = [...queuedMessagesRef.current, newItem];
			setQueuedMessages([...queuedMessagesRef.current]);
			if (!messageOverride || messageOverride === input) {
				setInput("");
			}
			return;
		}

		const isClaudeCode = model === "claude-code-pty";
		if (!isClaudeCode && model.startsWith("claude-")) {
			const hasKey = await api.getAnthropicApiKeyExists();
			if (!hasKey) {
				pendingMessageRef.current = messageToSend;
				setShowApiKeyDialog(true);
				return;
			}
		}

		const userMsg: Message = { role: "user", content: messageToSend };
		const newHistory = [...messages, userMsg];

		setMessages(newHistory);
		if (!messageOverride || messageOverride === input) {
			setInput("");
		}
		setLoading(true);
		setStreamingContent("");
		setActivityStatus(null);

		try {
			const provider = isClaudeCode
				? "claude-code"
				: model.startsWith("claude-")
					? "anthropic"
					: "ollama";
			const config: ProviderConfig = {
				provider,
				model,
				base_url: "http://localhost:11434",
				enable_tools: enableTools,
				...(isClaudeCode && claudeSessionId
					? { session_id: claudeSessionId }
					: {}),
			};

			wsRef.current?.sendChat(newHistory, config);
		} catch (e) {
			console.error("Chat error:", e);
			const errorMessage = String(e);
			if (!errorMessage.includes("Chat cancelled by user")) {
				setMessages((prev: Message[]) => [
					...prev,
					{ role: "assistant", content: `**Error:** ${e}` },
				]);
			}
			setLoading(false);
		}
	};

	const handleSaveApiKey = async () => {
		if (!apiKeyInput.trim()) return;

		try {
			await api.setAnthropicApiKey(apiKeyInput);
			setShowApiKeyDialog(false);
			setApiKeyInput("");

			const pendingMessage = pendingMessageRef.current;
			pendingMessageRef.current = "";

			if (pendingMessage.trim()) {
				sendMessage(pendingMessage);
			}
		} catch (e) {
			console.error("Failed to save API key:", e);
			alert(`Failed to save API key: ${e}`);
		}
	};

	const handlePermissionResponse = (approved: boolean) => {
		if (!permissionRequest) return;
		wsRef.current?.sendPermissionResponse(
			permissionRequest.requestId,
			approved,
		);
		setPermissionRequest(null);
	};

	const clearSession = async () => {
		const confirmed = window.confirm(
			"Are you sure? This will clear all messages and reset the conversation context.",
		);

		if (confirmed) {
			try {
				await api.cancelChat();
				wsRef.current?.cancel();
			} catch (e) {
				console.error("Failed to cancel chat:", e);
			}

			clearMessages();
			setStreamingContent("");
			setLoading(false);
			setActivityStatus(null);
			setClaudeSessionId(null);
		}
	};

	return (
		<div
			className="chat-container"
			style={{
				display: "flex",
				flexDirection: "column",
				height: "100%",
				backgroundColor: "#171717",
				color: "#ececec",
			}}
		>
			<ChatHeader
				projectPath={projectPath}
				onCloseProject={onCloseProject}
				contextUsage={contextUsage}
				onClearSession={clearSession}
				model={model}
				availableModels={availableModels}
				claudeModels={claudeModels}
				hasAnthropicKey={hasAnthropicKey}
				onModelChange={(newModel) => {
					setModel(newModel);
					api.setModelPreference(newModel).catch(console.error);
				}}
				enableTools={enableTools}
				onToggleTools={setEnableTools}
			/>

			{/* Two-column content area */}
			<div
				data-testid="chat-content-area"
				style={{
					display: "flex",
					flex: 1,
					minHeight: 0,
					flexDirection: isNarrowScreen ? "column" : "row",
				}}
			>
				{/* Left column: chat messages + input pinned at bottom */}
				<div
					data-testid="chat-left-column"
					style={{
						display: "flex",
						flexDirection: "column",
						flex: "0 0 60%",
						minHeight: 0,
						overflow: "hidden",
					}}
				>
					{/* Scrollable messages area */}
					<div
						ref={scrollContainerRef}
						onScroll={handleScroll}
						style={{
							flex: 1,
							overflowY: "auto",
							padding: "20px 0",
							display: "flex",
							flexDirection: "column",
							gap: "24px",
						}}
					>
						<div
							style={{
								maxWidth: "768px",
								margin: "0 auto",
								width: "100%",
								padding: "0 24px",
								display: "flex",
								flexDirection: "column",
								gap: "24px",
							}}
						>
							{needsOnboarding && messages.length === 0 && !loading && (
								<div
									data-testid="onboarding-welcome"
									style={{
										padding: "24px",
										borderRadius: "12px",
										background: "#1c2a1c",
										border: "1px solid #2d4a2d",
										marginBottom: "8px",
									}}
								>
									<h3
										style={{
											margin: "0 0 8px 0",
											color: "#a0d4a0",
											fontSize: "1.1rem",
										}}
									>
										Welcome to Story Kit
									</h3>
									<p
										style={{
											margin: "0 0 16px 0",
											color: "#ccc",
											lineHeight: 1.5,
										}}
									>
										This project needs to be set up before you can start writing
										stories. The agent will guide you through configuring your
										project goals and tech stack.
									</p>
									<button
										type="button"
										data-testid="onboarding-start-button"
										onClick={() => {
											if (onboardingTriggeredRef.current) return;
											onboardingTriggeredRef.current = true;
											setNeedsOnboarding(false);
											sendMessage(
												"I just created a new project. Help me set it up.",
											);
										}}
										style={{
											padding: "10px 20px",
											borderRadius: "8px",
											border: "none",
											backgroundColor: "#a0d4a0",
											color: "#1a1a1a",
											cursor: "pointer",
											fontSize: "0.95rem",
											fontWeight: 600,
										}}
									>
										Start Project Setup
									</button>
								</div>
							)}
							{messages.map((msg: Message, idx: number) => (
								<div
									key={`msg-${idx}-${msg.role}-${msg.content.substring(0, 20)}`}
									style={{
										display: "flex",
										flexDirection: "column",
										alignItems: msg.role === "user" ? "flex-end" : "flex-start",
									}}
								>
									<div
										style={{
											maxWidth: "100%",
											padding: msg.role === "user" ? "10px 16px" : "0",
											borderRadius: msg.role === "user" ? "20px" : "0",
											background:
												msg.role === "user"
													? "#2f2f2f"
													: msg.role === "tool"
														? "#222"
														: "transparent",
											color: "#ececec",
											border: msg.role === "tool" ? "1px solid #333" : "none",
											fontFamily: msg.role === "tool" ? "monospace" : "inherit",
											fontSize: msg.role === "tool" ? "0.85em" : "1em",
											fontWeight: "500",
											whiteSpace: msg.role === "tool" ? "pre-wrap" : "normal",
											lineHeight: "1.6",
										}}
									>
										{msg.role === "user" ? (
											msg.content
										) : msg.role === "tool" ? (
											<details style={{ cursor: "pointer" }}>
												<summary
													style={{
														color: "#aaa",
														fontSize: "0.9em",
														marginBottom: "8px",
														listStyle: "none",
														display: "flex",
														alignItems: "center",
														gap: "6px",
													}}
												>
													<span style={{ fontSize: "0.8em" }}>▶</span>
													<span>
														Tool Output
														{msg.tool_call_id && ` (${msg.tool_call_id})`}
													</span>
												</summary>
												<pre
													style={{
														maxHeight: "300px",
														overflow: "auto",
														margin: 0,
														padding: "8px",
														background: "#1a1a1a",
														borderRadius: "4px",
														fontSize: "0.85em",
														whiteSpace: "pre-wrap",
														wordBreak: "break-word",
													}}
												>
													{msg.content}
												</pre>
											</details>
										) : (
											<div className="markdown-body">
												<Markdown
													components={{
														// eslint-disable-next-line @typescript-eslint/no-explicit-any
														// biome-ignore lint/suspicious/noExplicitAny: react-markdown requires any for component props
														code: ({ className, children, ...props }: any) => {
															const match = /language-(\w+)/.exec(
																className || "",
															);
															const isInline = !className;
															return !isInline && match ? (
																<SyntaxHighlighter
																	// biome-ignore lint/suspicious/noExplicitAny: oneDark style types are incompatible
																	style={oneDark as any}
																	language={match[1]}
																	PreTag="div"
																>
																	{String(children).replace(/\n$/, "")}
																</SyntaxHighlighter>
															) : (
																<code className={className} {...props}>
																	{children}
																</code>
															);
														},
													}}
												>
													{msg.content}
												</Markdown>
											</div>
										)}

										{msg.tool_calls && (
											<div
												style={{
													marginTop: "12px",
													fontSize: "0.85em",
													color: "#aaa",
													display: "flex",
													flexDirection: "column",
													gap: "8px",
												}}
											>
												{msg.tool_calls.map((tc: ToolCall, i: number) => {
													let argsSummary = "";
													try {
														const args = JSON.parse(tc.function.arguments);
														const firstKey = Object.keys(args)[0];
														if (firstKey && args[firstKey]) {
															argsSummary = String(args[firstKey]);
															if (argsSummary.length > 50) {
																argsSummary = `${argsSummary.substring(0, 47)}...`;
															}
														}
													} catch (_e) {
														// ignore
													}

													return (
														<div
															key={`tool-${i}-${tc.function.name}`}
															style={{
																display: "flex",
																alignItems: "center",
																gap: "8px",
																fontFamily: "monospace",
															}}
														>
															<span style={{ color: "#888" }}>▶</span>
															<span
																style={{
																	background: "#333",
																	padding: "2px 6px",
																	borderRadius: "4px",
																}}
															>
																{tc.function.name}
																{argsSummary && `(${argsSummary})`}
															</span>
														</div>
													);
												})}
											</div>
										)}
									</div>
								</div>
							))}
							{loading && streamingContent && (
								<div
									style={{
										display: "flex",
										flexDirection: "column",
										alignItems: "flex-start",
									}}
								>
									<div
										style={{
											maxWidth: "100%",
											padding: "0",
											borderRadius: "0",
											background: "transparent",
											color: "#ececec",
											border: "none",
											fontFamily: "inherit",
											fontSize: "1em",
											fontWeight: "500",
											whiteSpace: "normal",
											lineHeight: "1.6",
										}}
									>
										<div className="markdown-body">
											<Markdown
												components={{
													// eslint-disable-next-line @typescript-eslint/no-explicit-any
													// biome-ignore lint/suspicious/noExplicitAny: react-markdown requires any for component props
													code: ({ className, children, ...props }: any) => {
														const match = /language-(\w+)/.exec(
															className || "",
														);
														const isInline = !className;
														return !isInline && match ? (
															<SyntaxHighlighter
																// biome-ignore lint/suspicious/noExplicitAny: oneDark style types are incompatible
																style={oneDark as any}
																language={match[1]}
																PreTag="div"
															>
																{String(children).replace(/\n$/, "")}
															</SyntaxHighlighter>
														) : (
															<code className={className} {...props}>
																{children}
															</code>
														);
													},
												}}
											>
												{streamingContent}
											</Markdown>
										</div>
									</div>
								</div>
							)}
							{loading && (activityStatus != null || !streamingContent) && (
								<div
									data-testid="activity-indicator"
									style={{
										alignSelf: "flex-start",
										color: "#888",
										fontSize: "0.9em",
										marginTop: "10px",
									}}
								>
									<span className="pulse">
										{activityStatus ?? "Thinking..."}
									</span>
								</div>
							)}
							<div ref={messagesEndRef} />
						</div>
					</div>

					{/* Startup reconciliation progress banner */}
					{reconciliationActive && (
						<div
							data-testid="reconciliation-banner"
							style={{
								padding: "6px 24px",
								background: "#1c2a1c",
								borderTop: "1px solid #2d4a2d",
								fontSize: "0.8em",
								color: "#7ec87e",
								maxHeight: "100px",
								overflowY: "auto",
								flexShrink: 0,
							}}
						>
							<div
								style={{
									fontWeight: 600,
									marginBottom: "2px",
									color: "#a0d4a0",
								}}
							>
								Reconciling startup state...
							</div>
							{reconciliationEvents.map((evt) => (
								<div
									key={evt.id}
									style={{
										color:
											evt.status === "failed"
												? "#d07070"
												: evt.status === "advanced"
													? "#80c880"
													: "#666",
										whiteSpace: "nowrap",
										overflow: "hidden",
										textOverflow: "ellipsis",
									}}
								>
									{evt.storyId ? `[${evt.storyId}] ` : ""}
									{evt.message}
								</div>
							))}
						</div>
					)}

					{/* Chat input pinned at bottom of left column */}
					<div
						style={{
							padding: "24px",
							background: "#171717",
							display: "flex",
							justifyContent: "center",
						}}
					>
						<div
							style={{
								maxWidth: "768px",
								width: "100%",
								display: "flex",
								flexDirection: "column",
								gap: "8px",
							}}
						>
							{/* Queued message indicators */}
							{queuedMessages.map(({ id, text }) => (
								<div
									key={id}
									data-testid="queued-message-indicator"
									style={{
										display: "flex",
										alignItems: "center",
										gap: "8px",
										padding: "8px 12px",
										background: "#1e1e1e",
										border: "1px solid #3a3a3a",
										borderRadius: "12px",
										fontSize: "0.875rem",
									}}
								>
									<span
										style={{
											color: "#666",
											flexShrink: 0,
											fontSize: "0.7rem",
											fontWeight: 700,
											letterSpacing: "0.05em",
											textTransform: "uppercase",
										}}
									>
										Queued
									</span>
									<span
										style={{
											color: "#888",
											flex: 1,
											overflow: "hidden",
											textOverflow: "ellipsis",
											whiteSpace: "nowrap",
										}}
									>
										{text}
									</span>
									<button
										type="button"
										title="Edit queued message"
										onClick={() => {
											setInput(text);
											queuedMessagesRef.current =
												queuedMessagesRef.current.filter(
													(item) => item.id !== id,
												);
											setQueuedMessages([...queuedMessagesRef.current]);
											inputRef.current?.focus();
										}}
										style={{
											background: "none",
											border: "none",
											color: "#666",
											cursor: "pointer",
											padding: "2px 6px",
											fontSize: "0.8rem",
											flexShrink: 0,
											borderRadius: "4px",
										}}
									>
										Edit
									</button>
									<button
										type="button"
										title="Cancel queued message"
										onClick={() => {
											queuedMessagesRef.current =
												queuedMessagesRef.current.filter(
													(item) => item.id !== id,
												);
											setQueuedMessages([...queuedMessagesRef.current]);
										}}
										style={{
											background: "none",
											border: "none",
											color: "#666",
											cursor: "pointer",
											padding: "2px 4px",
											fontSize: "0.875rem",
											flexShrink: 0,
											borderRadius: "4px",
										}}
									>
										✕
									</button>
								</div>
							))}
							{/* Input row */}
							<div
								style={{
									display: "flex",
									gap: "8px",
									alignItems: "center",
								}}
							>
								<textarea
									ref={inputRef}
									value={input}
									onChange={(e) => setInput(e.target.value)}
									onKeyDown={(e) => {
										if (e.key === "Enter" && !e.shiftKey) {
											e.preventDefault();
											sendMessage();
										}
									}}
									placeholder="Send a message..."
									rows={1}
									style={{
										flex: 1,
										padding: "14px 20px",
										borderRadius: "24px",
										border: "1px solid #333",
										outline: "none",
										fontSize: "1rem",
										fontWeight: "500",
										background: "#2f2f2f",
										color: "#ececec",
										boxShadow: "0 2px 6px rgba(0,0,0,0.02)",
										resize: "none",
										overflowY: "auto",
										fontFamily: "inherit",
									}}
								/>
								<button
									type="button"
									onClick={
										loading && !input.trim()
											? cancelGeneration
											: () => sendMessage()
									}
									disabled={!loading && !input.trim()}
									style={{
										background: "#ececec",
										color: "black",
										border: "none",
										borderRadius: "50%",
										width: "32px",
										height: "32px",
										display: "flex",
										alignItems: "center",
										justifyContent: "center",
										cursor: "pointer",
										opacity: !loading && !input.trim() ? 0.5 : 1,
										flexShrink: 0,
									}}
								>
									{loading && !input.trim() ? "■" : "↑"}
								</button>
							</div>
						</div>
					</div>
				</div>

				{/* Right column: panels independently scrollable */}
				<div
					data-testid="chat-right-column"
					style={{
						flex: "0 0 40%",
						overflowY: "auto",
						borderLeft: isNarrowScreen ? "none" : "1px solid #333",
						borderTop: isNarrowScreen ? "1px solid #333" : "none",
						padding: "12px",
						display: "flex",
						flexDirection: "column",
						gap: "12px",
					}}
				>
					<LozengeFlyProvider pipeline={pipeline}>
						<AgentPanel configVersion={agentConfigVersion} />

						<StagePanel title="To Merge" items={pipeline.merge} />
						<StagePanel title="QA" items={pipeline.qa} />
						<StagePanel title="Current" items={pipeline.current} />
						<StagePanel title="Upcoming" items={pipeline.upcoming} />
					</LozengeFlyProvider>
				</div>
			</div>

			{showApiKeyDialog && (
				<div
					style={{
						position: "fixed",
						top: 0,
						left: 0,
						right: 0,
						bottom: 0,
						backgroundColor: "rgba(0, 0, 0, 0.7)",
						display: "flex",
						alignItems: "center",
						justifyContent: "center",
						zIndex: 1000,
					}}
				>
					<div
						style={{
							backgroundColor: "#2f2f2f",
							padding: "32px",
							borderRadius: "12px",
							maxWidth: "500px",
							width: "90%",
							border: "1px solid #444",
						}}
					>
						<h2 style={{ marginTop: 0, color: "#ececec" }}>
							Enter Anthropic API Key
						</h2>
						<p
							style={{ color: "#aaa", fontSize: "0.9em", marginBottom: "20px" }}
						>
							To use Claude models, please enter your Anthropic API key. Your
							key will be stored server-side and reused across sessions.
						</p>
						<input
							type="password"
							value={apiKeyInput}
							onChange={(e) => setApiKeyInput(e.target.value)}
							onKeyDown={(e) => e.key === "Enter" && handleSaveApiKey()}
							placeholder="sk-ant-..."
							style={{
								width: "100%",
								padding: "12px",
								borderRadius: "8px",
								border: "1px solid #555",
								backgroundColor: "#1a1a1a",
								color: "#ececec",
								fontSize: "1em",
								marginBottom: "20px",
								outline: "none",
							}}
						/>
						<div
							style={{
								display: "flex",
								gap: "12px",
								justifyContent: "flex-end",
							}}
						>
							<button
								type="button"
								onClick={() => {
									setShowApiKeyDialog(false);
									setApiKeyInput("");
									pendingMessageRef.current = "";
								}}
								style={{
									padding: "10px 20px",
									borderRadius: "8px",
									border: "1px solid #555",
									backgroundColor: "transparent",
									color: "#aaa",
									cursor: "pointer",
									fontSize: "0.9em",
								}}
							>
								Cancel
							</button>
							<button
								type="button"
								onClick={handleSaveApiKey}
								disabled={!apiKeyInput.trim()}
								style={{
									padding: "10px 20px",
									borderRadius: "8px",
									border: "none",
									backgroundColor: apiKeyInput.trim() ? "#ececec" : "#555",
									color: apiKeyInput.trim() ? "#000" : "#888",
									cursor: apiKeyInput.trim() ? "pointer" : "not-allowed",
									fontSize: "0.9em",
								}}
							>
								Save Key
							</button>
						</div>
					</div>
				</div>
			)}
			{permissionRequest && (
				<div
					style={{
						position: "fixed",
						top: 0,
						left: 0,
						right: 0,
						bottom: 0,
						backgroundColor: "rgba(0, 0, 0, 0.7)",
						display: "flex",
						alignItems: "center",
						justifyContent: "center",
						zIndex: 1000,
					}}
				>
					<div
						style={{
							backgroundColor: "#2f2f2f",
							padding: "32px",
							borderRadius: "12px",
							maxWidth: "520px",
							width: "90%",
							border: "1px solid #444",
						}}
					>
						<h2 style={{ marginTop: 0, color: "#ececec" }}>
							Permission Request
						</h2>
						<p
							style={{
								color: "#aaa",
								fontSize: "0.9em",
								marginBottom: "12px",
							}}
						>
							The agent wants to use the{" "}
							<strong style={{ color: "#ececec" }}>
								{permissionRequest.toolName}
							</strong>{" "}
							tool. Do you approve?
						</p>
						{Object.keys(permissionRequest.toolInput).length > 0 && (
							<pre
								style={{
									background: "#1a1a1a",
									border: "1px solid #333",
									borderRadius: "6px",
									padding: "12px",
									fontSize: "0.8em",
									color: "#ccc",
									overflowX: "auto",
									maxHeight: "200px",
									marginBottom: "20px",
									whiteSpace: "pre-wrap",
									wordBreak: "break-word",
								}}
							>
								{JSON.stringify(permissionRequest.toolInput, null, 2)}
							</pre>
						)}
						<div
							style={{
								display: "flex",
								gap: "12px",
								justifyContent: "flex-end",
							}}
						>
							<button
								type="button"
								onClick={() => handlePermissionResponse(false)}
								style={{
									padding: "10px 20px",
									borderRadius: "8px",
									border: "1px solid #555",
									backgroundColor: "transparent",
									color: "#aaa",
									cursor: "pointer",
									fontSize: "0.9em",
								}}
							>
								Deny
							</button>
							<button
								type="button"
								onClick={() => handlePermissionResponse(true)}
								style={{
									padding: "10px 20px",
									borderRadius: "8px",
									border: "none",
									backgroundColor: "#ececec",
									color: "#000",
									cursor: "pointer",
									fontSize: "0.9em",
								}}
							>
								Approve
							</button>
						</div>
					</div>
				</div>
			)}
		</div>
	);
}