scalix 0.0.1 → 1.1.0

package/dist/cli.js

@@ -0,0 +1,2454 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useRef, useMemo, memo } from 'react';
+import { render, Box, Text, useInput, useApp, useStdout } from 'ink';
+import Spinner from 'ink-spinner';
+import TextInput from 'ink-text-input';
+import Gradient from 'ink-gradient';
+import BigText from 'ink-big-text';
+import { execSync, execFileSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import SelectInput from 'ink-select-input';
+import { createAgent, messageContentToString } from './agent.js';
+import { defaultTools } from './tools.js';
+import { extraTools } from './tools-extra.js';
+import { webTools } from './tools-web.js';
+import { advancedTools } from './tools-advanced.js';
+import { visionTools } from './tools-vision.js';
+import { voiceTools } from './tools-voice.js';
+import { browserTools, closeBrowser } from './tools-browser.js';
+import { loadMcpServices } from './mcp.js';
+import { renderMarkdown } from './markdown.js';
+import { costTracker } from './cost-tracker.js';
+import { saveSession, listSessions, loadSession, generateSessionId } from './sessions.js';
+import { logger } from './logger.js';
+import { VERSION, PRODUCT_NAME, DEFAULT_MODELS, DEFAULT_BASE_URL, DEFAULT_INSTRUCTIONS, ENV_API_KEY, ENV_MODEL, TOOL_DEFAULTS, HEADLESS_DEFAULTS, fetchModelSpecs } from './constants.js';
+import { checkForUpdate, getUpdateBanner, performUpdate } from './update-checker.js';
+import { loadConfig, saveConfig, isConfigured, DEFAULT_LIMITS, THINKING_MODES } from './settings.js';
+import { getModeDescription, PERMISSION_MODES, setSandboxRoot } from './sandbox.js';
+import { buildProjectIndex, indexToContext } from './project-index.js';
+import { collectGitInfo, gitInfoToContext } from './git-context.js';
+import { loadMemory, autoDetectConventions, saveMemory, memoryToContext, addNote, detectCorrection } from './project-memory.js';
+import { discoverPlugins, getPluginTools, pluginsSummary } from './plugins.js';
+import { createRouterConfig, getRouterStatus } from './model-router.js';
+import { loadCustomCommands, expandCommand, commandsSummary } from './commands.js';
+import { hooksSummary } from './hooks.js';
+import { spawnSubAgent, pickCheapestModel } from './sub-agent.js';
+import { createCheckpoint, undoLastCheckpoint, listCheckpoints } from './git-undo.js';
+import { loadScopedRules, rulesToContext } from './scoped-rules.js';
+import { AgentRegistry } from './agent-registry.js';
+logger.setLevel('silent');
+setSandboxRoot(process.cwd());
+// Suppress noisy React 19 development-mode reconciler warnings that leak to stderr
+const _origConsoleError = console.error;
+console.error = (...args) => {
+    if (typeof args[0] === 'string' && args[0].startsWith('Warning:') && args[0].includes('same key'))
+        return;
+    _origConsoleError(...args);
+};
+// Disable bracketed paste mode — terminals (via zsh) may leave it enabled,
+// which wraps pasted text in escape sequences that corrupt TextInput values.
+process.stdout.write('\x1b[?2004l');
+const mcpTools = loadMcpServices();
+let pluginTools = [];
+const allTools = [...defaultTools, ...extraTools, ...webTools, ...advancedTools, ...visionTools, ...voiceTools, ...browserTools, ...mcpTools];
+// ─── Confirmation bridge (event-driven) ───
+import { EventEmitter } from 'node:events';
+const confirmEmitter = new EventEmitter();
+let pendingConfirm = null;
+const confirmToolCall = async (toolName, args) => new Promise((resolve) => {
+    pendingConfirm = { resolve, toolName, args };
+    confirmEmitter.emit('pending');
+});
+// ─── Agent (deferred until config is ready) ───
+let baseInstructions = DEFAULT_INSTRUCTIONS;
+let agent = null;
+let sessionId = generateSessionId();
+let projectIndex = null;
+let loadedPlugins = [];
+let projectMemory = null;
+let customCommands = [];
+async function buildEnhancedInstructions() {
+    let instructions = baseInstructions;
+    const cwd = process.cwd();
+    try {
+        const gitInfo = await collectGitInfo(cwd);
+        if (gitInfo.isRepo)
+            instructions += '\n\n' + gitInfoToContext(gitInfo);
+    }
+    catch { }
+    try {
+        const memory = await loadMemory(cwd);
+        const autoConventions = await autoDetectConventions(cwd);
+        for (const c of autoConventions) {
+            if (!memory.conventions.some((mc) => mc.key === c.key)) {
+                memory.conventions.push(c);
+            }
+        }
+        projectMemory = memory;
+        if (memory.conventions.length > 0 || memory.patterns.length > 0 || memory.notes.length > 0) {
+            instructions += '\n\n' + memoryToContext(memory);
+            await saveMemory(cwd, memory);
+        }
+    }
+    catch { }
+    try {
+        projectIndex = await buildProjectIndex(cwd);
+        instructions += '\n\n' + indexToContext(projectIndex);
+    }
+    catch { }
+    try {
+        const rules = await loadScopedRules(cwd);
+        const rulesCtx = rulesToContext(rules);
+        if (rulesCtx)
+            instructions += '\n\n' + rulesCtx;
+    }
+    catch { }
+    return instructions;
+}
+function initAgent(config) {
+    const envModels = process.env[ENV_MODEL]
+        ? process.env[ENV_MODEL].split(',').map((m) => m.trim()).filter(Boolean)
+        : null;
+    const models = envModels || config.models;
+    if (models.length === 0) {
+        throw new Error('No models configured. Please add at least one model in setup.');
+    }
+    const limits = config.limits || DEFAULT_LIMITS;
+    agent = createAgent({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        model: models.length === 1 ? models[0] : models,
+        instructions: baseInstructions,
+        tools: allTools,
+        confirmToolCall,
+        permissionMode: config.permissionMode || 'default',
+        maxSteps: limits.maxSteps,
+        maxMessages: limits.maxMessages,
+        contextManager: {
+            maxContextTokens: limits.maxContextTokens,
+            compressionThreshold: limits.compressionThreshold,
+            maxToolResultTokens: limits.maxToolResultTokens,
+        },
+        instructionLoader: buildEnhancedInstructions,
+        autoVerify: true,
+        thinkingMode: config.thinkingMode || 'off',
+    });
+    const currentAgent = agent;
+    loadedPlugins = [];
+    discoverPlugins(process.cwd()).then((plugins) => {
+        loadedPlugins = plugins;
+        const pTools = getPluginTools(plugins);
+        pluginTools = pTools;
+        for (const pt of pTools)
+            currentAgent.addTool(pt);
+    }).catch((err) => {
+        logger.warn('Plugin discovery failed', { error: err.message });
+    });
+    buildEnhancedInstructions().then((enhanced) => {
+        currentAgent.setInstructions(enhanced);
+    }).catch((err) => {
+        logger.warn('Failed to build enhanced instructions', { error: err.message });
+    });
+    loadCustomCommands(process.cwd()).then((cmds) => {
+        customCommands = cmds;
+    }).catch((err) => { logger.warn('Failed to load custom commands', { error: err.message }); });
+    return agent;
+}
+// ─── Helpers ───
+function shortModel(m) {
+    return m.split('/').pop().replace(/:free$/, '').replace(/-instruct$/, '');
+}
+function useTermSize() {
+    const { stdout } = useStdout();
+    const [size, setSize] = useState({ cols: stdout?.columns ?? 80, rows: stdout?.rows ?? 24 });
+    useEffect(() => {
+        const fn = () => {
+            const newCols = stdout?.columns ?? 80;
+            const newRows = stdout?.rows ?? 24;
+            setSize((prev) => {
+                if (prev.cols === newCols && prev.rows === newRows)
+                    return prev;
+                return { cols: newCols, rows: newRows };
+            });
+        };
+        stdout?.on('resize', fn);
+        return () => { stdout?.off('resize', fn); };
+    }, [stdout]);
+    return size;
+}
+function elapsed(start) {
+    const s = Math.floor((Date.now() - start) / 1000);
+    return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m${s % 60}s`;
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    const cut = s.slice(0, max - 1);
+    const lastBreak = Math.max(cut.lastIndexOf(','), cut.lastIndexOf(' '), cut.lastIndexOf('\n'));
+    return (lastBreak > max * 0.5 ? cut.slice(0, lastBreak) : cut) + '\u2026';
+}
+function formatTokens(n) {
+    if (n >= 1000000)
+        return `${(n / 1000000).toFixed(1)}M`;
+    if (n >= 1000)
+        return `${(n / 1000).toFixed(1)}K`;
+    return String(n);
+}
+// ─── Components ───
+const Banner = memo(function Banner() {
+    return (_jsx(Box, { flexDirection: "column", alignItems: "center", marginBottom: 0, children: _jsx(Gradient, { name: "teen", children: _jsx(BigText, { text: PRODUCT_NAME.toLowerCase(), font: "tiny" }) }) }));
+});
+// Strip bracketed paste markers and control chars that leak through ink's parser
+function sanitizeInput(v) {
+    return v.replace(/\[20[01]~/g, '').replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, '');
+}
+function LongTextInput({ value, onChange, onSubmit, placeholder, maxVisible = 80 }) {
+    const valueRef = useRef(value);
+    useEffect(() => { valueRef.current = value; }, [value]);
+    useInput((input, key) => {
+        if (key.upArrow || key.downArrow || key.tab || (key.ctrl && input === 'c'))
+            return;
+        if (key.return) {
+            onSubmit(valueRef.current);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (valueRef.current.length > 0) {
+                const next = valueRef.current.slice(0, -1);
+                valueRef.current = next;
+                onChange(next);
+            }
+            return;
+        }
+        if (key.leftArrow || key.rightArrow)
+            return;
+        const cleaned = sanitizeInput(input);
+        if (cleaned.length > 0) {
+            const next = valueRef.current + cleaned;
+            valueRef.current = next;
+            onChange(next);
+        }
+    });
+    if (value.length === 0) {
+        return _jsx(Text, { dimColor: true, children: placeholder || '' });
+    }
+    const display = value.length <= maxVisible
+        ? value
+        : '\u2026' + value.slice(-(maxVisible - 1));
+    return _jsxs(Text, { children: [display, _jsx(Text, { color: "magentaBright", children: '\u258E' })] });
+}
+function formatContextSize(tokens) {
+    if (tokens >= 1_000_000)
+        return `${(tokens / 1_000_000).toFixed(tokens % 1_000_000 === 0 ? 0 : 1)}M`;
+    if (tokens >= 1_000)
+        return `${(tokens / 1_000).toFixed(tokens % 1_000 === 0 ? 0 : 1)}K`;
+    return String(tokens);
+}
+function SetupScreen({ onComplete, existingConfig }) {
+    const STEPS = ['api-key', 'base-url', 'models', 'context-window'];
+    const [step, setStep] = useState('api-key');
+    const [apiKey, setApiKey] = useState(existingConfig?.apiKey || process.env[ENV_API_KEY] || '');
+    const [baseUrl, setBaseUrl] = useState(existingConfig?.baseUrl || DEFAULT_BASE_URL);
+    const [models, setModels] = useState(existingConfig?.models?.length ? [...existingConfig.models] : [...DEFAULT_MODELS]);
+    const [modelsMode, setModelsMode] = useState('custom');
+    const [modelInput, setModelInput] = useState('');
+    const [contextInput, setContextInput] = useState(String(existingConfig?.limits?.maxContextTokens ?? DEFAULT_LIMITS.maxContextTokens));
+    const [apiKeyError, setApiKeyError] = useState(false);
+    const [fetchedModels, setFetchedModels] = useState([]);
+    const [fetchingModels, setFetchingModels] = useState(false);
+    const { exit } = useApp();
+    const totalSteps = STEPS.length;
+    const stepNumber = STEPS.indexOf(step) + 1;
+    const goBack = useCallback(() => {
+        const idx = STEPS.indexOf(step);
+        if (idx > 0) {
+            if (step === 'models')
+                setModelsMode('custom');
+            setStep(STEPS[idx - 1]);
+        }
+    }, [step]);
+    useInput((_ch, key) => {
+        if (key.escape)
+            exit();
+        if (key.backspace || key.delete) {
+            if (step === 'api-key' && apiKey === '')
+                return;
+            if (step === 'base-url' && baseUrl === '') {
+                goBack();
+                return;
+            }
+            if (step === 'context-window' && contextInput === '') {
+                goBack();
+                return;
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(Banner, {}), _jsxs(Box, { flexDirection: "column", paddingX: 3, paddingY: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: "#20a0a0", bold: true, children: ['\u2501'.repeat(4), " First-time Setup ", '\u2501'.repeat(4)] }) }), _jsxs(Box, { marginBottom: 1, gap: 1, children: [_jsx(Text, { color: "#20a0a0", children: STEPS.map((_, i) => i < stepNumber ? '\u25CF' : '\u25CB').join('') }), _jsxs(Text, { dimColor: true, children: ["Step ", stepNumber, " of ", totalSteps] })] }), step === 'api-key' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "white", children: "API Key" }), _jsx(Text, { dimColor: true, children: "Paste your API key and press Enter." }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "#20a0a0", bold: true, children: ['\u276F', " "] }), _jsx(LongTextInput, { value: apiKey, onChange: (v) => { setApiKey(v); setApiKeyError(false); }, onSubmit: (v) => {
+                                            const cleaned = v.trim();
+                                            if (cleaned) {
+                                                setApiKey(cleaned);
+                                                setStep('base-url');
+                                            }
+                                            else {
+                                                setApiKeyError(true);
+                                            }
+                                        }, placeholder: "sk-or-v1-..." })] }), apiKeyError && (_jsx(Box, { marginTop: 0, paddingLeft: 2, children: _jsx(Text, { color: "yellow", dimColor: true, children: "API key is required." }) }))] })), step === 'base-url' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "white", children: "Base URL" }), _jsx(Text, { dimColor: true, children: "Scalix API endpoint (or any compatible URL)" }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "#20a0a0", bold: true, children: ['\u276F', " "] }), _jsx(TextInput, { value: baseUrl, onChange: (v) => setBaseUrl(sanitizeInput(v)), onSubmit: (v) => {
+                                            const url = sanitizeInput(v).trim() || baseUrl;
+                                            setBaseUrl(url);
+                                            setFetchingModels(true);
+                                            fetchModelSpecs(url, apiKey).then((result) => {
+                                                if (result.length > 0) {
+                                                    setFetchedModels(result.map((m) => ({ id: m.id, name: m.name })));
+                                                }
+                                            }).catch((err) => { logger.warn('Failed to fetch model specs', { error: err.message }); }).finally(() => {
+                                                setFetchingModels(false);
+                                                setStep('models');
+                                            });
+                                        }, placeholder: DEFAULT_BASE_URL })] }), fetchingModels && (_jsx(Box, { paddingLeft: 2, marginTop: 1, children: _jsx(Text, { color: "#20a0a0", dimColor: true, children: "Fetching available models..." }) }))] })), step === 'models' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "white", children: "Models" }), fetchedModels.length > 0 && modelsMode === 'custom' && models.length === 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Select models from your API or type a custom model ID." }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(SelectInput, { items: [
+                                                ...fetchedModels.filter((fm) => !models.includes(fm.id)).map((fm) => ({
+                                                    label: `  ${fm.name || fm.id}`,
+                                                    value: fm.id,
+                                                })),
+                                                { label: '+ Enter custom model ID...', value: '__custom__' },
+                                                ...(models.length > 0 ? [{ label: '\u2192 Continue', value: '__done__' }] : []),
+                                            ], onSelect: (item) => {
+                                                if (item.value === '__custom__') {
+                                                    setModelsMode('custom');
+                                                    setFetchedModels([]);
+                                                }
+                                                else if (item.value === '__done__') {
+                                                    if (models.length > 0)
+                                                        setStep('context-window');
+                                                }
+                                                else {
+                                                    if (!models.includes(item.value)) {
+                                                        setModels((prev) => [...prev, item.value]);
+                                                    }
+                                                }
+                                            } }) }), models.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginTop: 1, children: [_jsx(Text, { dimColor: true, bold: true, children: "Selected:" }), models.map((m) => (_jsxs(Text, { color: "#30c090", children: ['\u25CF', " ", m] }, m)))] }))] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "Type a model ID and press Enter to add. Add at least one." }), models.length > 0 && modelsMode === 'list' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "Added models (Enter to remove, \u2191/\u2193 to navigate):" }), _jsx(SelectInput, { items: [
+                                                    ...models.map((m) => ({
+                                                        label: `\u25CF ${m}`,
+                                                        value: m,
+                                                    })),
+                                                    { label: '+ Add another model...', value: '__add__' },
+                                                    { label: '\u2192 Continue', value: '__done__' },
+                                                ], onSelect: (item) => {
+                                                    if (item.value === '__add__') {
+                                                        setModelsMode('custom');
+                                                    }
+                                                    else if (item.value === '__done__') {
+                                                        if (models.length > 0)
+                                                            setStep('context-window');
+                                                    }
+                                                    else {
+                                                        setModels((prev) => {
+                                                            const next = prev.filter((m) => m !== item.value);
+                                                            if (next.length === 0)
+                                                                setModelsMode('custom');
+                                                            return next;
+                                                        });
+                                                    }
+                                                } })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [models.length > 0 && (_jsx(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: models.map((m) => (_jsxs(Text, { color: "#30c090", children: ['\u25CF', " ", m] }, m))) })), _jsxs(Box, { children: [_jsxs(Text, { color: "#20a0a0", bold: true, children: ['\u276F', " "] }), _jsx(TextInput, { value: modelInput, onChange: (v) => setModelInput(sanitizeInput(v)), onSubmit: (v) => {
+                                                            const trimmed = sanitizeInput(v).trim();
+                                                            if (trimmed) {
+                                                                if (!models.includes(trimmed)) {
+                                                                    setModels((prev) => [...prev, trimmed]);
+                                                                }
+                                                                setModelInput('');
+                                                            }
+                                                            else if (models.length > 0) {
+                                                                setModelsMode('list');
+                                                            }
+                                                        }, placeholder: "model-id (from your API provider)" })] }), _jsx(Box, { paddingLeft: 2, marginTop: 0, children: models.length === 0 ? (_jsx(Text, { color: "yellow", dimColor: true, children: "At least one model is required." })) : (_jsx(Text, { dimColor: true, children: "Enter another model or press Enter (empty) to review & continue" })) })] }))] }))] })), step === 'context-window' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "white", children: "Context Window Size" }), _jsx(Text, { dimColor: true, children: "Enter the max token count your model supports." }), _jsx(Text, { dimColor: true, children: "Check your model provider's docs for the exact limit." }), _jsx(Text, { dimColor: true, children: "This controls when the agent auto-compresses conversation context." }), (() => {
+                                const parsed = parseInt(contextInput, 10);
+                                const valid = parsed > 0;
+                                return valid ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "#30c090", children: ['\u25CF', " ", formatContextSize(parsed), " tokens (", parsed.toLocaleString(), ")"] }) })) : null;
+                            })(), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "#20a0a0", bold: true, children: ['\u276F', " "] }), _jsx(TextInput, { value: contextInput, onChange: setContextInput, onSubmit: (v) => {
+                                            const parsed = parseInt(v.trim(), 10);
+                                            const tokens = parsed > 0 ? parsed : DEFAULT_LIMITS.maxContextTokens;
+                                            const limits = { ...DEFAULT_LIMITS, maxContextTokens: tokens };
+                                            const newConfig = {
+                                                apiKey,
+                                                baseUrl,
+                                                models,
+                                                customModels: existingConfig?.customModels || {},
+                                                limits,
+                                                permissionMode: existingConfig?.permissionMode || 'default',
+                                                thinkingMode: existingConfig?.thinkingMode || 'off',
+                                                security: existingConfig?.security || {},
+                                                injectionDetection: existingConfig?.injectionDetection || { enabled: true, sensitivity: 'medium' },
+                                            };
+                                            saveConfig(newConfig).then(() => {
+                                                onComplete(newConfig);
+                                            }).catch(() => {
+                                                onComplete(newConfig);
+                                            });
+                                        }, placeholder: String(DEFAULT_LIMITS.maxContextTokens) })] })] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, italic: true, children: [stepNumber > 1 ? 'Backspace (empty) to go back \u2022 ' : '', "ESC to quit"] }) })] })] }));
+}
+const StatusBar = memo(function StatusBar({ status, model, toolCount, thinkStart, tokens, mode }) {
+    const { cols } = useTermSize();
+    const [elapsedStr, setElapsedStr] = useState('');
+    useEffect(() => {
+        if (!thinkStart) {
+            setElapsedStr('');
+            return;
+        }
+        setElapsedStr(elapsed(thinkStart));
+        const timer = setInterval(() => setElapsedStr(elapsed(thinkStart)), 1000);
+        return () => clearInterval(timer);
+    }, [thinkStart]);
+    const modeColor = mode === 'yolo' ? 'red' : mode === 'auto' ? 'yellow' : mode === 'plan' ? 'blue' : 'green';
+    const statusIcon = status === 'thinking' ? '\u25D4' : status === 'error' ? '\u2718' : '\u25CF';
+    const statusColor = status === 'thinking' ? 'yellow' : status === 'error' ? 'red' : 'green';
+    const activeAgents = AgentRegistry.getInstance().listActive().length;
+    const leftParts = [];
+    leftParts.push(shortModel(model));
+    if (tokens > 0)
+        leftParts.push(`${formatTokens(tokens)} tok`);
+    leftParts.push(`${toolCount} tools`);
+    if (activeAgents > 0)
+        leftParts.push(`${activeAgents} agent${activeAgents > 1 ? 's' : ''}`);
+    const leftText = leftParts.join(' \u00B7 ');
+    const rightLen = mode.length + VERSION.length + 6 + (elapsedStr ? elapsedStr.length + 3 : 0);
+    const gap = Math.max(cols - leftText.length - rightLen - 8, 2);
+    return (_jsxs(Box, { paddingX: 2, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: statusColor, children: statusIcon }), _jsx(Text, { dimColor: true, children: leftText })] }), _jsx(Text, { children: ' '.repeat(gap) }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: modeColor, bold: true, children: mode }), elapsedStr ? _jsxs(Text, { dimColor: true, children: ['\u00B7', " ", elapsedStr] }) : null, _jsxs(Text, { dimColor: true, children: ['\u00B7', " v", VERSION] })] })] }));
+});
+const WelcomeScreen = memo(function WelcomeScreen() {
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 0, children: [_jsx(Text, { dimColor: true, children: "  Type a message or use /help for commands. Press Esc to exit." }), _jsxs(Box, { marginTop: 0, paddingLeft: 2, gap: 1, flexWrap: "wrap", children: [_jsx(Text, { dimColor: true, children: "Tools:" }), ['shell', 'read', 'write', 'edit', 'search', 'find', 'git', 'web', 'tree'].map((t) => (_jsx(Text, { dimColor: true, bold: true, children: t }, t)))] })] }));
+});
+const UserMessage = memo(function UserMessage({ text }) {
+    return (_jsxs(Box, { paddingX: 2, marginTop: 1, gap: 1, children: [_jsx(Text, { color: "magentaBright", bold: true, children: '\u276F' }), _jsx(Text, { wrap: "wrap", bold: true, children: text })] }));
+});
+const AssistantMessage = memo(function AssistantMessage({ text }) {
+    const rendered = renderMarkdown(text);
+    return (_jsx(Box, { paddingLeft: 3, paddingRight: 2, flexDirection: "column", marginTop: 1, children: _jsx(Text, { wrap: "wrap", children: rendered }) }));
+});
+const ErrorMessage = memo(function ErrorMessage({ text, hint }) {
+    return (_jsxs(Box, { paddingLeft: 3, paddingRight: 2, flexDirection: "column", marginTop: 0, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "red", children: '\u2718' }), _jsx(Text, { wrap: "wrap", color: "red", children: text })] }), hint && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { wrap: "wrap", color: "yellow", dimColor: true, children: hint }) }))] }));
+});
+const ToolCallMessage = memo(function ToolCallMessage({ name, args }) {
+    let summary = '';
+    try {
+        const parsed = JSON.parse(args);
+        if (parsed.command)
+            summary = parsed.command;
+        else if (parsed.filePath || parsed.file_path)
+            summary = parsed.filePath || parsed.file_path;
+        else if (parsed.pattern)
+            summary = parsed.pattern;
+        else if (parsed.query)
+            summary = parsed.query;
+        else
+            summary = truncate(args, 80);
+    }
+    catch {
+        summary = truncate(args, 80);
+    }
+    return (_jsxs(Box, { paddingLeft: 3, paddingRight: 2, gap: 1, marginTop: 1, children: [_jsx(Text, { color: "cyan", children: '\u25CB' }), _jsx(Text, { color: "cyan", bold: true, children: name }), _jsx(Text, { dimColor: true, children: summary })] }));
+});
+const ToolResultMessage = memo(function ToolResultMessage({ name, result }) {
+    const { cols } = useTermSize();
+    const maxLen = Math.max(cols - name.length - 10, 40);
+    return (_jsxs(Box, { paddingLeft: 3, paddingRight: 2, gap: 1, children: [_jsx(Text, { color: "green", children: '\u25CF' }), _jsxs(Text, { dimColor: true, children: [name, ":"] }), _jsx(Text, { dimColor: true, children: truncate(result, maxLen) })] }));
+});
+const ToolBlockedMessage = memo(function ToolBlockedMessage({ text }) {
+    return (_jsxs(Box, { paddingLeft: 3, paddingRight: 2, gap: 1, children: [_jsx(Text, { color: "red", children: '\u25CF' }), _jsx(Text, { color: "red", children: text })] }));
+});
+const DIFF_MAX_LINES = 60;
+const DiffMessage = memo(function DiffMessage({ text, meta }) {
+    const allLines = text.split('\n');
+    const truncated = allLines.length > DIFF_MAX_LINES;
+    const lines = truncated ? [...allLines.slice(0, DIFF_MAX_LINES - 1), `  ... ${allLines.length - DIFF_MAX_LINES + 1} more lines`] : allLines;
+    return (_jsxs(Box, { paddingX: 2, paddingLeft: 3, flexDirection: "column", marginTop: 0, marginBottom: 0, children: [_jsxs(Text, { color: "cyan", dimColor: true, children: ['\u250C', " ", meta || 'Changes'] }), _jsx(Box, { flexDirection: "column", paddingLeft: 1, children: lines.map((line, i) => {
+                    if (line.startsWith('+ ') || line.startsWith('+\t')) {
+                        return _jsxs(Text, { color: "green", children: ['\u2502', " ", line] }, i);
+                    }
+                    if (line.startsWith('- ') || line.startsWith('-\t')) {
+                        return _jsxs(Text, { color: "red", children: ['\u2502', " ", line] }, i);
+                    }
+                    if (line.startsWith('@@ ')) {
+                        return _jsxs(Text, { color: "cyan", dimColor: true, children: ['\u2502', " ", line] }, i);
+                    }
+                    if (line.startsWith('---') || line.startsWith('+++')) {
+                        return _jsxs(Text, { bold: true, children: ['\u2502', " ", line] }, i);
+                    }
+                    if (line.includes('additions') || line.includes('deletions')) {
+                        return _jsxs(Text, { color: "cyan", dimColor: true, children: ['\u2514', " ", line] }, i);
+                    }
+                    return _jsxs(Text, { dimColor: true, children: ['\u2502', " ", line] }, i);
+                }) })] }));
+});
+const SystemMessage = memo(function SystemMessage({ text }) {
+    return (_jsxs(Box, { paddingX: 2, paddingLeft: 3, marginY: 0, gap: 1, children: [_jsx(Text, { dimColor: true, children: '\u2500' }), _jsx(Text, { dimColor: true, wrap: "wrap", children: text })] }));
+});
+const RenderItem = memo(function RenderItem({ item }) {
+    switch (item.kind) {
+        case 'user': return _jsx(UserMessage, { text: item.text });
+        case 'assistant': return _jsx(AssistantMessage, { text: item.text });
+        case 'error': return _jsx(ErrorMessage, { text: item.text, hint: item.hint });
+        case 'tool-call': return _jsx(ToolCallMessage, { name: item.meta ?? '', args: item.text });
+        case 'tool-result': return _jsx(ToolResultMessage, { name: item.meta ?? '', result: item.text });
+        case 'tool-blocked': return _jsx(ToolBlockedMessage, { text: item.text });
+        case 'diff': return _jsx(DiffMessage, { text: item.text, meta: item.meta });
+        case 'system': return _jsx(SystemMessage, { text: item.text });
+    }
+});
+const StreamingArea = memo(function StreamingArea({ text, reasoning, model, maxLines }) {
+    const { rows } = useTermSize();
+    const limit = maxLines ?? Math.floor(rows * 0.5);
+    const displayText = useMemo(() => {
+        if (!text)
+            return '';
+        const lines = text.split('\n');
+        if (lines.length <= limit)
+            return text;
+        return '…\n' + lines.slice(-limit).join('\n');
+    }, [text, limit]);
+    const displayReasoning = useMemo(() => {
+        if (!reasoning)
+            return '';
+        const lines = reasoning.split('\n');
+        if (lines.length <= 3)
+            return reasoning;
+        return lines.slice(-3).join('\n');
+    }, [reasoning]);
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 3, paddingRight: 2, marginTop: 1, children: [displayReasoning.length > 0 && (_jsx(Box, { paddingLeft: 0, marginBottom: 0, children: _jsxs(Text, { color: "magenta", dimColor: true, italic: true, wrap: "wrap", children: ['\u2502', " ", displayReasoning] }) })), displayText.length > 0 ? (_jsxs(Text, { wrap: "wrap", children: [renderMarkdown(displayText), _jsx(Text, { color: "magentaBright", children: '\u258E' })] })) : displayReasoning.length === 0 ? (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "magentaBright", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { dimColor: true, children: ["Thinking", model ? ` (${model})` : '', "..."] })] })) : null] }));
+});
+function ConfirmPrompt({ toolName, args, onRespond, onScrollUp, onScrollDown }) {
+    const { cols } = useTermSize();
+    useInput((ch, key) => {
+        if (ch.toLowerCase() === 'y')
+            onRespond(true);
+        else if (ch.toLowerCase() === 'n' || key.escape)
+            onRespond(false);
+        else if (key.pageUp || (key.upArrow && key.shift))
+            onScrollUp?.();
+        else if (key.pageDown || (key.downArrow && key.shift))
+            onScrollDown?.();
+    });
+    let parsed = {};
+    try {
+        parsed = typeof args === 'string' ? JSON.parse(args) : args ?? {};
+    }
+    catch {
+        parsed = {};
+    }
+    const isCommand = toolName === 'run_command';
+    const isWrite = toolName === 'write_file' || toolName === 'edit_file' || toolName === 'notebook_edit';
+    const isGit = toolName === 'git_commit';
+    const highlight = parsed.command ?? parsed.filePath ?? parsed.file_path ?? parsed.notebook_path ?? parsed.message ?? null;
+    const highlightLabel = isCommand ? 'Command' : isGit ? 'Message' : isWrite ? 'File' : 'Args';
+    const highlightStr = highlight ? String(highlight) : null;
+    const extraFields = Object.entries(parsed).filter(([k]) => !['command', 'filePath', 'file_path', 'notebook_path', 'message', 'content'].includes(k));
+    const boxWidth = Math.min(cols - 2, 80);
+    const border = '\u2500'.repeat(boxWidth - 2);
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { color: "yellow", children: ['\u250C', border, '\u2510'] }), _jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsxs(Text, { color: "yellow", bold: true, children: ['\u26A0', " Permission Required"] }), _jsx(Text, { children: ' '.repeat(Math.max(0, boxWidth - 24)) }), '\u2502'] }), _jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsx(Text, { dimColor: true, children: "Tool:" }), " ", _jsx(Text, { color: "cyan", bold: true, children: toolName }), _jsx(Text, { children: ' '.repeat(Math.max(0, boxWidth - 9 - toolName.length)) }), '\u2502'] }), highlightStr && (_jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsxs(Text, { dimColor: true, children: [highlightLabel, ":"] }), " ", _jsx(Text, { color: "white", bold: true, children: truncate(highlightStr, boxWidth - highlightLabel.length - 6) }), _jsx(Text, { children: ' '.repeat(Math.max(0, boxWidth - highlightLabel.length - 4 - Math.min(highlightStr.length, boxWidth - highlightLabel.length - 6))) }), '\u2502'] })), extraFields.slice(0, 3).map(([k, v]) => {
+                const val = truncate(String(v), boxWidth - k.length - 6);
+                return (_jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsxs(Text, { dimColor: true, children: [k, ":"] }), " ", _jsx(Text, { children: val }), _jsx(Text, { children: ' '.repeat(Math.max(0, boxWidth - k.length - 4 - val.length)) }), '\u2502'] }, k));
+            }), _jsxs(Text, { color: "yellow", children: ['\u251C', border, '\u2524'] }), _jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsx(Text, { color: "green", bold: true, children: "[Y]" }), _jsx(Text, { children: " Allow  " }), _jsx(Text, { color: "red", bold: true, children: "[N]" }), _jsx(Text, { children: " Deny  " }), _jsx(Text, { dimColor: true, children: "ESC to deny" }), _jsx(Text, { children: ' '.repeat(Math.max(0, boxWidth - 33)) }), '\u2502'] }), _jsxs(Text, { color: "yellow", children: ['\u2514', border, '\u2518'] })] }));
+}
+function ModelPicker({ currentModels, onSelect, onCancel }) {
+    const [customInput, setCustomInput] = useState('');
+    const [showCustom, setShowCustom] = useState(false);
+    useInput((_ch, key) => { if (key.escape) {
+        if (showCustom)
+            setShowCustom(false);
+        else
+            onCancel();
+    } });
+    if (showCustom) {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 3, marginX: 0, children: [_jsx(Text, { bold: true, children: "Enter Model ID" }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "magentaBright", bold: true, children: ['\u276F', " "] }), _jsx(TextInput, { value: customInput, onChange: setCustomInput, onSubmit: (v) => {
+                                if (v.trim())
+                                    onSelect(v.trim(), shortModel(v.trim()));
+                                else
+                                    setShowCustom(false);
+                            }, placeholder: "provider/model-name" })] }), _jsx(Text, { dimColor: true, children: "ESC to go back" })] }));
+    }
+    const items = [
+        ...currentModels.map((m) => ({
+            label: `\u25CF ${shortModel(m)}`,
+            value: m,
+        })),
+        { label: '+ Add new model...', value: '__custom__' },
+        { label: '  Cancel', value: '__cancel__' },
+    ];
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 3, marginX: 0, children: [_jsx(Text, { bold: true, children: "Switch Model" }), _jsxs(Text, { dimColor: true, children: ["Current: ", currentModels.map(shortModel).join(', ')] }), _jsx(SelectInput, { items: items, onSelect: (item) => {
+                    if (item.value === '__cancel__')
+                        onCancel();
+                    else if (item.value === '__custom__')
+                        setShowCustom(true);
+                    else
+                        onSelect(item.value, item.label);
+                } }), _jsx(Text, { dimColor: true, children: "ESC to cancel" })] }));
+}
+function SessionPicker({ sessions, onSelect, onCancel }) {
+    useInput((_ch, key) => { if (key.escape)
+        onCancel(); });
+    useEffect(() => {
+        if (sessions.length === 0) {
+            const timer = setTimeout(onCancel, 1500);
+            return () => clearTimeout(timer);
+        }
+    }, [sessions.length, onCancel]);
+    if (sessions.length === 0) {
+        return (_jsx(Box, { paddingX: 3, marginY: 1, children: _jsx(Text, { dimColor: true, italic: true, children: "No saved sessions found. Press ESC or wait..." }) }));
+    }
+    const items = [
+        ...sessions.slice(0, 10).map((s) => ({
+            label: `${s.name} (${s.messageCount} msgs, ${shortModel(s.model)}, ${new Date(s.updatedAt).toLocaleDateString()})`,
+            value: s.id,
+        })),
+        { label: 'Cancel', value: '__cancel__' },
+    ];
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 3, marginX: 0, children: [_jsx(Text, { bold: true, children: "Resume Session" }), _jsx(SelectInput, { items: items, onSelect: (item) => {
+                    if (item.value === '__cancel__')
+                        return onCancel();
+                    const session = sessions.find((s) => s.id === item.value);
+                    if (session)
+                        onSelect(session);
+                    else
+                        onCancel();
+                } }), _jsx(Text, { dimColor: true, children: "ESC to cancel" })] }));
+}
+function ModePicker({ currentMode, onSelect, onCancel }) {
+    useInput((_ch, key) => { if (key.escape)
+        onCancel(); });
+    const items = [
+        ...PERMISSION_MODES.map((m) => ({
+            label: `${m === currentMode ? '\u25CF' : '\u25CB'} ${m.padEnd(8)} \u2014 ${getModeDescription(m)}`,
+            value: m,
+        })),
+        { label: '  Cancel', value: '__cancel__' },
+    ];
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 3, marginX: 0, children: [_jsx(Text, { bold: true, children: "Permission Mode" }), _jsxs(Text, { dimColor: true, children: ["Current: ", currentMode] }), _jsx(SelectInput, { items: items, initialIndex: PERMISSION_MODES.indexOf(currentMode), onSelect: (item) => {
+                    if (item.value === '__cancel__')
+                        onCancel();
+                    else
+                        onSelect(item.value);
+                } }), _jsx(Text, { dimColor: true, children: "ESC to cancel" })] }));
+}
+function SettingsEditor({ onSave, onClose }) {
+    const [selectedKey, setSelectedKey] = useState(null);
+    const [editValue, setEditValue] = useState('');
+    const [currentConfig, setCurrentConfig] = useState(null);
+    const reload = useCallback(() => { loadConfig().then(setCurrentConfig).catch((err) => { logger.warn('Failed to load config', { error: err.message }); }); }, []);
+    useEffect(() => { reload(); }, [reload]);
+    useInput((_ch, key) => {
+        if (key.escape) {
+            if (selectedKey)
+                setSelectedKey(null);
+            else
+                onClose();
+        }
+    });
+    if (!currentConfig) {
+        return (_jsx(Box, { paddingX: 2, children: _jsxs(Text, { dimColor: true, children: ['\u25CF', " Loading settings..."] }) }));
+    }
+    const limits = currentConfig.limits || DEFAULT_LIMITS;
+    if (selectedKey) {
+        const currentVal = String(limits[selectedKey]);
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 3, marginX: 0, children: [_jsxs(Text, { bold: true, children: ["Edit: ", selectedKey] }), _jsxs(Text, { dimColor: true, children: ["Current: ", currentVal] }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "magentaBright", bold: true, children: ['\u276F', " "] }), _jsx(TextInput, { value: editValue, onChange: setEditValue, onSubmit: (v) => {
+                                const trimmed = v.trim();
+                                if (!trimmed) {
+                                    setSelectedKey(null);
+                                    return;
+                                }
+                                const num = Number(trimmed);
+                                if (isNaN(num) || num < 0) {
+                                    setEditValue('');
+                                    return;
+                                }
+                                if (selectedKey.includes('Ratio') || selectedKey.includes('Threshold') || selectedKey === 'slidingWindowTarget') {
+                                    if (num < 0 || num > 1) {
+                                        setEditValue('');
+                                        return;
+                                    }
+                                }
+                                onSave(selectedKey, trimmed);
+                                setSelectedKey(null);
+                                reload();
+                            }, placeholder: currentVal })] }), _jsx(Text, { dimColor: true, children: "Enter to save \u2022 ESC to go back" })] }));
+    }
+    const editableKeys = [
+        // Agent
+        { key: 'maxSteps', label: 'Max Steps (tool-call rounds)', value: String(limits.maxSteps) },
+        { key: 'maxMessages', label: 'Max Messages (history size)', value: String(limits.maxMessages) },
+        { key: 'maxRetries', label: 'Max Retries', value: String(limits.maxRetries) },
+        { key: 'toolTimeoutMs', label: 'Tool Timeout (ms)', value: limits.toolTimeoutMs.toLocaleString() },
+        { key: 'circuitBreakerThreshold', label: 'Circuit Breaker Threshold', value: String(limits.circuitBreakerThreshold) },
+        { key: 'circuitBreakerResetMs', label: 'Circuit Breaker Reset (ms)', value: limits.circuitBreakerResetMs.toLocaleString() },
+        { key: 'messageKeepRatio', label: 'Message Keep Ratio (0-1)', value: String(limits.messageKeepRatio) },
+        // Context
+        { key: 'maxContextTokens', label: 'Max Context Tokens', value: limits.maxContextTokens.toLocaleString() },
+        { key: 'maxToolResultTokens', label: 'Max Tool Result Tokens', value: String(limits.maxToolResultTokens) },
+        { key: 'compressionThreshold', label: 'Compression Threshold (0-1)', value: String(limits.compressionThreshold) },
+        { key: 'charsPerToken', label: 'Chars Per Token', value: String(limits.charsPerToken) },
+        { key: 'minRecentMessages', label: 'Min Recent Messages', value: String(limits.minRecentMessages) },
+        { key: 'slidingWindowTarget', label: 'Sliding Window Target (0-1)', value: String(limits.slidingWindowTarget) },
+        // File & Shell
+        { key: 'readFileMaxSize', label: 'Read File Max Size (bytes)', value: limits.readFileMaxSize.toLocaleString() },
+        { key: 'maxEditStringLength', label: 'Max Edit String Length', value: limits.maxEditStringLength.toLocaleString() },
+        { key: 'commandTimeoutMs', label: 'Command Timeout (ms)', value: limits.commandTimeoutMs.toLocaleString() },
+        { key: 'searchTimeoutMs', label: 'Search Timeout (ms)', value: limits.searchTimeoutMs.toLocaleString() },
+        { key: 'fileRefTruncation', label: 'File Ref Truncation', value: limits.fileRefTruncation.toLocaleString() },
+        { key: 'treeMaxEntries', label: 'Tree Max Entries', value: String(limits.treeMaxEntries) },
+        { key: 'shellDetectionTimeoutMs', label: 'Shell Detection Timeout (ms)', value: limits.shellDetectionTimeoutMs.toLocaleString() },
+        // Background processes
+        { key: 'bgBufferMax', label: 'BG Buffer Max (bytes)', value: limits.bgBufferMax.toLocaleString() },
+        { key: 'bgCleanupMs', label: 'BG Cleanup (ms)', value: limits.bgCleanupMs.toLocaleString() },
+        // Git
+        { key: 'gitTimeoutMs', label: 'Git Timeout (ms)', value: limits.gitTimeoutMs.toLocaleString() },
+        { key: 'gitDiffMaxBuffer', label: 'Git Diff Max Buffer (bytes)', value: limits.gitDiffMaxBuffer.toLocaleString() },
+        // Web
+        { key: 'webFetchTimeoutMs', label: 'Web Fetch Timeout (ms)', value: limits.webFetchTimeoutMs.toLocaleString() },
+        { key: 'htmlMaxSize', label: 'HTML Max Size (bytes)', value: limits.htmlMaxSize.toLocaleString() },
+        { key: 'defaultSearchResults', label: 'Default Search Results', value: String(limits.defaultSearchResults) },
+        { key: 'defaultMaxFetchLength', label: 'Default Max Fetch Length', value: limits.defaultMaxFetchLength.toLocaleString() },
+        { key: 'maxWebFetchLength', label: 'Max Web Fetch Length', value: limits.maxWebFetchLength.toLocaleString() },
+        // Sub-agents
+        { key: 'subAgentTimeoutMs', label: 'Sub-Agent Timeout (ms)', value: limits.subAgentTimeoutMs.toLocaleString() },
+        { key: 'subAgentMaxSteps', label: 'Sub-Agent Max Steps', value: String(limits.subAgentMaxSteps) },
+        { key: 'subAgentMaxContextTokens', label: 'Sub-Agent Max Context Tokens', value: limits.subAgentMaxContextTokens.toLocaleString() },
+        { key: 'subAgentCompressionThreshold', label: 'Sub-Agent Compression Threshold', value: String(limits.subAgentCompressionThreshold) },
+        { key: 'agentToolTimeoutMs', label: 'Agent Tool Timeout (ms)', value: limits.agentToolTimeoutMs.toLocaleString() },
+        { key: 'exploreMaxSteps', label: 'Explore Max Steps', value: String(limits.exploreMaxSteps) },
+        // Notebooks
+        { key: 'maxNotebookSource', label: 'Max Notebook Source', value: limits.maxNotebookSource.toLocaleString() },
+    ];
+    const items = [
+        ...editableKeys.map((e) => ({
+            label: `${e.label}: ${e.value}`,
+            value: e.key,
+        })),
+        { label: '  Done', value: '__done__' },
+    ];
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 3, marginX: 0, children: [_jsx(Text, { bold: true, children: "Settings" }), _jsxs(Text, { dimColor: true, children: ['\u2191\u2193', " navigate ", '\u00B7', " Enter to edit ", '\u00B7', " ESC to close"] }), _jsx(SelectInput, { items: items, limit: 15, onSelect: (item) => {
+                    if (item.value === '__done__')
+                        onClose();
+                    else {
+                        setSelectedKey(item.value);
+                        setEditValue(String(limits[item.value]));
+                    }
+                } })] }));
+}
+const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, onClear, onScrollUp, onScrollDown, onHeightChange }) {
+    const { exit } = useApp();
+    const { cols } = useTermSize();
+    const line = useMemo(() => '\u2500'.repeat(Math.max(cols - 6, 20)), [cols]);
+    const [value, setValue] = useState('');
+    const [stash, setStash] = useState('');
+    const [ctrlCCount, setCtrlCCount] = useState(0);
+    const ctrlCTimer = useRef(null);
+    const [history, setHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const savedInput = useRef('');
+    const valueRef = useRef('');
+    const onChange = useCallback((v) => {
+        setValue(v);
+        valueRef.current = v;
+        setHistoryIndex(-1);
+    }, []);
+    const handleSubmit = useCallback((v) => {
+        const trimmed = v.trim();
+        if (!trimmed)
+            return;
+        setHistory((prev) => {
+            const filtered = prev.filter((h) => h !== trimmed);
+            return [...filtered, trimmed].slice(-100);
+        });
+        setHistoryIndex(-1);
+        setValue('');
+        valueRef.current = '';
+        onSubmit(trimmed);
+    }, [onSubmit]);
+    useInput((ch, key) => {
+        const val = valueRef.current;
+        // ── Ctrl+C: interrupt → clear → exit (escalating) ──
+        if (ch === 'c' && key.ctrl) {
+            if (disabled) {
+                onAbort();
+                return;
+            }
+            if (val.length > 0) {
+                onChange('');
+                return;
+            }
+            setCtrlCCount((prev) => {
+                if (prev >= 1) {
+                    exit();
+                    return 0;
+                }
+                if (ctrlCTimer.current)
+                    clearTimeout(ctrlCTimer.current);
+                ctrlCTimer.current = setTimeout(() => setCtrlCCount(0), 3000);
+                return prev + 1;
+            });
+            return;
+        }
+        // ── Ctrl+D: exit when input is empty ──
+        if (ch === 'd' && key.ctrl) {
+            if (!disabled && val.length === 0)
+                exit();
+            return;
+        }
+        // ── Ctrl+L: clear screen ──
+        if (ch === 'l' && key.ctrl) {
+            onClear();
+            return;
+        }
+        // ── Ctrl+U: clear entire input ──
+        if (ch === 'u' && key.ctrl && !disabled) {
+            onChange('');
+            return;
+        }
+        // ── Ctrl+W: delete last word ──
+        if (ch === 'w' && key.ctrl && !disabled) {
+            const trimmed = val.replace(/\s*\S+\s*$/, '');
+            onChange(trimmed === val ? '' : trimmed);
+            return;
+        }
+        // ── Ctrl+K: delete from cursor to end (clears all since cursor is at end) ──
+        if (ch === 'k' && key.ctrl && !disabled) {
+            onChange('');
+            return;
+        }
+        // ── Ctrl+S: stash / restore prompt ──
+        if (ch === 's' && key.ctrl && !disabled) {
+            if (val.length > 0) {
+                setStash(val);
+                onChange('');
+            }
+            else if (stash.length > 0) {
+                onChange(stash);
+                setStash('');
+            }
+            return;
+        }
+        // ── Tab: autocomplete slash commands ──
+        if (key.tab && !disabled && val.startsWith('/') && !val.includes(' ')) {
+            const cmdNames = commands.map((c) => c.cmd);
+            const matches = cmdNames.filter((c) => c.startsWith(val.toLowerCase()));
+            if (matches.length === 1)
+                onChange(matches[0]);
+            return;
+        }
+        // ── Escape: close command picker or exit ──
+        if (key.escape) {
+            if (val.startsWith('/') && !val.includes(' ')) {
+                onChange('');
+                return;
+            }
+            exit();
+            return;
+        }
+        // ── When command picker is open, handle input manually since TextInput is unfocused ──
+        const pickerOpen = !disabled && val.startsWith('/') && !val.includes(' ');
+        if (pickerOpen) {
+            if (key.upArrow || key.downArrow || key.return)
+                return;
+            if (key.backspace || key.delete) {
+                onChange(val.slice(0, -1));
+                return;
+            }
+            if (!key.ctrl && !key.meta && !key.tab && ch.length > 0) {
+                onChange(val + sanitizeInput(ch));
+                return;
+            }
+            return;
+        }
+        // ── Scroll ──
+        if (key.pageUp || (key.upArrow && key.shift)) {
+            onScrollUp();
+            return;
+        }
+        if (key.pageDown || (key.downArrow && key.shift)) {
+            onScrollDown();
+            return;
+        }
+        // ── History navigation ──
+        if (!disabled) {
+            if (key.upArrow && history.length > 0) {
+                setHistoryIndex((prev) => {
+                    if (prev === -1)
+                        savedInput.current = val;
+                    const next = Math.min(prev + 1, history.length - 1);
+                    const restored = history[history.length - 1 - next] || '';
+                    setValue(restored);
+                    valueRef.current = restored;
+                    return next;
+                });
+            }
+            if (key.downArrow && historyIndex >= 0) {
+                setHistoryIndex((prev) => {
+                    const next = Math.max(prev - 1, -1);
+                    const restored = next === -1 ? savedInput.current : (history[history.length - 1 - next] || '');
+                    setValue(restored);
+                    valueRef.current = restored;
+                    return next;
+                });
+            }
+        }
+    });
+    const commands = useMemo(() => [
+        { cmd: '/help', desc: 'Show all commands' },
+        { cmd: '/clear', desc: 'Reset conversation' },
+        { cmd: '/models', desc: 'List active models' },
+        { cmd: '/model', desc: 'Switch model' },
+        { cmd: '/mode', desc: 'Permission mode (plan/default/auto/yolo)' },
+        { cmd: '/thinking', desc: 'Thinking mode (off/low/medium/high)' },
+        { cmd: '/plan', desc: 'Enter plan mode (read-only)' },
+        { cmd: '/compact', desc: 'Compress conversation context' },
+        { cmd: '/context', desc: 'Show context usage & token count' },
+        { cmd: '/cost', desc: 'Show token usage & cost' },
+        { cmd: '/diff', desc: 'Show uncommitted changes' },
+        { cmd: '/copy', desc: 'Copy last response to clipboard' },
+        { cmd: '/save', desc: 'Save current session' },
+        { cmd: '/load', desc: 'Resume a saved session' },
+        { cmd: '/export', desc: 'Export conversation as text' },
+        { cmd: '/index', desc: 'Scan & index project files' },
+        { cmd: '/init', desc: 'Initialize project config (SCALIX.md)' },
+        { cmd: '/git', desc: 'Show git context' },
+        { cmd: '/memory', desc: 'Show project memory' },
+        { cmd: '/remember', desc: 'Save a note about this project' },
+        { cmd: '/replay', desc: 'Show session timeline' },
+        { cmd: '/plugins', desc: 'Show loaded plugins' },
+        { cmd: '/router', desc: 'Show model routing status' },
+        { cmd: '/status', desc: 'Version, model & connection info' },
+        { cmd: '/doctor', desc: 'Diagnose installation' },
+        { cmd: '/mcp', desc: 'Add MCP server' },
+        { cmd: '/setup', desc: 'Reconfigure API key, URL & models' },
+        { cmd: '/settings', desc: 'View & configure limits' },
+        { cmd: '/shortcuts', desc: 'Keyboard shortcuts' },
+        { cmd: '/hooks', desc: 'Show lifecycle hooks' },
+        { cmd: '/commands', desc: 'Show custom commands' },
+        { cmd: '/delegate', desc: 'Run task with sub-agent' },
+        { cmd: '/agents', desc: 'Show active agents & usage' },
+        { cmd: '/checkpoint', desc: 'Create git checkpoint' },
+        { cmd: '/undo', desc: 'Undo last checkpoint' },
+        { cmd: '/checkpoints', desc: 'List recent checkpoints' },
+        { cmd: '/commit', desc: 'Auto-generate commit message & commit' },
+        { cmd: '/review', desc: 'AI code review of current changes' },
+        { cmd: '/watch', desc: 'Run command, auto-fix on failure' },
+        { cmd: '/create', desc: 'Scaffold a new project' },
+        { cmd: '/exit', desc: 'Save & exit' },
+        ...customCommands.map((c) => ({ cmd: `/${c.name}`, desc: c.description })),
+    ], [customCommands]);
+    const prefix = value.split(' ')[0].toLowerCase();
+    const showCommandPicker = !disabled && value.startsWith('/') && !value.includes(' ');
+    const filteredCommands = showCommandPicker
+        ? commands.filter((c) => c.cmd.startsWith(prefix))
+        : [];
+    const pickerActive = showCommandPicker && filteredCommands.length > 0;
+    useEffect(() => {
+        if (!onHeightChange)
+            return;
+        let h = 3; // separator + input row + padding
+        if (pickerActive)
+            h += Math.min(filteredCommands.length, 10) + 2; // items + header + footer
+        if (stash.length > 0 && !disabled)
+            h += 1;
+        onHeightChange(h);
+    }, [pickerActive, filteredCommands.length, stash.length, disabled, onHeightChange]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { paddingX: 2, children: _jsx(Text, { dimColor: true, children: line }) }), pickerActive && (_jsxs(Box, { flexDirection: "column", paddingX: 3, marginX: 0, paddingY: 0, children: [_jsxs(Box, { gap: 1, marginBottom: 0, children: [_jsx(Text, { dimColor: true, bold: true, children: "Commands" }), _jsxs(Text, { dimColor: true, children: ["(", filteredCommands.length, ")"] })] }), _jsx(SelectInput, { items: filteredCommands.map((c) => ({
+                            label: `${c.cmd.padEnd(16)} ${c.desc}`,
+                            value: c.cmd,
+                        })), isFocused: true, onSelect: (item) => {
+                            const argCmds = ['/remember', '/delegate', '/save', '/mode', '/thinking', '/mcp', '/watch', '/create', '/export'];
+                            if (argCmds.includes(item.value)) {
+                                onChange(item.value + ' ');
+                            }
+                            else {
+                                onChange('');
+                                handleSubmit(item.value);
+                            }
+                        }, limit: 10 }), _jsxs(Text, { dimColor: true, italic: true, children: ['↑↓', " navigate ", '•', " Enter select ", '•', " keep typing to filter"] })] })), stash.length > 0 && !disabled && (_jsxs(Box, { paddingX: 3, children: [_jsxs(Text, { color: "magenta", dimColor: true, children: ['⚑', " Stashed: ", truncate(stash, 40), " "] }), _jsx(Text, { dimColor: true, children: "(Ctrl+S to restore)" })] })), _jsx(Box, { paddingX: 2, children: _jsxs(Box, { flexGrow: 1, children: [_jsx(Box, { flexShrink: 0, width: 2, children: disabled ? (_jsx(Text, { color: "magentaBright", children: _jsx(Spinner, { type: "dots" }) })) : (_jsx(Text, { color: "magentaBright", bold: true, children: '❯' })) }), _jsx(Box, { flexGrow: 1, children: _jsx(TextInput, { value: value, onChange: onChange, onSubmit: handleSubmit, placeholder: disabled ? 'Queue a message... (sent after current task)' : 'Type a message...', showCursor: true, focus: !pickerActive }) }), disabled && (_jsx(Box, { flexShrink: 0, children: _jsx(Text, { dimColor: true, children: " ^C interrupt" }) }))] }) })] }));
+});
+// ─── App ───
+function estimateLines(item, cols) {
+    // Account for paddingLeft=3 + paddingRight=2 used by most message components
+    const textWidth = Math.max(cols - 7, 20);
+    const lines = item.text.split('\n');
+    // Count wrapped lines per actual line
+    let totalLines = 0;
+    for (const line of lines) {
+        totalLines += Math.max(1, Math.ceil((line.length || 1) / textWidth));
+    }
+    switch (item.kind) {
+        case 'user': return totalLines + 2; // marginTop=1 + prompt icon row
+        case 'assistant': {
+            // Markdown rendering can add ~20% extra lines for headings, code blocks, spacing
+            const markdownExpansion = Math.ceil(totalLines * 0.2);
+            return totalLines + markdownExpansion + 2; // marginTop=1 + padding
+        }
+        case 'error': return totalLines + 2;
+        case 'tool-call': return 2; // single row + marginTop=1
+        case 'tool-result': return 1;
+        case 'tool-blocked': return 1;
+        case 'diff': return lines.length + 2; // header + each diff line + footer
+        case 'system': return 1;
+    }
+}
+function useScrollableItems(items, availableHeight, cols, isLoading, streamLineCount = 0) {
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const prevItemCount = useRef(items.length);
+    const autoScroll = useRef(true);
+    useEffect(() => {
+        if (items.length > prevItemCount.current && autoScroll.current) {
+            setScrollOffset(0);
+        }
+        prevItemCount.current = items.length;
+    }, [items.length]);
+    useEffect(() => {
+        if (isLoading && autoScroll.current)
+            setScrollOffset(0);
+    }, [isLoading]);
+    const scrollUp = useCallback((amount = 3) => {
+        setScrollOffset((prev) => {
+            const maxOffset = Math.max(items.length - 1, 0);
+            const next = Math.min(prev + amount, maxOffset);
+            autoScroll.current = false;
+            return next;
+        });
+    }, [items.length]);
+    const scrollDown = useCallback((amount = 3) => {
+        setScrollOffset((prev) => {
+            const next = Math.max(prev - amount, 0);
+            if (next === 0)
+                autoScroll.current = true;
+            return next;
+        });
+    }, []);
+    const scrollToBottom = useCallback(() => {
+        setScrollOffset(0);
+        autoScroll.current = true;
+    }, []);
+    const reservedForStream = isLoading ? Math.max(4, Math.min(streamLineCount + 3, Math.floor(availableHeight * 0.5))) : 0;
+    const effectiveHeight = Math.max(availableHeight - reservedForStream, 4);
+    const visibleItems = [];
+    let usedLines = 0;
+    const endIdx = items.length - scrollOffset;
+    for (let i = endIdx - 1; i >= 0; i--) {
+        const lines = estimateLines(items[i], cols);
+        if (usedLines + lines > effectiveHeight && visibleItems.length > 0)
+            break;
+        visibleItems.unshift(items[i]);
+        usedLines += lines;
+    }
+    const isAtBottom = scrollOffset === 0;
+    const isAtTop = visibleItems.length > 0 && visibleItems[0].id === items[0]?.id;
+    return { visibleItems, scrollUp, scrollDown, scrollToBottom, isAtBottom, isAtTop, scrollOffset };
+}
+function App({ config }) {
+    const { rows, cols } = useTermSize();
+    const [items, setItems] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [status, setStatus] = useState('ready');
+    const [models, setModels] = useState(agent?.getModels() ?? []);
+    const [streamText, setStreamText] = useState('');
+    const [reasoningText, setReasoningText] = useState('');
+    const [selectingModel, setSelectingModel] = useState(false);
+    const [confirmInfo, setConfirmInfo] = useState(null);
+    const [thinkStart, setThinkStart] = useState(null);
+    const [showBanner, setShowBanner] = useState(true);
+    const [totalTokens, setTotalTokens] = useState(0);
+    const [sessionList, setSessionList] = useState(null);
+    const [showSetup, setShowSetup] = useState(false);
+    const [currentMode, setCurrentMode] = useState(agent?.getPermissionMode() ?? 'default');
+    const [selectingMode, setSelectingMode] = useState(false);
+    const [editingSettings, setEditingSettings] = useState(false);
+    const [agentVersion, setAgentVersion] = useState(0);
+    const counter = useRef(0);
+    const showBannerRef = useRef(true);
+    const modelsRef = useRef(models);
+    useEffect(() => { modelsRef.current = models; }, [models]);
+    const nextId = () => ++counter.current;
+    const MAX_DISPLAY_ITEMS = 2000;
+    const add = useCallback((kind, text, meta, hint) => {
+        setItems((prev) => {
+            const next = [...prev, { id: nextId(), kind, text, meta, hint }];
+            return next.length > MAX_DISPLAY_ITEMS ? next.slice(next.length - MAX_DISPLAY_ITEMS) : next;
+        });
+        if (showBannerRef.current && kind !== 'system') {
+            showBannerRef.current = false;
+            setShowBanner(false);
+        }
+    }, []);
+    // Register agent event handlers ONCE
+    useEffect(() => {
+        const onThinkingStart = () => {
+            setIsLoading(true);
+            setStreamText('');
+            setReasoningText('');
+            setStatus('thinking');
+            setThinkStart(Date.now());
+        };
+        const onThinkingEnd = () => {
+            setIsLoading(false);
+            setStatus('ready');
+            setThinkStart(null);
+        };
+        let streamBuffer = '';
+        let streamFlushTimer = null;
+        let streamStallTimer = null;
+        const STREAM_THROTTLE_MS = 50;
+        const STREAM_STALL_MS = 15_000;
+        const flushStream = () => {
+            streamFlushTimer = null;
+            setStreamText(streamBuffer);
+        };
+        const resetStallTimer = () => {
+            if (streamStallTimer)
+                clearTimeout(streamStallTimer);
+            streamStallTimer = setTimeout(() => {
+                if (isLoadingRef.current) {
+                    add('system', 'Stream appears stalled. Press Ctrl+C to abort, or wait for a response.');
+                }
+            }, STREAM_STALL_MS);
+        };
+        const onDelta = (_d, acc) => {
+            streamBuffer = acc;
+            resetStallTimer();
+            if (!streamFlushTimer) {
+                streamFlushTimer = setTimeout(flushStream, STREAM_THROTTLE_MS);
+            }
+        };
+        const onStreamEnd = (full) => {
+            if (streamFlushTimer) {
+                clearTimeout(streamFlushTimer);
+                streamFlushTimer = null;
+            }
+            if (streamStallTimer) {
+                clearTimeout(streamStallTimer);
+                streamStallTimer = null;
+            }
+            streamBuffer = '';
+            setStreamText('');
+            setReasoningText('');
+            if (full.trim()) {
+                add('assistant', full);
+            }
+        };
+        let reasoningBuffer = '';
+        let reasoningFlushTimer = null;
+        const onReasoning = (t) => {
+            reasoningBuffer = t;
+            if (!reasoningFlushTimer) {
+                reasoningFlushTimer = setTimeout(() => {
+                    reasoningFlushTimer = null;
+                    setReasoningText(reasoningBuffer);
+                }, STREAM_THROTTLE_MS);
+            }
+        };
+        const onToolCall = (name, args) => {
+            add('tool-call', typeof args === 'string' ? args : JSON.stringify(args), name);
+        };
+        const onToolResult = (name, result) => {
+            // Extract diff from write_file / edit_file results and show separately
+            let parsed = null;
+            if (typeof result === 'object' && result !== null) {
+                parsed = result;
+            }
+            else if (typeof result === 'string') {
+                try {
+                    parsed = JSON.parse(result);
+                }
+                catch {
+                    parsed = null;
+                }
+            }
+            if (parsed?.diff && typeof parsed.diff === 'string') {
+                // Strip ANSI codes from diff for clean display
+                const cleanDiff = parsed.diff.replace(/\x1b\[[0-9;]*m/g, '');
+                const fileName = parsed.message?.match(/to (.+)$|in (.+)$/)?.[1] || parsed.message?.match(/in (.+)$/)?.[1] || name;
+                add('diff', cleanDiff, fileName);
+                // Show the result summary without the diff
+                const { diff: _d, ...rest } = parsed;
+                const summary = rest.message || (rest.success ? 'Done' : 'Failed');
+                add('tool-result', summary, name);
+                return;
+            }
+            let text = typeof result === 'string' ? result : JSON.stringify(result);
+            const MAX_DISPLAY = 2000;
+            if (text.length > MAX_DISPLAY) {
+                const truncated = text.length - MAX_DISPLAY;
+                text = text.slice(0, MAX_DISPLAY) + `\n... (${truncated.toLocaleString()} chars hidden)`;
+            }
+            add('tool-result', text, name);
+        };
+        const onToolBlocked = (name, reason) => {
+            add('tool-blocked', `${name} denied: ${reason}`);
+        };
+        const onUsage = (data) => {
+            costTracker.record(data.model || modelsRef.current[0], data);
+            setTotalTokens(costTracker.totalTokens);
+        };
+        const onError = (err) => {
+            setIsLoading(false);
+            setStreamText('');
+            setReasoningText('');
+            setStatus('error');
+            setThinkStart(null);
+            const meta = err.metadata;
+            const reason = meta?.error?.message || err.message;
+            const model = meta?.model ? shortModel(meta.model) : '';
+            const msg = model ? `${reason} (${model})` : reason;
+            let hint;
+            const lower = reason?.toLowerCase() || '';
+            if (lower.includes('rate limit') || lower.includes('429')) {
+                hint = 'Rate limited. Try /model to switch models, or wait a moment.';
+            }
+            else if (lower.includes('auth') || lower.includes('401') || lower.includes('api key')) {
+                hint = 'Authentication failed. Run /setup to reconfigure your API key.';
+            }
+            else if (lower.includes('422') || lower.includes('unprocessable') || lower.includes('no body')) {
+                hint = 'Request rejected by the API. Check your model name is valid (/model), or run /setup to reconfigure.';
+            }
+            else if (lower.includes('timeout') || lower.includes('timed out')) {
+                hint = 'Request timed out. Try /compact to reduce context size, or try again.';
+            }
+            else if (lower.includes('context') || lower.includes('token')) {
+                hint = 'Context too large. Use /compact to compress the conversation.';
+            }
+            add('error', msg, undefined, hint);
+        };
+        const onContextCompress = (info) => {
+            add('system', `Context compressed: ${formatTokens(info.saved)} tokens saved (${formatTokens(info.before)} \u2192 ${formatTokens(info.after)})`);
+        };
+        const onContextUsage = (info) => {
+            if (info.percentage > 80) {
+                add('system', `Context usage: ${info.percentage}% (${formatTokens(info.tokens)}/${formatTokens(info.maxTokens)} tokens)`);
+            }
+        };
+        agent.on('thinking:start', onThinkingStart);
+        agent.on('thinking:end', onThinkingEnd);
+        agent.on('stream:delta', onDelta);
+        agent.on('stream:end', onStreamEnd);
+        agent.on('reasoning:update', onReasoning);
+        agent.on('tool:call', onToolCall);
+        agent.on('tool:result', onToolResult);
+        agent.on('tool:blocked', onToolBlocked);
+        agent.on('usage', onUsage);
+        agent.on('error', onError);
+        const onVerifyPass = (r) => { add('system', `\u2705 ${r.checker} passed (${r.durationMs}ms)`); };
+        const onVerifyFail = (r) => { add('error', `\u274C ${r.checker} failed: ${r.output.split('\n').slice(0, 5).join('\n')}`); };
+        const onFileModified = (f) => { add('system', `\u270F\uFE0F Modified: ${f}`); };
+        agent.on('verify:pass', onVerifyPass);
+        agent.on('verify:fail', onVerifyFail);
+        agent.on('file:modified', onFileModified);
+        agent.on('context:compress', onContextCompress);
+        agent.on('context:usage', onContextUsage);
+        const currentAgent = agent;
+        return () => {
+            if (streamFlushTimer)
+                clearTimeout(streamFlushTimer);
+            if (streamStallTimer)
+                clearTimeout(streamStallTimer);
+            if (reasoningFlushTimer)
+                clearTimeout(reasoningFlushTimer);
+            currentAgent.off('thinking:start', onThinkingStart);
+            currentAgent.off('thinking:end', onThinkingEnd);
+            currentAgent.off('stream:delta', onDelta);
+            currentAgent.off('stream:end', onStreamEnd);
+            currentAgent.off('reasoning:update', onReasoning);
+            currentAgent.off('tool:call', onToolCall);
+            currentAgent.off('tool:result', onToolResult);
+            currentAgent.off('tool:blocked', onToolBlocked);
+            currentAgent.off('usage', onUsage);
+            currentAgent.off('error', onError);
+            currentAgent.off('verify:pass', onVerifyPass);
+            currentAgent.off('verify:fail', onVerifyFail);
+            currentAgent.off('file:modified', onFileModified);
+            currentAgent.off('context:compress', onContextCompress);
+            currentAgent.off('context:usage', onContextUsage);
+        };
+    }, [add, agentVersion]);
+    // Confirmation bridge (event-driven)
+    useEffect(() => {
+        const onPending = () => {
+            if (pendingConfirm && !confirmInfo) {
+                setConfirmInfo({ toolName: pendingConfirm.toolName, args: pendingConfirm.args });
+            }
+        };
+        confirmEmitter.on('pending', onPending);
+        return () => { confirmEmitter.off('pending', onPending); };
+    }, [confirmInfo]);
+    useEffect(() => {
+        const banner = getUpdateBanner();
+        if (banner)
+            add('system', banner);
+    }, [add]);
+    const handleConfirm = useCallback((ok) => {
+        if (pendingConfirm) {
+            pendingConfirm.resolve(ok);
+            pendingConfirm = null;
+        }
+        setConfirmInfo(null);
+    }, []);
+    const handleCommand = useCallback((text) => {
+        const cmd = text.split(' ')[0].toLowerCase();
+        if (cmd === '/help') {
+            const helpLines = [
+                'Session & Navigation:',
+                '  /help         \u2014 show commands',
+                '  /shortcuts    \u2014 keyboard shortcuts',
+                '  /clear        \u2014 reset conversation',
+                '  /save [name]  \u2014 save current session',
+                '  /load         \u2014 resume a saved session',
+                '  /export [f]   \u2014 export conversation as text',
+                '  /exit         \u2014 save & exit',
+                '',
+                'Model & Mode:',
+                '  /models       \u2014 list active models',
+                '  /model        \u2014 switch model',
+                '  /mode [m]     \u2014 permission mode (plan/default/auto/yolo)',
+                '  /thinking [m] \u2014 thinking mode (off/low/medium/high)',
+                '  /plan         \u2014 enter plan mode (read-only)',
+                '',
+                'Context & Cost:',
+                '  /compact      \u2014 compress conversation context',
+                '  /context      \u2014 show context usage & token count',
+                '  /cost         \u2014 show token usage & cost',
+                '',
+                'Code & Git:',
+                '  /diff         \u2014 show uncommitted changes',
+                '  /commit       \u2014 auto-generate commit message & commit',
+                '  /review       \u2014 AI code review of current changes',
+                '  /checkpoint   \u2014 create git checkpoint',
+                '  /undo         \u2014 undo last checkpoint',
+                '  /checkpoints  \u2014 list recent checkpoints',
+                '  /git          \u2014 show git context',
+                '',
+                'Project:',
+                '  /init         \u2014 initialize project config (SCALIX.md)',
+                '  /index        \u2014 scan & index project files',
+                '  /memory       \u2014 show project memory',
+                '  /remember <n> \u2014 save a note about this project',
+                '  /watch <cmd>  \u2014 run command, auto-fix on failure',
+                '  /create <d>   \u2014 scaffold a new project',
+                '  /delegate <t> \u2014 run task with sub-agent',
+                '  /agents       \u2014 show active agents & usage',
+                '',
+                'Tools & Config:',
+                '  /copy         \u2014 copy last response to clipboard',
+                '  /status       \u2014 show version, model & connection info',
+                '  /update       \u2014 check for and install updates',
+                '  /doctor       \u2014 diagnose installation',
+                '  /settings     \u2014 view & configure limits',
+                '  /setup        \u2014 reconfigure API key, URL & models',
+                '  /mcp <l> <u>  \u2014 add MCP server',
+                '  /plugins      \u2014 show loaded plugins',
+                '  /router       \u2014 show model routing status',
+                '  /replay       \u2014 show session timeline',
+                '  /hooks        \u2014 show lifecycle hooks',
+                '  /commands     \u2014 show custom commands',
+                '',
+                'Input modes:',
+                '  !<cmd>        \u2014 run shell command (e.g. !ls -la)',
+                '  text\\         \u2014 multiline input (end with \\ to continue)',
+            ];
+            if (customCommands.length > 0) {
+                helpLines.push('', 'Custom commands:');
+                for (const c of customCommands)
+                    helpLines.push(`  /${c.name.padEnd(12)} \u2014 ${c.description}`);
+            }
+            helpLines.forEach((line) => add('system', line));
+            return true;
+        }
+        if (cmd === '/clear') {
+            agent.abort();
+            if (pendingConfirm) {
+                pendingConfirm.resolve(false);
+                pendingConfirm = null;
+            }
+            const msgs = agent.getMessages();
+            if (msgs.length > 0) {
+                saveSession(sessionId, msgs, models[0] || 'unknown', undefined, costTracker.getState()).then((meta) => {
+                    add('system', `Auto-saved: ${meta.name}`);
+                }).catch((err) => { logger.warn('Failed to auto-save session', { error: err.message }); });
+            }
+            agent.clearHistory();
+            setItems([]);
+            setIsLoading(false);
+            setStatus('ready');
+            setStreamText('');
+            setReasoningText('');
+            setThinkStart(null);
+            setConfirmInfo(null);
+            showBannerRef.current = true;
+            setShowBanner(true);
+            costTracker.reset();
+            setTotalTokens(0);
+            sessionId = generateSessionId();
+            return true;
+        }
+        if (cmd === '/models') {
+            add('system', `Active models: ${agent.getModels().map(shortModel).join(', ')}`);
+            return true;
+        }
+        if (cmd === '/model') {
+            setSelectingModel(true);
+            return true;
+        }
+        if (cmd === '/compact') {
+            const before = agent.getContextUsage();
+            add('system', `Compacting... (${before.tokens.toLocaleString()} tokens, ${before.percentage}% used)`);
+            setIsLoading(true);
+            setStatus('thinking');
+            setThinkStart(Date.now());
+            agent.compact().then((result) => {
+                const after = agent.getContextUsage();
+                add('system', result);
+                add('system', `Context: ${before.tokens.toLocaleString()} → ${after.tokens.toLocaleString()} tokens (saved ${(before.tokens - after.tokens).toLocaleString()})`);
+            }).catch((err) => {
+                add('error', `Compact failed: ${err.message}`);
+            }).finally(() => {
+                setIsLoading(false);
+                setStatus('ready');
+                setThinkStart(null);
+            });
+            return true;
+        }
+        if (cmd === '/cost') {
+            add('system', costTracker.summary());
+            return true;
+        }
+        if (cmd === '/save') {
+            const msgs = agent.getMessages();
+            if (msgs.length === 0) {
+                add('system', 'Nothing to save — conversation is empty.');
+                return true;
+            }
+            const explicit = text.slice(5).trim();
+            const rawContent = msgs.find((m) => m.role === 'user')?.content;
+            const firstUserMsg = messageContentToString(rawContent);
+            const autoName = firstUserMsg.slice(0, 50).replace(/\n/g, ' ').trim();
+            const name = explicit || autoName || undefined;
+            saveSession(sessionId, msgs, models[0] || 'unknown', name, costTracker.getState()).then((meta) => {
+                add('system', `Session saved: ${meta.name} (${meta.messageCount} messages)`);
+            }).catch((err) => {
+                add('error', `Failed to save session: ${err.message}`);
+            });
+            return true;
+        }
+        if (cmd === '/load') {
+            listSessions().then((sessions) => {
+                if (sessions.length === 0) {
+                    add('system', 'No saved sessions found.');
+                }
+                else {
+                    setSessionList(sessions);
+                }
+            });
+            return true;
+        }
+        if (cmd === '/shortcuts') {
+            const shortcuts = [
+                'Ctrl+C \u2014 interrupt agent / clear input / double-press to quit',
+                'Ctrl+D \u2014 exit (when input is empty)',
+                'Ctrl+L \u2014 clear screen & conversation',
+                'Ctrl+U \u2014 clear entire input line',
+                'Ctrl+W \u2014 delete last word',
+                'Ctrl+K \u2014 delete to end of line',
+                'Ctrl+S \u2014 stash / restore current prompt',
+                'Tab \u2014 autocomplete slash commands',
+                '\u2191/\u2193 \u2014 navigate input history',
+                'Shift+\u2191 / PageUp \u2014 scroll chat up',
+                'Shift+\u2193 / PageDown \u2014 scroll chat down',
+                'Y/N \u2014 confirm or deny tool execution',
+                'Esc \u2014 quit',
+                '',
+                'Copy \u2014 Cmd+C (Mac) / Ctrl+Shift+C (Linux)',
+                'Paste \u2014 Cmd+V (Mac) / Ctrl+Shift+V (Linux)',
+                '',
+                '!<cmd> \u2014 run shell command directly',
+                'text\\ \u2014 continue on next line (multiline mode, 50-line max)',
+            ];
+            shortcuts.forEach((s) => add('system', s));
+            return true;
+        }
+        if (cmd === '/settings') {
+            setEditingSettings(true);
+            return true;
+        }
+        if (cmd === '/setup') {
+            setShowSetup(true);
+            return true;
+        }
+        if (cmd === '/mode') {
+            const arg = text.split(' ')[1]?.toLowerCase();
+            if (arg && PERMISSION_MODES.includes(arg)) {
+                agent.setPermissionMode(arg);
+                setCurrentMode(arg);
+                loadConfig().then(cfg => {
+                    cfg.permissionMode = arg;
+                    saveConfig(cfg);
+                }).catch((err) => { logger.warn('Failed to save config', { error: err.message }); });
+                add('system', `Mode: ${arg.toUpperCase()} \u2014 ${getModeDescription(arg)}`);
+            }
+            else {
+                setSelectingMode(true);
+            }
+            return true;
+        }
+        if (cmd === '/thinking') {
+            const arg = text.split(' ')[1]?.toLowerCase();
+            if (arg && THINKING_MODES.includes(arg)) {
+                agent.setThinking(arg);
+                loadConfig().then(cfg => {
+                    cfg.thinkingMode = arg;
+                    saveConfig(cfg);
+                }).catch((err) => { logger.warn('Failed to save config', { error: err.message }); });
+                add('system', `Thinking: ${arg.toUpperCase()}${arg === 'off' ? '' : ' \u2014 model will reason before responding'}`);
+            }
+            else {
+                add('system', `Thinking mode: ${agent.getThinking().toUpperCase()}\nUsage: /thinking <off|low|medium|high>`);
+            }
+            return true;
+        }
+        if (cmd === '/mcp') {
+            const p = text.split(' ').filter(Boolean);
+            if (p.length < 3) {
+                add('system', 'Usage: /mcp <label> <url>');
+                return true;
+            }
+            {
+                try {
+                    new URL(p[2]);
+                }
+                catch {
+                    add('error', `Invalid URL: ${p[2]}`);
+                    return true;
+                }
+                agent.addTool({ type: 'mcp', serverLabel: p[1], serverUrl: p[2] });
+                add('system', `MCP registered: ${p[1]} \u2192 ${p[2]}`);
+            }
+            return true;
+        }
+        if (cmd === '/index') {
+            setIsLoading(true);
+            setStatus('thinking');
+            setThinkStart(Date.now());
+            buildProjectIndex(process.cwd()).then((idx) => {
+                projectIndex = idx;
+                add('system', idx.summary);
+                add('system', `Tech stack: ${idx.techStack.join(', ') || 'Unknown'}`);
+                add('system', `Top symbols: ${idx.symbols.slice(0, 10).map((s) => s.name).join(', ')}`);
+            }).catch((err) => {
+                add('error', `Index failed: ${err.message}`);
+            }).finally(() => {
+                setIsLoading(false);
+                setStatus('ready');
+                setThinkStart(null);
+            });
+            return true;
+        }
+        if (cmd === '/git') {
+            collectGitInfo(process.cwd()).then((gitInfo) => {
+                if (!gitInfo.isRepo) {
+                    add('system', 'Not a git repository.');
+                }
+                else {
+                    const lines = gitInfoToContext(gitInfo).split('\n');
+                    lines.forEach((l) => add('system', l));
+                }
+            }).catch(() => { add('system', 'Failed to collect git info.'); });
+            return true;
+        }
+        if (cmd === '/plugins') {
+            add('system', pluginsSummary(loadedPlugins));
+            return true;
+        }
+        if (cmd === '/replay') {
+            const replay = agent.getReplay();
+            const timeline = replay.getTimeline();
+            const lines = timeline.split('\n');
+            lines.forEach((l) => add('system', l));
+            return true;
+        }
+        if (cmd === '/remember') {
+            const note = text.slice(10).trim();
+            if (!note) {
+                add('system', 'Usage: /remember <note about this project>');
+            }
+            else {
+                addNote(process.cwd(), note).then(() => {
+                    add('system', `Remembered: ${note}`);
+                }).catch(() => {
+                    add('system', 'Failed to save note.');
+                });
+            }
+            return true;
+        }
+        if (cmd === '/memory') {
+            loadMemory(process.cwd()).then((mem) => {
+                if (mem.conventions.length === 0 && mem.patterns.length === 0 && mem.notes.length === 0) {
+                    add('system', 'No project memory yet. Use /remember to add notes.');
+                }
+                else {
+                    const lines = memoryToContext(mem).split('\n');
+                    lines.forEach((l) => add('system', l));
+                }
+            }).catch(() => {
+                add('error', 'Failed to load project memory.');
+            });
+            return true;
+        }
+        if (cmd === '/router') {
+            const routerConfig = createRouterConfig(models);
+            const lines = getRouterStatus(routerConfig).split('\n');
+            lines.forEach((l) => add('system', l));
+            return true;
+        }
+        if (cmd === '/hooks') {
+            const hooks = agent.getHooks();
+            hooksSummary(hooks).split('\n').forEach((l) => add('system', l));
+            return true;
+        }
+        if (cmd === '/commands') {
+            commandsSummary(customCommands).split('\n').forEach((l) => add('system', l));
+            return true;
+        }
+        if (cmd === '/delegate') {
+            const prompt = text.slice(10).trim();
+            if (!prompt) {
+                add('system', 'Usage: /delegate <task description>');
+                return true;
+            }
+            setIsLoading(true);
+            setStatus('thinking');
+            setThinkStart(Date.now());
+            const cheapModel = pickCheapestModel(agent.getModels());
+            add('system', `Delegating to sub-agent (${shortModel(cheapModel)})...`);
+            spawnSubAgent({ apiKey: agent.getApiKey(), baseUrl: agent.getBaseUrl(), models: agent.getModels() }, prompt, { model: cheapModel, tools: 'read-only', maxSteps: 10 }).then((result) => {
+                add('assistant', result.response);
+                add('system', `Sub-agent: ${result.steps} steps, ~${formatTokens(result.tokenEstimate)} tokens (${shortModel(result.model)})`);
+            }).catch((err) => {
+                add('error', `Sub-agent failed: ${err.message}`);
+            }).finally(() => {
+                setIsLoading(false);
+                setStatus('ready');
+                setThinkStart(null);
+            });
+            return true;
+        }
+        if (cmd === '/agents') {
+            const registry = AgentRegistry.getInstance();
+            const summary = registry.getUsageSummary();
+            const tree = registry.getAgentTree();
+            const lines = [
+                `Active: ${summary.activeCount} | Completed: ${summary.completedCount} | Failed: ${summary.failedCount}`,
+                `Total tokens: ${summary.totalTokens.toLocaleString()}`,
+            ];
+            if (tree && tree !== '(no agents)') {
+                lines.push('', 'Agent tree:', tree);
+            }
+            else {
+                lines.push('', 'No agents have been spawned yet.');
+            }
+            lines.forEach(l => add('system', l));
+            return true;
+        }
+        if (cmd === '/checkpoint') {
+            const label = text.slice(12).trim() || undefined;
+            createCheckpoint(process.cwd(), label).then((hash) => {
+                if (hash)
+                    add('system', `Checkpoint created: ${hash}${label ? ` (${label})` : ''}`);
+                else
+                    add('system', 'No changes to checkpoint (or not a git repo).');
+            }).catch((err) => add('error', `Checkpoint failed: ${err.message}`));
+            return true;
+        }
+        if (cmd === '/undo') {
+            undoLastCheckpoint(process.cwd()).then((r) => {
+                add(r.success ? 'system' : 'error', r.message);
+            }).catch((err) => add('error', `Undo failed: ${err.message}`));
+            return true;
+        }
+        if (cmd === '/checkpoints') {
+            listCheckpoints(process.cwd()).then((list) => {
+                if (list.length === 0)
+                    add('system', 'No checkpoints found.');
+                else {
+                    add('system', 'Recent checkpoints:');
+                    list.forEach((l) => add('system', `  ${l}`));
+                }
+            }).catch(() => add('error', 'Failed to list checkpoints.'));
+            return true;
+        }
+        if (cmd === '/commit') {
+            setIsLoading(true);
+            setStatus('thinking');
+            setThinkStart(Date.now());
+            add('system', 'Generating commit...');
+            (async () => {
+                try {
+                    // Check for staged changes
+                    let diff = '';
+                    try {
+                        diff = execSync('git diff --staged', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                    }
+                    catch { }
+                    if (!diff) {
+                        // Nothing staged — stage tracked files only (safer than -A)
+                        try {
+                            execSync('git add -u', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() });
+                            diff = execSync('git diff --staged', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                        }
+                        catch (e) {
+                            add('error', `Failed to stage files: ${e.message}`);
+                            return;
+                        }
+                    }
+                    if (!diff) {
+                        add('system', 'No changes to commit.');
+                        return;
+                    }
+                    // Send diff to agent to generate commit message
+                    const truncatedDiff = diff.length > 8000 ? diff.slice(0, 8000) + '\n... (diff truncated)' : diff;
+                    const commitMsg = await agent.send(`Generate a concise git commit message for these changes. Just output the commit message, nothing else. No quotes, no backticks, no explanation.\n\n${truncatedDiff}`);
+                    const cleanMsg = commitMsg.trim().replace(/^["'`]+|["'`]+$/g, '');
+                    if (!cleanMsg) {
+                        add('error', 'Agent returned empty commit message.');
+                        return;
+                    }
+                    add('system', `Commit message: ${cleanMsg}`);
+                    try {
+                        const result = execFileSync('git', ['commit', '-m', cleanMsg], { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                        add('system', result);
+                    }
+                    catch (e) {
+                        add('error', `Commit failed: ${e.stderr?.trim() || e.message}`);
+                    }
+                }
+                catch (e) {
+                    add('error', e.message || 'Commit failed');
+                }
+                finally {
+                    setIsLoading(false);
+                    setStatus('ready');
+                    setThinkStart(null);
+                }
+            })();
+            return true;
+        }
+        if (cmd === '/review') {
+            setIsLoading(true);
+            setStatus('thinking');
+            setThinkStart(Date.now());
+            add('system', 'Running code review...');
+            (async () => {
+                try {
+                    let diff = '';
+                    let baseBranch = 'main';
+                    try {
+                        baseBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim().replace('refs/remotes/origin/', '');
+                    }
+                    catch {
+                        try {
+                            const branches = execSync('git branch --list main master', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                            if (branches.includes('master'))
+                                baseBranch = 'master';
+                        }
+                        catch { }
+                    }
+                    try {
+                        diff = execSync(`git diff ${baseBranch}...HEAD`, { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                    }
+                    catch { }
+                    if (!diff) {
+                        try {
+                            diff = execSync('git diff', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                        }
+                        catch { }
+                    }
+                    if (!diff) {
+                        add('system', 'No changes to review.');
+                        return;
+                    }
+                    const truncatedDiff = diff.length > 15000 ? diff.slice(0, 15000) + '\n... (diff truncated)' : diff;
+                    await agent.send(`Review this code diff. Point out bugs, security issues, performance problems, and suggest improvements. Be specific with file names and line numbers.\n\n${truncatedDiff}`);
+                }
+                catch (e) {
+                    add('error', e.message || 'Review failed');
+                }
+                finally {
+                    setIsLoading(false);
+                    setStatus('ready');
+                    setThinkStart(null);
+                }
+            })();
+            return true;
+        }
+        if (cmd === '/watch') {
+            const watchCmd = text.slice(7).trim();
+            if (!watchCmd) {
+                add('system', 'Usage: /watch <command> — runs the command, and if it fails, sends the error to the agent for auto-fix');
+                return true;
+            }
+            setIsLoading(true);
+            setStatus('thinking');
+            setThinkStart(Date.now());
+            add('system', `Watch: running "${watchCmd}"...`);
+            (async () => {
+                const MAX_RETRIES = 5;
+                for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+                    try {
+                        const output = execSync(watchCmd, { encoding: 'utf-8', timeout: TOOL_DEFAULTS.maxCommandTimeoutMs, cwd: process.cwd() }).trim();
+                        if (output)
+                            add('system', output.length > 2000 ? output.slice(0, 2000) + '\n... (truncated)' : output);
+                        add('system', `Watch: command succeeded on attempt ${attempt}.`);
+                        break;
+                    }
+                    catch (err) {
+                        const errorOutput = (err.stderr?.trim() || '') + '\n' + (err.stdout?.trim() || '');
+                        add('error', `Attempt ${attempt}/${MAX_RETRIES} failed:\n${errorOutput.trim().slice(0, 1000)}`);
+                        if (attempt >= MAX_RETRIES) {
+                            add('system', 'Watch: max retries reached. Giving up.');
+                            break;
+                        }
+                        add('system', `Watch: sending error to agent for auto-fix (attempt ${attempt})...`);
+                        try {
+                            await agent.send(`The command "${watchCmd}" failed with this error. Please read the relevant files, analyze the error, and fix the issue:\n\n${errorOutput.trim().slice(0, 4000)}`);
+                        }
+                        catch (agentErr) {
+                            add('error', `Agent fix attempt failed: ${agentErr.message}`);
+                            break;
+                        }
+                    }
+                }
+                setIsLoading(false);
+                setStatus('ready');
+                setThinkStart(null);
+            })();
+            return true;
+        }
+        if (cmd === '/create') {
+            const description = text.slice(8).trim();
+            if (!description) {
+                add('system', 'Usage: /create <project description>');
+                return true;
+            }
+            setIsLoading(true);
+            setStatus('thinking');
+            setThinkStart(Date.now());
+            agent.send(`Create a new project based on this description: ${description}. Set up the project structure, install dependencies, and create initial files. Use best practices for the tech stack.`).then((result) => {
+                if (!result?.trim())
+                    add('system', 'Agent returned no response.');
+            }).catch((err) => {
+                add('error', err.message || 'Create failed');
+            }).finally(() => {
+                setIsLoading(false);
+                setStatus('ready');
+                setThinkStart(null);
+            });
+            return true;
+        }
+        if (cmd === '/diff') {
+            try {
+                let diff = '';
+                try {
+                    diff = execSync('git diff', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                }
+                catch { }
+                let staged = '';
+                try {
+                    staged = execSync('git diff --staged', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                }
+                catch { }
+                if (staged)
+                    diff = (diff ? diff + '\n' : '') + '--- Staged changes ---\n' + staged;
+                if (!diff) {
+                    add('system', 'No uncommitted changes.');
+                }
+                else {
+                    const truncated = diff.length > 5000 ? diff.slice(0, 5000) + '\n... (truncated, full diff is ' + diff.length + ' chars)' : diff;
+                    truncated.split('\n').forEach((l) => add('system', l));
+                }
+            }
+            catch (e) {
+                add('error', `Failed to get diff: ${e.message}`);
+            }
+            return true;
+        }
+        if (cmd === '/copy') {
+            const msgs = agent.getMessages();
+            const assistantMsgs = msgs.filter((m) => m.role === 'assistant' && m.content);
+            if (assistantMsgs.length === 0) {
+                add('system', 'No assistant responses to copy.');
+            }
+            else {
+                const rawResponse = assistantMsgs[assistantMsgs.length - 1].content || '';
+                const lastResponse = messageContentToString(rawResponse);
+                try {
+                    if (process.platform === 'darwin') {
+                        execSync('pbcopy', { input: lastResponse, timeout: 3000 });
+                    }
+                    else if (process.platform === 'linux') {
+                        const isWSL = existsSync('/proc/version') && readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft');
+                        if (isWSL) {
+                            execSync('clip.exe', { input: lastResponse, timeout: 3000 });
+                        }
+                        else {
+                            try {
+                                execSync('xclip -selection clipboard', { input: lastResponse, timeout: 3000 });
+                            }
+                            catch {
+                                execSync('xsel --clipboard --input', { input: lastResponse, timeout: 3000 });
+                            }
+                        }
+                    }
+                    else {
+                        execSync('clip', { input: lastResponse, timeout: 3000 });
+                    }
+                    add('system', `Copied last response to clipboard (${lastResponse.length} chars).`);
+                }
+                catch {
+                    add('error', 'Failed to copy to clipboard. Clipboard tool not available.');
+                }
+            }
+            return true;
+        }
+        if (cmd === '/status') {
+            const mode = agent.getPermissionMode();
+            const modelsStr = agent.getModels().map(shortModel).join(', ');
+            const baseUrl = agent.getBaseUrl() || 'default';
+            const ctx = agent.getContextUsage();
+            const msgCount = agent.getMessages().length;
+            add('system', `${PRODUCT_NAME} v${VERSION}`);
+            add('system', `Model: ${modelsStr}`);
+            add('system', `API: ${baseUrl}`);
+            add('system', `Mode: ${mode}`);
+            add('system', `Context: ${ctx.percentage}% (${formatTokens(ctx.tokens)} / ${formatTokens(ctx.maxTokens)})`);
+            add('system', `Messages: ${msgCount}`);
+            add('system', `Session: ${sessionId}`);
+            add('system', `CWD: ${process.cwd()}`);
+            const updateBanner = getUpdateBanner();
+            if (updateBanner)
+                add('system', updateBanner);
+            return true;
+        }
+        if (cmd === '/update') {
+            add('system', 'Checking for updates...');
+            checkForUpdate().then((info) => {
+                if (info && info.updateAvailable) {
+                    add('system', `New version available: ${info.current} → ${info.latest}`);
+                    add('system', 'Installing update...');
+                    performUpdate().then(({ success, output }) => {
+                        if (success) {
+                            add('system', `Updated successfully. Restart Scalix to use v${info.latest}.`);
+                        }
+                        else {
+                            add('system', `Update failed: ${output}\nTry manually: npm install -g scalix@latest`);
+                        }
+                    });
+                }
+                else {
+                    add('system', `Scalix v${VERSION} is up to date.`);
+                }
+            }).catch(() => {
+                add('system', 'Failed to check for updates. Try: npm install -g scalix@latest');
+            });
+            return true;
+        }
+        if (cmd === '/context') {
+            const ctx = agent.getContextUsage();
+            const pct = Math.min(ctx.percentage, 100);
+            const filled = Math.round(pct / 5);
+            const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(20 - filled);
+            add('system', `Context usage: [${bar}] ${ctx.percentage}%`);
+            add('system', `Tokens: ${formatTokens(ctx.tokens)} / ${formatTokens(ctx.maxTokens)}`);
+            add('system', `Messages: ${agent.getMessages().length}`);
+            if (pct > 80)
+                add('system', 'Tip: Use /compact to free up context space.');
+            else if (pct > 50)
+                add('system', 'Context is healthy. /compact available if needed.');
+            return true;
+        }
+        if (cmd === '/init') {
+            const configPath = path.join(process.cwd(), 'SCALIX.md');
+            (async () => {
+                try {
+                    const exists = await fs.access(configPath).then(() => true).catch(() => false);
+                    if (exists) {
+                        add('system', 'SCALIX.md already exists in this directory.');
+                        return;
+                    }
+                    setIsLoading(true);
+                    setStatus('thinking');
+                    setThinkStart(Date.now());
+                    const response = await agent.send('Analyze this project directory and generate a SCALIX.md file. Include: project description, tech stack, build/test commands, coding conventions, and any important architectural decisions. Format as markdown. Just output the file content, nothing else.');
+                    if (response?.trim()) {
+                        await fs.writeFile(configPath, response.trim() + '\n', 'utf-8');
+                        add('system', `Created SCALIX.md (${response.length} chars). This will be loaded as project context.`);
+                    }
+                }
+                catch (e) {
+                    add('error', `Init failed: ${e.message}`);
+                }
+                finally {
+                    setIsLoading(false);
+                    setStatus('ready');
+                    setThinkStart(null);
+                }
+            })();
+            return true;
+        }
+        if (cmd === '/exit' || cmd === '/quit') {
+            const msgs = agent.getMessages();
+            if (msgs.length > 0) {
+                saveSession(sessionId, msgs, models[0] || 'unknown', undefined, costTracker.getState()).catch((err) => { logger.warn('Failed to save session on exit', { error: err.message }); }).finally(() => process.exit(0));
+            }
+            else {
+                process.exit(0);
+            }
+            return true;
+        }
+        if (cmd === '/plan') {
+            agent.setPermissionMode('plan');
+            setCurrentMode('plan');
+            loadConfig().then(cfg => {
+                cfg.permissionMode = 'plan';
+                saveConfig(cfg);
+            }).catch((err) => { logger.warn('Failed to save config', { error: err.message }); });
+            add('system', `Mode: PLAN — ${getModeDescription('plan')}`);
+            return true;
+        }
+        if (cmd === '/export') {
+            const msgs = agent.getMessages();
+            if (msgs.length === 0) {
+                add('system', 'No conversation to export.');
+                return true;
+            }
+            const filename = text.split(' ')[1]?.trim() || `scalix-export-${new Date().toISOString().slice(0, 10)}.txt`;
+            const lines = [];
+            for (const m of msgs) {
+                if (m.role === 'system')
+                    continue;
+                const prefix = m.role === 'user' ? 'You' : m.role === 'assistant' ? 'Assistant' : m.role === 'tool' ? `Tool(${m.name || 'unknown'})` : m.role;
+                if (m.content)
+                    lines.push(`[${prefix}]\n${messageContentToString(m.content)}\n`);
+                if (m.tool_calls) {
+                    for (const tc of m.tool_calls) {
+                        lines.push(`[Tool Call: ${tc.function.name}]\n${tc.function.arguments}\n`);
+                    }
+                }
+            }
+            const exportPath = path.join(process.cwd(), filename);
+            fs.writeFile(exportPath, lines.join('\n'), 'utf-8').then(() => {
+                add('system', `Exported ${msgs.length} messages to ${filename}`);
+            }).catch((e) => {
+                add('error', `Export failed: ${e.message}`);
+            });
+            return true;
+        }
+        if (cmd === '/doctor') {
+            add('system', `${PRODUCT_NAME} v${VERSION} — Diagnostics`);
+            add('system', `Platform: ${process.platform} (${process.arch})`);
+            add('system', `Node: ${process.version}`);
+            add('system', `CWD: ${process.cwd()}`);
+            // Check git
+            try {
+                const gitVersion = execSync('git --version', { encoding: 'utf-8', timeout: 3000 }).trim();
+                add('system', `Git: ${gitVersion}`);
+            }
+            catch {
+                add('error', 'Git: not found');
+            }
+            // Check API connectivity
+            add('system', `API Base: ${agent.getBaseUrl() || DEFAULT_BASE_URL}`);
+            add('system', `API Key: ${agent.getApiKey() ? '****' + agent.getApiKey().slice(-4) : 'NOT SET'}`);
+            add('system', `Models: ${agent.getModels().map(shortModel).join(', ')}`);
+            add('system', `Mode: ${agent.getPermissionMode()}`);
+            // Check config
+            loadConfig().then(cfg => {
+                add('system', `Config: ${cfg.apiKey ? 'configured' : 'not configured'}`);
+            }).catch(() => {
+                add('error', 'Config: failed to load');
+            });
+            return true;
+        }
+        const customCmd = customCommands.find((c) => cmd === `/${c.name}`);
+        if (customCmd) {
+            const args = text.slice(cmd.length).trim();
+            const expanded = expandCommand(customCmd, args);
+            add('system', `Running custom command: /${customCmd.name}`);
+            setIsLoading(true);
+            setStatus('thinking');
+            setThinkStart(Date.now());
+            agent.send(expanded).then((result) => {
+                if (!result?.trim())
+                    add('system', 'Agent returned no response.');
+            }).catch((err) => {
+                add('error', err.message || 'Unknown error');
+            }).finally(() => {
+                setIsLoading(false);
+                setStatus('ready');
+                setThinkStart(null);
+            });
+            return true;
+        }
+        return false;
+    }, [add, models]);
+    // Use a ref for isLoading to avoid stale closures in handleSubmit
+    const isLoadingRef = useRef(false);
+    useEffect(() => { isLoadingRef.current = isLoading; }, [isLoading]);
+    const multilineRef = useRef([]);
+    const messageQueueRef = useRef([]);
+    const handleSubmit = useCallback(async (text) => {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return;
+        // Allow /mode even while the agent is working
+        if (isLoadingRef.current && trimmed.startsWith('/mode')) {
+            handleCommand(trimmed);
+            return;
+        }
+        // Queue messages while agent is working
+        if (isLoadingRef.current) {
+            messageQueueRef.current.push(trimmed);
+            add('system', `Queued (${messageQueueRef.current.length}): ${truncate(trimmed, 60)}`);
+            return;
+        }
+        if (trimmed.endsWith('\\')) {
+            if (multilineRef.current.length >= 50) {
+                add('system', 'Multiline limit reached (50 lines). Sending now.');
+            }
+            else {
+                multilineRef.current.push(trimmed.slice(0, -1));
+                add('system', '... (continue typing, submit without \\ to send)');
+                return;
+            }
+        }
+        let finalText;
+        if (multilineRef.current.length > 0) {
+            multilineRef.current.push(trimmed);
+            finalText = multilineRef.current.join('\n');
+            multilineRef.current = [];
+        }
+        else {
+            finalText = trimmed;
+        }
+        if (finalText.startsWith('/') && handleCommand(finalText))
+            return;
+        if (finalText.startsWith('!')) {
+            const shellCmd = finalText.slice(1).trim();
+            if (!shellCmd)
+                return;
+            add('system', `$ ${shellCmd}`);
+            try {
+                let output = execSync(shellCmd, { encoding: 'utf-8', timeout: HEADLESS_DEFAULTS.commandTimeoutMs, cwd: process.cwd() }).trim();
+                if (output) {
+                    if (output.length > 2000) {
+                        output = output.slice(0, 2000) + `\n... (${(output.length - 2000).toLocaleString()} chars truncated)`;
+                    }
+                    add('system', output);
+                }
+            }
+            catch (err) {
+                add('error', err.stderr?.trim() || err.message);
+            }
+            return;
+        }
+        const correction = detectCorrection(finalText);
+        if (correction) {
+            addNote(process.cwd(), `[correction] ${correction}`).catch((err) => { logger.warn('Failed to save correction note', { error: err.message }); });
+        }
+        add('user', finalText);
+        setIsLoading(true);
+        setStatus('thinking');
+        setThinkStart(Date.now());
+        try {
+            const result = await agent.send(finalText);
+            if (!result || !result.trim()) {
+                add('system', 'Agent returned no response.');
+            }
+        }
+        catch (e) {
+            add('error', e.message || 'Unknown error');
+        }
+        finally {
+            // Process queued messages sequentially
+            while (messageQueueRef.current.length > 0) {
+                const next = messageQueueRef.current.shift();
+                const remaining = messageQueueRef.current.length;
+                if (remaining > 0)
+                    add('system', `${remaining} more queued`);
+                add('user', next);
+                setStatus('thinking');
+                setThinkStart(Date.now());
+                try {
+                    const qResult = await agent.send(next);
+                    if (!qResult || !qResult.trim())
+                        add('system', 'Agent returned no response.');
+                }
+                catch (e) {
+                    add('error', e.message || 'Unknown error');
+                }
+            }
+            setIsLoading(false);
+            setStatus('ready');
+            setThinkStart(null);
+        }
+    }, [add, handleCommand]);
+    const handleSessionSelect = useCallback((session) => {
+        setSessionList(null);
+        setIsLoading(true);
+        setStatus('thinking');
+        setThinkStart(Date.now());
+        loadSession(session.id).then((data) => {
+            agent.loadMessages(data.messages);
+            sessionId = session.id;
+            setModels([session.model]);
+            agent.setModel(session.model);
+            if (data.costState) {
+                costTracker.restore(data.costState);
+                setTotalTokens(data.costState.totalTokens);
+            }
+            setItems([]);
+            showBannerRef.current = false;
+            setShowBanner(false);
+            for (const msg of data.messages) {
+                const text = messageContentToString(msg.content);
+                if (msg.role === 'user' && text)
+                    add('user', text);
+                else if (msg.role === 'assistant' && text)
+                    add('assistant', text);
+            }
+            add('system', `Resumed: ${session.name} (${session.messageCount} messages)`);
+        }).catch(() => {
+            add('error', 'Failed to load session.');
+        }).finally(() => {
+            setIsLoading(false);
+            setStatus('ready');
+            setThinkStart(null);
+        });
+    }, [add]);
+    const handleAbort = useCallback(() => {
+        agent.abort();
+        if (pendingConfirm) {
+            pendingConfirm.resolve(false);
+            pendingConfirm = null;
+        }
+        setConfirmInfo(null);
+        setIsLoading(false);
+        setStatus('ready');
+        setStreamText('');
+        setReasoningText('');
+        setThinkStart(null);
+        add('system', 'Interrupted.');
+    }, [add]);
+    const handleClearScreen = useCallback(() => {
+        const msgs = agent.getMessages();
+        if (msgs.length > 0) {
+            saveSession(sessionId, msgs, models[0] || 'unknown', undefined, costTracker.getState()).catch((err) => { logger.warn('Failed to save session on clear', { error: err.message }); });
+        }
+        agent.clearHistory();
+        setItems([]);
+        showBannerRef.current = true;
+        setShowBanner(true);
+        costTracker.reset();
+        setTotalTokens(0);
+        sessionId = generateSessionId();
+    }, [models]);
+    const handleSetupDone = useCallback((newConfig) => {
+        setShowSetup(false);
+        try {
+            initAgent(newConfig);
+            setModels(agent.getModels());
+            setAgentVersion(v => v + 1);
+            add('system', 'Configuration updated. Agent reinitialized.');
+        }
+        catch (err) {
+            add('error', `Failed to reinitialize: ${err.message}`);
+        }
+    }, [add]);
+    const [inputSectionHeight, setInputSectionHeight] = useState(3);
+    const handleInputHeightChange = useCallback((h) => setInputSectionHeight(h), []);
+    const bannerHeight = showBanner ? 5 : 0;
+    const statusBarHeight = 1;
+    const bottomHeight = useMemo(() => {
+        if (confirmInfo) {
+            let parsed = {};
+            try {
+                parsed = typeof confirmInfo.args === 'string' ? JSON.parse(confirmInfo.args) : confirmInfo.args ?? {};
+            }
+            catch {
+                parsed = {};
+            }
+            const extraCount = Math.min(Object.keys(parsed).filter(k => !['command', 'filePath', 'file_path', 'notebook_path', 'message', 'content'].includes(k)).length, 3);
+            const hasHighlight = !!(parsed.command ?? parsed.filePath ?? parsed.file_path ?? parsed.notebook_path ?? parsed.message);
+            return 5 + (hasHighlight ? 1 : 0) + extraCount;
+        }
+        if (selectingModel)
+            return 6 + Math.min(models.length + 2, 12);
+        if (selectingMode)
+            return 5 + PERMISSION_MODES.length + 1;
+        if (editingSettings)
+            return Math.min(rows - 8, 42);
+        if (sessionList)
+            return 5 + Math.min((sessionList?.length ?? 0) + 1, 12);
+        return inputSectionHeight;
+    }, [confirmInfo, selectingModel, selectingMode, editingSettings, sessionList, models.length, rows, inputSectionHeight]);
+    const chromeHeight = bannerHeight + statusBarHeight + bottomHeight;
+    const chatHeight = Math.max(rows - chromeHeight, 6);
+    const streamLineCount = useMemo(() => {
+        if (!isLoading)
+            return 0;
+        const textLines = streamText ? (streamText.match(/\n/g) || []).length + 1 : 0;
+        const reasonLines = reasoningText ? (reasoningText.match(/\n/g) || []).length + 1 : 0;
+        return textLines + reasonLines;
+    }, [isLoading, streamText, reasoningText]);
+    const { visibleItems, scrollUp, scrollDown, scrollToBottom, isAtBottom, } = useScrollableItems(items, chatHeight, cols, isLoading, streamLineCount);
+    const scrollToBottomRef = useRef(scrollToBottom);
+    scrollToBottomRef.current = scrollToBottom;
+    const handleSubmitRef = useRef(handleSubmit);
+    handleSubmitRef.current = handleSubmit;
+    const handleInputSubmit = useCallback((v) => {
+        scrollToBottomRef.current();
+        handleSubmitRef.current(v);
+    }, []);
+    if (showSetup) {
+        return _jsx(SetupScreen, { onComplete: handleSetupDone, existingConfig: config });
+    }
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: rows, children: [showBanner && _jsx(Banner, {}), _jsx(StatusBar, { status: status, model: models[0] || 'no model', toolCount: allTools.length + pluginTools.length, thinkStart: thinkStart, tokens: totalTokens, mode: currentMode }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 6, overflowY: "hidden", children: [showBanner && !isLoading && _jsx(WelcomeScreen, {}), visibleItems.map((item) => _jsx(RenderItem, { item: item }, item.id)), isLoading && _jsx(StreamingArea, { text: streamText, reasoning: reasoningText, model: shortModel(models[0] || '') }), !isAtBottom && (_jsx(Box, { justifyContent: "center", children: _jsxs(Text, { dimColor: true, children: [" ", '\u2193', " more below ", '\u2014', " Shift+Down "] }) }))] }), _jsx(Box, { flexShrink: 0, flexDirection: "column", children: confirmInfo ? (_jsx(ConfirmPrompt, { toolName: confirmInfo.toolName, args: confirmInfo.args, onRespond: handleConfirm, onScrollUp: scrollUp, onScrollDown: scrollDown })) : selectingModel ? (_jsx(ModelPicker, { currentModels: models, onSelect: (v) => {
+                        agent.setModel(v);
+                        setModels([v]);
+                        setSelectingModel(false);
+                        loadConfig().then(cfg => {
+                            cfg.models = [v];
+                            saveConfig(cfg);
+                        }).catch((err) => { logger.warn('Failed to save config', { error: err.message }); });
+                        add('system', `Model switched to ${shortModel(v)}`);
+                    }, onCancel: () => setSelectingModel(false) })) : selectingMode ? (_jsx(ModePicker, { currentMode: currentMode, onSelect: (mode) => {
+                        agent.setPermissionMode(mode);
+                        setCurrentMode(mode);
+                        setSelectingMode(false);
+                        loadConfig().then(cfg => {
+                            cfg.permissionMode = mode;
+                            saveConfig(cfg);
+                        }).catch((err) => { logger.warn('Failed to save config', { error: err.message }); });
+                        add('system', `Mode: ${mode.toUpperCase()} \u2014 ${getModeDescription(mode)}`);
+                    }, onCancel: () => setSelectingMode(false) })) : editingSettings ? (_jsx(SettingsEditor, { onSave: (key, value) => {
+                        loadConfig().then((c) => {
+                            const limits = { ...(c.limits || DEFAULT_LIMITS) };
+                            const floatKeys = new Set([
+                                'compressionThreshold', 'messageKeepRatio', 'subAgentCompressionThreshold',
+                                'slidingWindowTarget', 'charsPerToken',
+                            ]);
+                            const parsed = floatKeys.has(key) ? parseFloat(value) : parseInt(value, 10);
+                            if (!isNaN(parsed) && parsed >= 0) {
+                                limits[key] = parsed;
+                                const newConfig = { ...c, limits };
+                                saveConfig(newConfig).then(() => {
+                                    agent?.updateLimit(key, parsed);
+                                    add('system', `Setting updated: ${key} = ${parsed}`);
+                                }).catch(() => {
+                                    add('error', `Failed to save setting: ${key}`);
+                                });
+                            }
+                            else {
+                                add('error', `Invalid value for ${key}: ${value}`);
+                            }
+                        }).catch(() => {
+                            add('error', 'Failed to load config.');
+                        });
+                    }, onClose: () => setEditingSettings(false) })) : sessionList ? (_jsx(SessionPicker, { sessions: sessionList, onSelect: handleSessionSelect, onCancel: () => setSessionList(null) })) : (_jsx(InputSection, { onSubmit: handleInputSubmit, disabled: isLoading, onAbort: handleAbort, onClear: handleClearScreen, onScrollUp: scrollUp, onScrollDown: scrollDown, onHeightChange: handleInputHeightChange })) })] }));
+}
+// ─── Root (config loading + setup gate) ───
+function Root() {
+    const [config, setConfig] = useState(null);
+    const [ready, setReady] = useState(false);
+    const [initError, setInitError] = useState(null);
+    useEffect(() => {
+        loadConfig().then((c) => {
+            const envKey = process.env[ENV_API_KEY];
+            if (envKey)
+                c.apiKey = envKey;
+            setConfig(c);
+            if (isConfigured(c)) {
+                // Fetch model specs from API in background (uses user-defined/built-in as fallback)
+                fetchModelSpecs(c.baseUrl, c.apiKey).catch((err) => { logger.warn('Failed to fetch model specs', { error: err.message }); });
+                if (!process.env.NO_UPDATE_NOTIFIER && !c.disableUpdateCheck) {
+                    checkForUpdate().catch(() => { });
+                }
+                try {
+                    initAgent(c);
+                    setReady(true);
+                }
+                catch (err) {
+                    setInitError(err.message);
+                }
+            }
+        }).catch(() => {
+            setConfig({ apiKey: '', baseUrl: DEFAULT_BASE_URL, models: [...DEFAULT_MODELS], customModels: {}, limits: { ...DEFAULT_LIMITS }, permissionMode: 'default', thinkingMode: 'off', security: {}, injectionDetection: { enabled: true, sensitivity: 'medium' } });
+        });
+    }, []);
+    const handleSetupComplete = useCallback((c) => {
+        setConfig(c);
+        setInitError(null);
+        try {
+            initAgent(c);
+            setReady(true);
+        }
+        catch (err) {
+            setInitError(err.message);
+        }
+    }, []);
+    if (config === null) {
+        return (_jsx(Box, { paddingX: 3, paddingY: 1, children: _jsxs(Text, { dimColor: true, children: ['\u25CF', " Loading configuration..."] }) }));
+    }
+    if (initError) {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 3, paddingY: 1, children: [_jsxs(Text, { color: "red", bold: true, children: ["Initialization failed: ", initError] }), _jsx(Text, { dimColor: true, children: "Running setup to reconfigure..." }), _jsx(SetupScreen, { onComplete: (c) => { setInitError(null); handleSetupComplete(c); } })] }));
+    }
+    if (!ready) {
+        return _jsx(SetupScreen, { onComplete: handleSetupComplete });
+    }
+    return _jsx(App, { config: config });
+}
+// ─── Flicker-free rendering for Windows terminals ───
+// Buffer all stdout writes and flush at a capped frame rate (~60fps).
+// This ensures the terminal receives complete frames instead of
+// partial line-by-line rewrites that cause visible blinking.
+process.stdout.write('\x1b[?25l'); // hide cursor
+const _origWrite = process.stdout.write.bind(process.stdout);
+let _buffer = '';
+let _flushTimer = null;
+const FRAME_MS = 16; // ~60fps
+process.stdout.write = function (chunk, encodingOrCb, cb) {
+    if (typeof chunk === 'string') {
+        _buffer += chunk;
+        if (!_flushTimer) {
+            _flushTimer = setTimeout(() => {
+                _flushTimer = null;
+                const data = _buffer;
+                _buffer = '';
+                if (data)
+                    _origWrite(data);
+            }, FRAME_MS);
+        }
+        // Handle callback argument
+        const callback = typeof encodingOrCb === 'function' ? encodingOrCb : cb;
+        if (typeof callback === 'function')
+            process.nextTick(callback);
+        return true;
+    }
+    return _origWrite(chunk, encodingOrCb, cb);
+};
+function _restoreTerminal() {
+    if (_flushTimer) {
+        clearTimeout(_flushTimer);
+        _flushTimer = null;
+    }
+    process.stdout.write = _origWrite;
+    if (_buffer) {
+        _origWrite(_buffer);
+        _buffer = '';
+    }
+    _origWrite('\x1b[?25h'); // show cursor
+}
+process.on('exit', _restoreTerminal);
+process.on('SIGINT', () => { _restoreTerminal(); closeBrowser().finally(() => process.exit(0)); });
+process.on('SIGTERM', () => { _restoreTerminal(); closeBrowser().finally(() => process.exit(0)); });
+render(_jsx(Root, {}), { exitOnCtrlC: false, patchConsole: false });