@hopper-agent/cli 0.1.0

package/dist/src/cli.js

@@ -0,0 +1,1876 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+process.title = 'hopper-agent';
+import { render } from 'ink';
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve, basename, isAbsolute, join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+const __filename = fileURLToPath(import.meta.url);
+import { ChatSurface, handleSlashCommand } from '@hopper-agent/tui';
+import { getTheme } from '@hopper-agent/render';
+import { TurnLoop, SettingsManager, DEFAULT_SETTINGS, CronManager, TelegramGateway, ChannelRegistry, ChannelRouter, HeartbeatExecutor, HeartbeatDelivery, pickNextSchedule, scheduleLabel } from '@hopper-agent/core';
+import { AnthropicProvider, OpenAIProvider } from '@hopper-agent/providers';
+import { allTools } from '@hopper-agent/tools';
+import { createMcpTools } from '@hopper-agent/mcp';
+const VERSION = '0.5.1';
+// Resolve templates directory — included in package via "files" in package.json
+// Prod: packages/cli/dist/src/cli.js  → ../../templates
+// Dev:  packages/cli/src/cli.tsx       → ../templates
+const __dir = dirname(__filename);
+const TEMPLATES_DIR = existsSync(join(__dir, '..', '..', 'templates'))
+    ? join(__dir, '..', '..', 'templates') // prod: dist/src/
+    : join(__dir, '..', 'templates'); // dev: src/
+function parseStreamJsonSummary(raw, prompt) {
+    // Parse Claude CLI stream-json output (JSONL format).
+    // --verbose adds __meta lines we skip.
+    // Actual format from real output:
+    //   {"type":"assistant","message":{"content":[{"type":"thinking","thinking":"...","signature":""},{"type":"text","text":"Hello world!"}]}}
+    //   {"type":"result","result":"Hello world!","..."}
+    const lines = raw.split('\n');
+    const texts = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Skip __meta lines and non-JSON noise
+        if (trimmed.startsWith('__meta'))
+            continue;
+        // Try to parse as JSON
+        try {
+            const obj = JSON.parse(trimmed);
+            // type: "assistant" — message.content is an array of blocks
+            if (obj.type === 'assistant' && obj.message && typeof obj.message === 'object') {
+                const msg = obj.message;
+                const contentArr = msg.content;
+                if (Array.isArray(contentArr)) {
+                    for (const block of contentArr) {
+                        if (typeof block !== 'object' || block === null)
+                            continue;
+                        const b = block;
+                        // Only text blocks — skip thinking blocks (internal reasoning)
+                        if (b.type === 'text' && typeof b.text === 'string') {
+                            texts.push(b.text);
+                        }
+                    }
+                }
+            }
+            // type: "result" — final output has a flat "result" field
+            if (obj.type === 'result' && typeof obj.result === 'string') {
+                texts.push(obj.result);
+            }
+        }
+        catch {
+            // Not JSON — skip
+        }
+    }
+    // Combine all text blocks
+    const fullText = texts.join('\n').trim();
+    if (fullText) {
+        const summary = fullText.length > 2000
+            ? fullText.slice(0, 2000) + '... (truncated)'
+            : fullText;
+        return `Agent done work on project: ${basename(process.cwd())}\n${'---'.repeat(10)}\n${summary}`;
+    }
+    // Fallback: non-JSON lines that look like assistant output
+    const nonJsonLines = lines
+        .filter(l => l.trim() && !l.trim().startsWith('{'))
+        .filter(l => !l.trim().startsWith('['))
+        .join('\n')
+        .trim();
+    if (nonJsonLines) {
+        const summary = nonJsonLines.length > 2000
+            ? nonJsonLines.slice(0, 2000) + '... (truncated)'
+            : nonJsonLines;
+        return `Agent done work on project: ${basename(process.cwd())}\n${'---'.repeat(10)}\n${summary}`;
+    }
+    return `Agent finished on project: ${basename(process.cwd())}`;
+}
+function parseArgs(argv) {
+    const args = {};
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg === '--version' || arg === '-v') {
+            args.version = true;
+        }
+        else if (arg === '--help' || arg === '-h') {
+            args.help = true;
+        }
+        else if (arg === '-p') {
+            args.headless = true;
+        }
+        else if (arg === '--output-format') {
+            i++;
+            args.outputFormat = argv[i];
+        }
+        else if (arg === '--model') {
+            i++;
+            args.model = argv[i];
+        }
+        else if (arg === '--approval-mode') {
+            i++;
+            args.approvalMode = argv[i];
+        }
+        else if (arg === '--session') {
+            i++;
+            args.session = argv[i];
+        }
+        else if (arg === '--cwd') {
+            i++;
+            args.cwd = argv[i];
+        }
+        else if (arg === 'resume' || arg === 'continue') {
+            args.resume = true;
+        }
+        else if (!arg.startsWith('-')) {
+            args.prompt = arg;
+        }
+        i++;
+    }
+    return args;
+}
+function printHelp() {
+    console.log(`
+hopper-agent - the successor to claude-code
+
+Usage:
+  hopper-agent                              Interactive TUI
+  hopper-agent "<prompt>"                   One-shot prompt
+  hopper-agent -p "<prompt>"                Headless mode, stdout answer
+  hopper-agent resume [<id>]                Resume session
+  hopper-agent sessions list|show|rm        Session management
+  hopper-agent --version                    Show version
+
+Options:
+  --model <model>                       Model to use
+  --approval-mode <mode>                plan | edit | auto | yolo
+  --cwd <dir>                           Working directory
+  --output-format <format>              stream-json
+  -v, --version                         Show version
+  -h, --help                            Show help
+
+Slash Commands (in TUI):
+  /status                               Show version, model, and account info
+  /help                                 Show all available commands
+  /model <model>                        Switch AI model
+  /effort <level>                       Set reasoning effort (low|medium|high|max|auto)
+  /mode <mode>                          Set approval mode (plan|edit|auto|yolo)
+  /theme <name>                         Change color theme
+  /debug [on|off]                       Toggle debug logging
+  /agent [--mode m] [--effort e] <prompt> Launch external agent
+  /remind <message at time>             Create a reminder
+  /cron <list|delete|clear>             Manage reminders
+  /channels <list|set-bot-token|set-user-id|disconnect>  Manage Telegram channel
+`.trim());
+}
+function buildModePreamble(mode, cwd) {
+    const plansDir = resolve(cwd, 'plans');
+    switch (mode) {
+        case 'plan':
+            return [
+                '',
+                '',
+                '# PLAN MODE (active)',
+                'You MUST NOT edit files, write files, or run shell commands — only Read/Glob/Grep are permitted.',
+                '',
+                'Your job this turn:',
+                `1. Think step by step about the request.`,
+                `2. Pick a concise THREE-word kebab-case slug that summarises it (e.g. "refactor-login-flow").`,
+                `3. Write the full plan to ${plansDir}/<three-word-slug>.md with sections: Context, Critical Files, Steps, Verification.`,
+                `   (Use the Write tool — Write IS allowed in plan mode for files under ${plansDir}/ only, via the dedicated plan flow.)`,
+                `4. Stop. The user will review and approve. On approval the app will switch to auto mode and execute the plan.`,
+            ].join('\n');
+        case 'edit':
+            return [
+                '',
+                '',
+                '# EDIT MODE (active)',
+                'Every mutating tool call (Edit, Write, Bash) requires explicit user approval.',
+                'Propose changes in small, easy-to-review steps. After each approval, continue.',
+            ].join('\n');
+        case 'auto':
+            return [
+                '',
+                '',
+                '# AUTO MODE (active)',
+                'Think before you act. Non-destructive edits proceed automatically.',
+                'Ask only when a step could be harmful (destructive shell, large rewrites, anything irreversible).',
+            ].join('\n');
+        case 'yolo':
+            return [
+                '',
+                '',
+                '# YOLO MODE (active)',
+                'Proceed end-to-end without asking. No approvals. Only stop when the task is complete or you hit a blocker you cannot resolve.',
+            ].join('\n');
+        default:
+            return '';
+    }
+}
+const FILE_DESCRIPTIONS = {
+    'IDENTITY.md': { bucket: 'identity', description: 'Core identity — who you are, your name, your persona' },
+    'SOUL.md': { bucket: 'identity', description: 'Behavioural principles and personality' },
+    'USER.md': { bucket: 'user', description: 'Static profile of the human you help (name, timezone, skills, hardware)' },
+    'MEMORY.md': { bucket: 'memory', description: 'Curated long-term memory. Read when the user references past context; write here when asked to remember something' },
+    'TOOLS.md': { bucket: 'tools', description: 'Your local tool conventions and notes' },
+    'HEARTBEAT.md': { bucket: 'other', description: 'Heartbeat / liveness state log' },
+};
+function listMainFiles() {
+    const root = resolve(homedir(), '.hopper-agent');
+    const manifest = {
+        agentsMd: null, identity: [], user: [], memory: [], dailyMemory: [], tools: [], other: [],
+    };
+    if (!existsSync(root) || !statSync(root).isDirectory())
+        return manifest;
+    const agentsPath = resolve(root, 'AGENTS.md');
+    if (existsSync(agentsPath)) {
+        try {
+            const body = readFileSync(agentsPath, 'utf-8').trim();
+            if (body)
+                manifest.agentsMd = body;
+        }
+        catch { /* ignore */ }
+    }
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isFile())
+            continue;
+        if (entry.name === 'AGENTS.md')
+            continue; // loaded as the operating manual
+        if (!/\.(md|markdown|txt)$/i.test(entry.name))
+            continue;
+        const full = resolve(root, entry.name);
+        const meta = FILE_DESCRIPTIONS[entry.name];
+        const ref = {
+            path: full,
+            label: `~/.hopper-agent/${entry.name}`,
+            description: meta?.description ?? entry.name.replace(/\.[^.]+$/, ''),
+        };
+        const bucket = meta?.bucket ?? 'other';
+        manifest[bucket].push(ref);
+    }
+    // Daily memory: most recent 5 by mtime.
+    const memoryDir = resolve(root, 'memory');
+    if (existsSync(memoryDir) && statSync(memoryDir).isDirectory()) {
+        const entries = readdirSync(memoryDir, { withFileTypes: true })
+            .filter(e => e.isFile() && /\.(md|txt)$/i.test(e.name))
+            .map(e => {
+            const full = resolve(memoryDir, e.name);
+            return { name: e.name, full, mtime: statSync(full).mtimeMs };
+        })
+            .sort((a, b) => b.mtime - a.mtime)
+            .slice(0, 5);
+        for (const e of entries) {
+            manifest.dailyMemory.push({
+                path: e.full,
+                label: `~/.hopper-agent/memory/${e.name}`,
+                description: 'Dated session log',
+            });
+        }
+    }
+    return manifest;
+}
+function renderRefs(refs) {
+    return refs.map(r => `- ${r.path} — ${r.description}`).join('\n');
+}
+function loadAgentPrompt(cwd) {
+    const parts = [];
+    const manifest = listMainFiles();
+    const mainRoot = resolve(homedir(), '.hopper-agent');
+    const memoryDir = resolve(mainRoot, 'memory');
+    const today = new Date().toISOString().slice(0, 10);
+    // 1. Operating manual — AGENTS.md verbatim, or a built-in fallback.
+    if (manifest.agentsMd) {
+        parts.push(`# Your operating manual\n\n${manifest.agentsMd}`);
+    }
+    else {
+        parts.push([
+            '# Your operating manual',
+            '',
+            `Your persistent identity and memory live at: ${mainRoot}`,
+            'Use the Read tool with absolute paths to pull in context files when you need them.',
+            'When the user asks you to remember something, write it to MEMORY.md.',
+        ].join('\n'));
+    }
+    // 2. Manifest of available-but-not-loaded context.
+    const manifestParts = [
+        '# Available context files',
+        '',
+        'These files exist in ~/.hopper-agent/ and you may Read them with the Read tool when relevant to the user\'s request. Paths are absolute — pass them directly to Read.',
+    ];
+    if (manifest.identity.length) {
+        manifestParts.push('', '## Identity & personality', renderRefs(manifest.identity));
+    }
+    if (manifest.user.length) {
+        manifestParts.push('', '## The human you\'re helping', renderRefs(manifest.user));
+    }
+    if (manifest.memory.length || manifest.dailyMemory.length) {
+        manifestParts.push('', '## Memory');
+        if (manifest.memory.length)
+            manifestParts.push(renderRefs(manifest.memory));
+        if (manifest.dailyMemory.length) {
+            manifestParts.push(`Dated session logs (newest first) in ${memoryDir}:`, renderRefs(manifest.dailyMemory));
+        }
+    }
+    if (manifest.tools.length) {
+        manifestParts.push('', '## Tool notes', renderRefs(manifest.tools));
+    }
+    if (manifest.other.length) {
+        manifestParts.push('', '## Other', renderRefs(manifest.other));
+    }
+    parts.push(manifestParts.join('\n'));
+    // 3. Write rules — keep them explicit and short.
+    parts.push([
+        '# Write rules (enforce these)',
+        '',
+        `- "remember X" or a fact worth keeping → append to ${resolve(mainRoot, 'MEMORY.md')}`,
+        `- Today's session log → append to ${resolve(memoryDir, `${today}.md`)} (create if missing)`,
+        `- Profile fact about the user changed → update ${resolve(mainRoot, 'USER.md')}`,
+        '- Never write memories or session events to USER.md.',
+    ].join('\n'));
+    // 4. Project overrides — <cwd>/.hopper-agent/AGENTS.md layered on top of the global manual.
+    const projectPath = resolve(cwd, '.hopper-agent', 'AGENTS.md');
+    if (existsSync(projectPath)) {
+        parts.push(`# Project overrides (${projectPath})\n\n${readFileSync(projectPath, 'utf-8')}`);
+    }
+    // 5. Current time.
+    const now = new Date();
+    const dateStr = now.toLocaleDateString('en-US', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
+    const timeStr = now.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', second: '2-digit', timeZoneName: 'short' });
+    parts.push(`# Current time\n\n${dateStr}, ${timeStr}`);
+    return parts.join('\n\n');
+}
+function cwdFromProjectDir(rawDir) {
+    // Read cwd from a JSONL file in the project dir — fall back to reconstructing from dir name.
+    const projDir = join(homedir(), '.claude', 'projects', rawDir);
+    try {
+        const files = readdirSync(projDir).filter(f => f.endsWith('.jsonl'));
+        for (const f of files) {
+            const content = readFileSync(join(projDir, f), 'utf8');
+            for (const line of content.split('\n')) {
+                if (!line.includes('"cwd"'))
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    if (typeof obj['cwd'] === 'string')
+                        return obj['cwd'];
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    catch { /* fall through */ }
+    // Fallback: reconstruct from dir name (works for simple paths without dashes in dir names)
+    const m = rawDir.match(/^([A-Za-z])--(.+)$/);
+    if (m) {
+        const drive = m[1].toUpperCase();
+        return drive + ':\\' + m[2].replace(/-/g, '\\');
+    }
+    return rawDir;
+}
+function loadClaudeProjects() {
+    const dir = join(homedir(), '.claude', 'projects');
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        return entries
+            .filter(e => e.isDirectory())
+            .map(e => {
+            const m = e.name.match(/^[A-Za-z]--(.+)$/);
+            const projectPath = cwdFromProjectDir(e.name);
+            return {
+                label: m ? m[1] : e.name,
+                rawDir: e.name,
+                source: 'claude-code',
+                projectPath,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function formatDuration(ms) {
+    const totalSeconds = Math.floor(ms / 1000);
+    const h = String(Math.floor(totalSeconds / 3600)).padStart(2, '0');
+    const m = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, '0');
+    const s = String(totalSeconds % 60).padStart(2, '0');
+    return `${h}:${m}:${s}`;
+}
+function estimateCost(model, inputTokens, outputTokens) {
+    // Rough per-million-token pricing in USD; fall back to Sonnet rates.
+    const pricing = {
+        'claude-opus': { in: 15, out: 75 },
+        'claude-sonnet': { in: 3, out: 15 },
+        'claude-haiku': { in: 0.8, out: 4 },
+    };
+    const key = Object.keys(pricing).find(k => model.includes(k)) || 'claude-sonnet';
+    const p = pricing[key];
+    return (inputTokens * p.in + outputTokens * p.out) / 1_000_000;
+}
+function App({ provider, streamProviderHolder, model, approvalMode, cwd, themeName, system, settings, projects, cronManager: externalCronManager, onReminderHolder, telegramChatIdRef, telegramSubmitRef, telegramGateway, channelRegistry, channelRouter, activeChannelRef, mcpToolsRef, mcpClientsRef, onMcpReconnect, contextWindowSize }) {
+    const [messages, setMessages] = useState([]);
+    // Multi-channel: per-channel message storage (keyed by channel ID)
+    const [channelMessages, setChannelMessages] = useState({});
+    const [activeChannelId, setActiveChannelId] = useState('main');
+    // Per-channel TurnLoop instances
+    const channelTurnLoopsRef = useRef(new Map());
+    const [currentModel, setCurrentModel] = useState(model);
+    const [currentProvider, setCurrentProvider] = useState(provider?.name || '(not configured)');
+    const [currentTheme, setCurrentTheme] = useState(themeName);
+    const [currentMode, setCurrentMode] = useState(approvalMode);
+    const [currentEffort, setCurrentEffort] = useState(settings.effort);
+    const [currentDebug, setCurrentDebug] = useState(settings.debug);
+    const [currentCwd, setCurrentCwd] = useState(cwd);
+    const [currentSystem, setCurrentSystem] = useState(system);
+    const [inputTokens, setInputTokens] = useState(undefined);
+    const [outputTokens, setOutputTokens] = useState(undefined);
+    const [currentTab, setCurrentTab] = useState('assistant');
+    const [duration, setDuration] = useState('00:00:00');
+    const [status, setStatus] = useState('idle');
+    const startedAt = useRef(Date.now());
+    const loopRef = useRef(null);
+    const busyRef = useRef(false);
+    const toolGroupIndexRef = useRef(null);
+    const planFileRef = useRef(null);
+    // Pending approval requests keyed by toolCallId (for Telegram callback correlation)
+    const pendingApprovalsRef = useRef(new Map());
+    // ToolCallId of the current approval request (set by approval-request event, consumed by onApprovalAsk)
+    const pendingToolCallIdRef = useRef(null);
+    const [pendingApproval, setPendingApproval] = useState(null);
+    const shellChildRef = useRef(null);
+    // Persistent cwd for `!` shell commands. `cd foo` inside a one-shot spawn
+    // would evaporate when the subshell exits, so we track it ourselves and
+    // pass it to every subsequent spawn.
+    const shellCwdRef = useRef(cwd);
+    // Load existing settings so subsequent .update() calls (from slash commands)
+    // preserve keys like MODEL_URL / MODEL_API_KEY instead of resetting to
+    // defaults.
+    const settingsMgr = useRef(null);
+    if (!settingsMgr.current) {
+        const mgr = new SettingsManager();
+        mgr.load();
+        settingsMgr.current = mgr;
+    }
+    const sessionIdRef = useRef(null);
+    // CronManager instance — created externally, stored here for slash commands
+    const cronManagerRef = useRef(externalCronManager);
+    const wizardRef = useRef({ phase: 'idle' });
+    const TEMPLATE_FILES = ['AGENTS.md', 'SOUL.md', 'USER.md', 'TODO.md', 'MEMORY.md'];
+    // Store setMessages in a ref so the checker callback can call it
+    // without racing with a render cycle. The checker runs in setInterval,
+    // which can fire mid-render — calling setState then can silently fail.
+    const setMessagesRef = useRef(setMessages);
+    setMessagesRef.current = setMessages;
+    // Helper: push a message to both channel and legacy message arrays
+    const pushToChannel = useCallback((channelId, content) => {
+        setChannelMessages((prev) => {
+            const ch = prev[channelId] || [];
+            return { ...prev, [channelId]: [...ch, { role: 'assistant', content }] };
+        });
+        setMessages((prev) => [...prev, { role: 'assistant', content }]);
+    }, []);
+    // Wire Telegram approval decision callback so inline button taps resolve pending Promises
+    useEffect(() => {
+        if (telegramGateway) {
+            telegramGateway.setOnApprovalDecision((toolCallId, approved) => {
+                const pending = pendingApprovalsRef.current.get(toolCallId);
+                if (pending) {
+                    pending.resolve(approved);
+                    pendingApprovalsRef.current.delete(toolCallId);
+                }
+                // Clear TUI approval UI — decision came from Telegram, not keyboard
+                setPendingApproval(null);
+            });
+        }
+    }, [telegramGateway]);
+    // Register the reminder callback synchronously so it's available
+    // before useEffect runs. Uses setMessagesRef to avoid render-cycle race.
+    // Telegram sends are handled in main()'s cron checker callback (fresh closure).
+    onReminderHolder.current = (task) => {
+        const timeStr = new Date(task.scheduledAt).toLocaleString();
+        const briefTask = task;
+        if (briefTask.heartbeatBrief) {
+            const label = task.schedule ? scheduleLabel(task.schedule.type) : 'MANUAL';
+            setChannelMessages(prev => {
+                const ch = prev[activeChannelId] || [];
+                return { ...prev, [activeChannelId]: [...ch, { role: 'heartbeat', title: label, content: briefTask.heartbeatBrief }] };
+            });
+        }
+        else {
+            const content = `Hopper reminder:\nDate: ${timeStr}\n${task.message}`;
+            setChannelMessages(prev => {
+                const ch = prev[activeChannelId] || [];
+                return { ...prev, [activeChannelId]: [...ch, { role: 'system', content }] };
+            });
+        }
+    };
+    const [agents, setAgents] = useState(new Map());
+    const agentsRef = useRef(new Map());
+    agentsRef.current = agents;
+    useEffect(() => {
+        const id = setInterval(() => {
+            setDuration(formatDuration(Date.now() - startedAt.current));
+        }, 1000);
+        return () => clearInterval(id);
+    }, []);
+    const theme = getTheme(currentTheme);
+    const applySlashResult = useCallback((result, agentPrompt) => {
+        const push = (content) => {
+            // Slash command results must go to the per-channel messages array
+            // since that's what the ChatSurface renders.
+            setChannelMessages((prev) => {
+                const ch = prev[activeChannelId] || [];
+                return { ...prev, [activeChannelId]: [...ch, { role: 'assistant', content }] };
+            });
+            // Also sync to legacy messages for backward compatibility.
+            setMessages(prev => [...prev, { role: 'assistant', content }]);
+        };
+        switch (result.type) {
+            case 'message':
+                if (result.message === 'init_wizard') {
+                    push('Welcome to hopper-agent! Let\'s configure your AI provider.\n' +
+                        '\n' +
+                        'Which provider do you want to use?\n' +
+                        '  1) local\n' +
+                        '  2) openrouter\n' +
+                        '  3) openai\n' +
+                        '  4) anthropic\n' +
+                        '\nType 1, 2, 3, or 4:');
+                    wizardRef.current = { phase: 'provider' };
+                    return;
+                }
+                push(result.message);
+                break;
+            case 'update_model':
+                setCurrentModel(result.model);
+                settingsMgr.current.update({ model: result.model });
+                push(result.message);
+                break;
+            case 'update_provider': {
+                const newProvider = result.provider;
+                settingsMgr.current.update({ MODEL_PROVIDER: newProvider });
+                // Create new provider and swap into the holder
+                const settings = settingsMgr.current.get();
+                // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                streamProviderHolder.current = createProvider(settings);
+                loopRef.current = null;
+                setCurrentProvider(streamProviderHolder.current.name);
+                push(result.message);
+                break;
+            }
+            case 'update_init': {
+                // Legacy: direct API key via /init <key>
+                settingsMgr.current.update({ MODEL_API_KEY: result.apiKey });
+                const settings = settingsMgr.current.get();
+                streamProviderHolder.current = createProvider(settings);
+                loopRef.current = null;
+                push(result.message + '\nProvider ready. You can now chat!');
+                break;
+            }
+            case 'update_theme': {
+                setCurrentTheme(result.theme);
+                settingsMgr.current.update({ theme: result.theme });
+                // Repaint the terminal default-background to match the new theme so
+                // unpainted cells stay consistent.
+                const nextTheme = getTheme(result.theme);
+                process.stdout.write(`\x1b]11;${nextTheme.background}\x07`);
+                push(result.message);
+                break;
+            }
+            case 'update_mode':
+                setCurrentMode(result.mode);
+                settingsMgr.current.update({ mode: result.mode });
+                loopRef.current = null;
+                push(result.message);
+                break;
+            case 'update_effort':
+                setCurrentEffort(result.effort);
+                settingsMgr.current.update({ effort: result.effort });
+                loopRef.current = null;
+                push(result.message);
+                break;
+            case 'update_debug':
+                setCurrentDebug(result.debug);
+                settingsMgr.current.update({ debug: result.debug });
+                push(result.message);
+                break;
+            case 'update_statusline':
+                push(result.message);
+                break;
+            case 'update_tools_per_call':
+                settingsMgr.current.update({ TOOLS_PER_CALL: result.toolsPerCall, WEBSEARCH_PER_CALL: result.websearchPerCall });
+                loopRef.current = null;
+                push(result.message);
+                break;
+            case 'update_websearch_per_call':
+                settingsMgr.current.update({ WEBSEARCH_PER_CALL: result.websearchPerCall });
+                loopRef.current = null;
+                push(result.message);
+                break;
+            case 'update_mcp': {
+                // Persist MCP servers to disk. handleMcp mutates ctx.settings in-place,
+                // but that's a shallow copy from .get() — settingsMgr never sees it.
+                // The mcpServers field on the result carries the JSON string to persist.
+                if (result.mcpServers) {
+                    settingsMgr.current.update({ MCP_SERVERS: typeof result.mcpServers === 'string' ? JSON.parse(result.mcpServers) : result.mcpServers });
+                }
+                loopRef.current = null;
+                if (result.mcpServerId) {
+                    push(`${result.message}\nServer "${result.mcpServerId}" changed — TurnLoop invalidated. New tools will be loaded on next message.`);
+                }
+                else {
+                    push(`${result.message}\nMCP reloaded — TurnLoop invalidated. New tools will be loaded on next message.`);
+                }
+                break;
+            }
+            case 'notification': {
+                const note = result.notification;
+                if (!note)
+                    break;
+                // Heartbeat notification handling
+                if (note.type === 'heartbeat') {
+                    if (note.enabled) {
+                        push('Heartbeat enabled. The agent will run on all configured schedules.');
+                        settingsMgr.current.update({ HEARTBEAT: 'on' });
+                    }
+                    else {
+                        push('Heartbeat disabled.');
+                        settingsMgr.current.update({ HEARTBEAT: 'off' });
+                    }
+                    break;
+                }
+                // Heartbeat schedule set
+                if (note.type === 'heartbeat-set') {
+                    settingsMgr.current.update({ [note.key]: note.value });
+                    // Re-evaluate all four schedules to pick the next earliest
+                    const settings = settingsMgr.current.get();
+                    cronManagerRef.current?.rescheduleFromSettings({
+                        HEARTBEAT_TIMES: settings.HEARTBEAT_TIMES,
+                        HEARTBEAT_DAILY: settings.HEARTBEAT_DAILY,
+                        HEARTBEAT_WEEKLY: settings.HEARTBEAT_WEEKLY,
+                        HEARTBEAT_MONTHLY: settings.HEARTBEAT_MONTHLY,
+                    });
+                    const scheduleLabel = {
+                        HEARTBEAT_TIMES: `times: ${note.value}`,
+                        HEARTBEAT_DAILY: `daily at ${note.value}`,
+                        HEARTBEAT_WEEKLY: `weekly on ${note.value}`,
+                        HEARTBEAT_MONTHLY: `monthly on day ${note.value}`,
+                    };
+                    push(`Heartbeat schedule updated: ${scheduleLabel[note.key] ?? note.value}`);
+                    break;
+                }
+                // Heartbeat now — run immediately
+                if (note.type === 'heartbeat-now') {
+                    push('Heartbeat cycle starting...');
+                    const settings = settingsMgr.current.get();
+                    const provider = streamProviderHolder.current;
+                    if (!provider) {
+                        push('Provider not initialized. Cannot run heartbeat.');
+                        break;
+                    }
+                    // Merge built-in tools + MCP tools, just like the TUI TurnLoop
+                    const mcpTools = mcpToolsRef.current;
+                    const heartbeatTools = mcpTools.length > 0
+                        ? [...allTools, ...mcpTools]
+                        : allTools;
+                    const hasMcp = mcpTools.length > 0;
+                    const executor = new HeartbeatExecutor({
+                        provider: provider,
+                        model: settings.model,
+                        tools: heartbeatTools,
+                        cwd: currentCwd,
+                        settings,
+                        effort: currentEffort,
+                    });
+                    executor.execute().then(async (result) => {
+                        const formatted = HeartbeatDelivery.formatBrief(result);
+                        setChannelMessages(prev => {
+                            const ch = prev[activeChannelId] || [];
+                            return { ...prev, [activeChannelId]: [...ch, { role: 'heartbeat', title: 'manual', content: formatted }] };
+                        });
+                        // Also deliver to Telegram if configured
+                        const telegramChatId = settings.TELEGRAM_CHAT_ID;
+                        if (telegramChatId && telegramGateway) {
+                            const delivery = new HeartbeatDelivery({
+                                chatId: telegramChatId,
+                                telegramGateway,
+                            });
+                            await delivery.deliver(formatted);
+                        }
+                    }).catch((err) => {
+                        push(`Heartbeat failed: ${err instanceof Error ? err.message : String(err)}`);
+                    });
+                    break;
+                }
+                // Original reminder notification handling
+                {
+                    const sysMsg = {
+                        role: 'system',
+                        content: `Hopper reminder:\nDate: ${note.scheduledAt}\n${note.message}`,
+                    };
+                    setChannelMessages((prev) => {
+                        const ch = prev[activeChannelId] || [];
+                        return { ...prev, [activeChannelId]: [...ch, sysMsg] };
+                    });
+                    setMessages(prev => [...prev, sysMsg]);
+                }
+                break;
+            }
+            case 'start_agent': {
+                setAgents(prev => {
+                    const next = new Map(prev);
+                    next.set(result.agentId, {
+                        id: result.agentId,
+                        prompt: agentPrompt ?? '',
+                        output: '',
+                        status: 'running',
+                    });
+                    return next;
+                });
+                push(result.message);
+                break;
+            }
+            case 'external': {
+                const ext = result.external;
+                if (ext === 'channels.set-bot-token') {
+                    settingsMgr.current.update({ TELEGRAM_BOT_TOKEN: result.message });
+                    push(`Telegram bot token set. Bot will start polling on next user ID configuration.`);
+                }
+                else if (ext === 'channels.set-user-id') {
+                    settingsMgr.current.update({ TELEGRAM_USER_ID: result.message });
+                    push(`Allowed user ID set. Telegram will only process messages from this user.`);
+                }
+                else if (ext === 'channels.set-chat-id') {
+                    settingsMgr.current.update({ TELEGRAM_CHAT_ID: result.message });
+                    push(`Telegram chat ID set. Reminders will now send to this chat.`);
+                }
+                else if (ext === 'channels.disconnect') {
+                    settingsMgr.current.update({ TELEGRAM_BOT_TOKEN: '', TELEGRAM_USER_ID: '' });
+                    push('Telegram integration disconnected.');
+                    telegramGateway?.stop();
+                }
+                else if (ext === 'channels.switch') {
+                    setActiveChannelId(result.message);
+                    push(`Switched to channel: ${result.message}`);
+                }
+                else {
+                    push(`Command /${ext} not yet implemented`);
+                }
+                break;
+            }
+            case 'exit':
+                if (result.message)
+                    push(result.message);
+                // Let the transcript paint before exiting.
+                setTimeout(() => process.exit(0), 30);
+                break;
+            case 'update_memory': {
+                const mem = result.memory;
+                const home = homedir();
+                const memoryPath = join(home, '.hopper-agent', 'MEMORY.md');
+                if (mem.operation === 'status') {
+                    // Read key memory files and compute approximate tokens (~4 chars ≈ 1 token for English markdown)
+                    const memDir = join(home, '.hopper-agent');
+                    const files = ['AGENTS.md', 'MEMORY.md', 'USER.md', 'SOUL.md', 'IDENTITY.md', 'TOOLS.md', 'HEARTBEAT.md'];
+                    const lines = ['Memory System Status:'];
+                    let totalChars = 0;
+                    for (const f of files) {
+                        const fp = join(memDir, f);
+                        if (existsSync(fp)) {
+                            const content = readFileSync(fp, 'utf-8');
+                            const tokens = Math.ceil(content.length / 4);
+                            totalChars += content.length;
+                            lines.push(`  ${f.padEnd(15)} ~${tokens} tokens`);
+                        }
+                    }
+                    lines.push(`  ${'---'.padEnd(15)} ~${'---'}`);
+                    lines.push(`  ${'TOTAL'.padEnd(15)} ~${Math.ceil(totalChars / 4)} tokens`);
+                    push(lines.join('\n'));
+                }
+                else if (mem.operation === 'add') {
+                    const existing = existsSync(memoryPath) ? readFileSync(memoryPath, 'utf-8') : '';
+                    const newContent = existing.trim() ? existing.trimEnd() + '\n' + mem.content : mem.content;
+                    writeFileSync(memoryPath, newContent, 'utf-8');
+                    push(result.message);
+                }
+                loopRef.current = null;
+                break;
+            }
+            case 'switch_tab': {
+                setCurrentTab(result.tab ?? 'stats');
+                push(result.message ?? 'Switched to Stats tab');
+                break;
+            }
+        }
+    }, []);
+    const onSlashCommand = useCallback((input) => {
+        // Echo the submitted slash command as a user message so the transcript
+        // shows what the user typed alongside the assistant's reply.
+        const echoed = input.args ? `/${input.command} ${input.args}` : `/${input.command}`;
+        setChannelMessages((prev) => {
+            const ch = prev[activeChannelId] || [];
+            return { ...prev, [activeChannelId]: [...ch, { role: 'user', content: echoed }] };
+        });
+        setMessages(prev => [...prev, { role: 'user', content: echoed }]);
+        const ctx = {
+            settings: settingsMgr.current.get(),
+            version: VERSION,
+            model: currentModel,
+            provider: provider?.name || '(not configured)',
+            approvalMode: currentMode,
+            cwd: currentCwd,
+            inputTokens,
+            outputTokens,
+            cronManager: cronManagerRef.current ?? undefined,
+            mcpClients: mcpClientsRef.current,
+            contextWindowSize: contextWindowSize ?? 200_000,
+            thinkingBudget: ({ low: 2000, medium: 6000, high: 16000, max: 32000, auto: 0 })[currentEffort ?? 'auto'] ?? 0,
+        };
+        const result = handleSlashCommand(input.command, input.args, ctx);
+        applySlashResult(result, input.args);
+        // Spawn external agent subprocess after the slash command result is applied.
+        if (result.type === 'start_agent' && result.agentId) {
+            const agentId = result.agentId;
+            const prompt = input.args;
+            const agentCwd = currentCwd;
+            // Build claude CLI args with agent-specific mode/effort params
+            const claudeArgs = ['-p', prompt];
+            if (result.agentMode)
+                claudeArgs.unshift('--mode', result.agentMode);
+            if (result.agentEffort)
+                claudeArgs.unshift('--effort', result.agentEffort);
+            claudeArgs.unshift('--output-format', 'stream-json', '--verbose');
+            setAgents(prev => {
+                const next = new Map(prev);
+                const child = spawn('claude', claudeArgs, {
+                    cwd: agentCwd,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                const entry = next.get(agentId);
+                entry.child = child;
+                next.set(agentId, entry);
+                // Accumulate raw output for the Agents tab (full streaming)
+                const rawOutput = [];
+                child.stdout.on('data', (data) => {
+                    const text = data.toString();
+                    rawOutput.push(text);
+                    setAgents(prev2 => {
+                        const next2 = new Map(prev2);
+                        const e = next2.get(agentId);
+                        if (e) {
+                            e.output += text;
+                            next2.set(agentId, e);
+                        }
+                        return next2;
+                    });
+                });
+                child.stderr.on('data', (data) => {
+                    const text = data.toString();
+                    rawOutput.push(text);
+                    setAgents(prev2 => {
+                        const next2 = new Map(prev2);
+                        const e = next2.get(agentId);
+                        if (e) {
+                            e.output += text;
+                            next2.set(agentId, e);
+                        }
+                        return next2;
+                    });
+                });
+                child.on('close', (code) => {
+                    setAgents(prev2 => {
+                        const next2 = new Map(prev2);
+                        const e = next2.get(agentId);
+                        if (e) {
+                            e.status = code === 0 ? 'completed' : 'error';
+                            next2.set(agentId, e);
+                        }
+                        return next2;
+                    });
+                    // Parse stream-json output to extract assistant summary for the Assistant tab
+                    const fullRaw = rawOutput.join('');
+                    const summary = parseStreamJsonSummary(fullRaw, prompt);
+                    const finishedAgent = agentsRef.current.get(agentId);
+                    if (code === 0 && finishedAgent) {
+                        setMessages(prev => [
+                            ...prev,
+                            {
+                                role: 'assistant',
+                                content: summary,
+                                title: `Agent: ${prompt}`,
+                            },
+                        ]);
+                    }
+                    else if (finishedAgent) {
+                        setMessages(prev => [
+                            ...prev,
+                            {
+                                role: 'assistant',
+                                content: `Agent "${prompt}" failed (exit ${code}):\n\n${finishedAgent.output}`,
+                                title: `Agent: ${prompt}`,
+                            },
+                        ]);
+                    }
+                });
+                return next;
+            });
+        }
+    }, [currentModel, currentMode, currentCwd, inputTokens, outputTokens, provider?.name, applySlashResult]);
+    const onSubmit = useCallback(async (text) => {
+        if (busyRef.current)
+            return;
+        // Determine target channel: Telegram sets activeChannelRef before calling onSubmit
+        const targetChannel = activeChannelRef.current ?? activeChannelId;
+        if (activeChannelRef.current) {
+            activeChannelRef.current = null;
+            setActiveChannelId(targetChannel);
+        }
+        // Handle interactive /init wizard steps
+        const wizard = wizardRef.current;
+        if (wizard.phase !== 'idle' && !text.trim().startsWith('/')) {
+            const input = text.trim();
+            if (wizard.phase === 'provider') {
+                const choice = input.toLowerCase();
+                const providerMap = {
+                    '1': { name: 'local', key: 'MODEL_API_KEY', url: 'MODEL_URL' },
+                    '2': { name: 'openrouter', key: 'OPENROUTER_API_KEY', url: 'OPENROUTER_URL' },
+                    '3': { name: 'openai', key: 'OPENAI_API_KEY', url: 'OPENAI_URL' },
+                    '4': { name: 'anthropic', key: 'ANTHROPIC_API_KEY', url: 'ANTHROPIC_URL' },
+                };
+                const entry = providerMap[choice];
+                if (!entry) {
+                    setChannelMessages((prev) => ({ ...prev, [targetChannel]: [...(prev[targetChannel] || []), { role: 'assistant', content: 'Invalid choice. Please enter 1-4.\n  1) local\n  2) openrouter\n  3) openai\n  4) anthropic' }] }));
+                    setMessages((prev) => [...prev, { role: 'assistant', content: 'Invalid choice. Please enter 1-4.\n  1) local\n  2) openrouter\n  3) openai\n  4) anthropic' }]);
+                    return;
+                }
+                const updates = { MODEL_PROVIDER: entry.name };
+                updates[entry.key] = '';
+                updates[entry.url] = entry.name === 'openrouter' ? 'https://openrouter.ai/api' : `https://api.${entry.name}.com/v1`;
+                settingsMgr.current.update(updates);
+                if (entry.name === 'local') {
+                    wizardRef.current = { phase: 'apiKey', provider: entry.name };
+                    pushToChannel(targetChannel, `${entry.name}: Enter your API key:`);
+                }
+                else {
+                    wizardRef.current = { phase: 'apiKey', provider: entry.name };
+                    pushToChannel(targetChannel, `${entry.name}: Enter your API key:`);
+                }
+                return;
+            }
+            if (wizard.phase === 'apiKey') {
+                const keyName = wizard.provider === 'local' ? 'MODEL_API_KEY'
+                    : wizard.provider === 'openrouter' ? 'OPENROUTER_API_KEY'
+                        : wizard.provider === 'openai' ? 'OPENAI_API_KEY'
+                            : 'ANTHROPIC_API_KEY';
+                settingsMgr.current.update({ [keyName]: input });
+                if (wizard.provider === 'local') {
+                    wizardRef.current = { phase: 'url', provider: wizard.provider };
+                    pushToChannel(targetChannel, `API key configured.\nWhat is your local API URL?\n  Default: http://localhost:8080/v1\n  (Press Enter for default):`);
+                }
+                else {
+                    wizardRef.current = { phase: 'model', provider: wizard.provider };
+                    pushToChannel(targetChannel, `API key configured.\nWhich model do you want to use?\n  Examples: claude-sonnet-4-6, gpt-4o, o1, llama-3.1-405b\n  Enter model name:`);
+                }
+                return;
+            }
+            if (wizard.phase === 'url') {
+                const url = input || 'http://localhost:8080/v1';
+                settingsMgr.current.update({ MODEL_URL: url });
+                wizardRef.current = { phase: 'model', provider: wizard.provider };
+                pushToChannel(targetChannel, `URL configured: ${url}\nWhich model do you want to use?\n  Examples: claude-sonnet-4-6, gpt-4o, o1, llama-3.1-405b\n  Enter model name:`);
+                return;
+            }
+            if (wizard.phase === 'model') {
+                const model = input || 'claude-sonnet-4-6';
+                settingsMgr.current.update({ model });
+                const settings = settingsMgr.current.get();
+                streamProviderHolder.current = createProvider(settings);
+                loopRef.current = null;
+                setCurrentModel(model);
+                setCurrentProvider(streamProviderHolder.current.name);
+                wizardRef.current = { phase: 'idle' };
+                pushToChannel(targetChannel, `Configuration complete!\n  Provider: ${wizard.provider || 'anthropic'}\n  Model: ${model}\n\nWriting workspace files...`);
+                // Copy template files as-is to ~/.hopper-agent/
+                (async () => {
+                    try {
+                        const hopperDir = join(homedir(), '.hopper-agent');
+                        if (!existsSync(hopperDir)) {
+                            mkdirSync(hopperDir, { recursive: true });
+                        }
+                        const memoryDir = join(hopperDir, 'memory');
+                        if (!existsSync(memoryDir)) {
+                            mkdirSync(memoryDir, { recursive: true });
+                        }
+                        for (const filename of TEMPLATE_FILES) {
+                            const templatePath = join(TEMPLATES_DIR, filename);
+                            if (!existsSync(templatePath)) {
+                                pushToChannel(targetChannel, `  Skipped ${filename} (no template)`);
+                                continue;
+                            }
+                            const content = readFileSync(templatePath, 'utf-8');
+                            writeFileSync(join(hopperDir, filename), content, 'utf-8');
+                            pushToChannel(targetChannel, `  Wrote ${filename}`);
+                        }
+                        pushToChannel(targetChannel, '\nReady! Type a message to get started.');
+                        // Reload system prompt so the TurnLoop picks up the new AGENTS.md
+                        setCurrentSystem(loadAgentPrompt(currentCwd));
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        pushToChannel(targetChannel, `Failed to write files: ${msg}`);
+                    }
+                })();
+                return;
+            }
+        }
+        if (currentDebug) {
+            console.error(`[debug] prompt: ${text}, channel: ${targetChannel}`);
+        }
+        // Get or create TurnLoop for the target channel
+        const channelTurnLoops = channelTurnLoopsRef.current;
+        let loop = channelTurnLoops.get(targetChannel);
+        if (!loop) {
+            // Reconnect MCP tools before building TurnLoop so we pick up
+            // any changes made via /mcp add/remove from another channel.
+            if (onMcpReconnect) {
+                try {
+                    await onMcpReconnect();
+                }
+                catch {
+                    /* reconnect failure is non-fatal */
+                }
+            }
+            // Try to resume an existing session for this channel
+            const channel = channelRegistry.get(targetChannel);
+            loop = new TurnLoop({
+                provider: streamProviderHolder.current,
+                model: currentModel,
+                tools: [...allTools, ...mcpToolsRef.current],
+                cwd: currentCwd,
+                settings: settingsMgr.current.get(),
+                approvalMode: currentMode,
+                effort: currentEffort,
+                system: currentSystem + buildModePreamble(currentMode, currentCwd),
+                sessionId: channel?.sessionId,
+                onApprovalAsk: (req) => new Promise((resolve) => {
+                    setPendingApproval({
+                        toolName: req.name,
+                        input: req.input,
+                        reason: req.reason,
+                        resolve,
+                    });
+                    // Also send Telegram approval request if this is a Telegram channel
+                    const telegramChatId = channelRouter.getTelegramChatId(targetChannel);
+                    if (telegramChatId) {
+                        const toolCallId = pendingToolCallIdRef.current;
+                        if (toolCallId) {
+                            pendingApprovalsRef.current.set(toolCallId, { resolve });
+                            channelRouter.sendTelegramApproval(telegramChatId, req.name, req.input, toolCallId);
+                        }
+                        else {
+                            // Fallback: generate a key so resolve still works
+                            const fallbackId = `tg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+                            pendingApprovalsRef.current.set(fallbackId, { resolve });
+                            channelRouter.sendTelegramApproval(telegramChatId, req.name, req.input, fallbackId);
+                        }
+                    }
+                }),
+            });
+            channelTurnLoops.set(targetChannel, loop);
+        }
+        const channelMsgs = channelMessages[targetChannel] || [];
+        setChannelMessages((prev) => ({
+            ...prev,
+            [targetChannel]: [...channelMsgs, { role: 'user', content: text }],
+        }));
+        // Also sync the legacy messages for backward compat
+        setMessages((prev) => [...prev, { role: 'user', content: text }]);
+        busyRef.current = true;
+        setStatus('working');
+        let assistantText = '';
+        toolGroupIndexRef.current = null;
+        const unsubs = [
+            loop.eventBus.subscribe('assistant-delta', (e) => {
+                if (e.type !== 'assistant-delta')
+                    return;
+                assistantText += e.text;
+                setChannelMessages((prev) => {
+                    const chMsgs = prev[targetChannel] || [];
+                    // Seal the tool-group: replace its content with a compact "[N tools]" summary.
+                    let base = chMsgs;
+                    const gi = toolGroupIndexRef.current;
+                    if (gi !== null && base[gi]?.role === 'tool-group') {
+                        const names = base[gi].content.split(' · ');
+                        const count = names.length;
+                        const summary = count <= 3
+                            ? `[${names.join(' · ')}]`
+                            : `[${count} tools: ${names.slice(0, 2).join(', ')}, …]`;
+                        base = [...base.slice(0, gi), { role: 'tool-group', content: summary }, ...base.slice(gi + 1)];
+                        toolGroupIndexRef.current = null;
+                    }
+                    const last = base[base.length - 1];
+                    if (last && last.role === 'assistant') {
+                        return { ...prev, [targetChannel]: [...base.slice(0, -1), { role: 'assistant', content: assistantText }] };
+                    }
+                    return { ...prev, [targetChannel]: [...base, { role: 'assistant', content: assistantText }] };
+                });
+                // Also sync to legacy messages
+                setMessages((prev) => {
+                    // Seal the tool-group
+                    let base = prev;
+                    const gi = toolGroupIndexRef.current;
+                    if (gi !== null && base[gi]?.role === 'tool-group') {
+                        const names = base[gi].content.split(' · ');
+                        const count = names.length;
+                        const summary = count <= 3
+                            ? `[${names.join(' · ')}]`
+                            : `[${count} tools: ${names.slice(0, 2).join(', ')}, …]`;
+                        base = [...base.slice(0, gi), { role: 'tool-group', content: summary }, ...base.slice(gi + 1)];
+                        toolGroupIndexRef.current = null;
+                    }
+                    const last = base[base.length - 1];
+                    if (last && last.role === 'assistant') {
+                        return [...base.slice(0, -1), { role: 'assistant', content: assistantText }];
+                    }
+                    return [...base, { role: 'assistant', content: assistantText }];
+                });
+            }),
+            loop.eventBus.subscribe('session-start', (e) => {
+                if (e.type === 'session-start') {
+                    sessionIdRef.current = e.id;
+                    globalThis.__hopperSessionId = e.id;
+                }
+            }),
+            loop.eventBus.subscribe('usage', (e) => {
+                if (e.type === 'usage') {
+                    setInputTokens(e.inputTokens);
+                    setOutputTokens(e.outputTokens);
+                }
+            }),
+            loop.eventBus.subscribe('tool-call', (e) => {
+                if (e.type !== 'tool-call')
+                    return;
+                // Extract a human-readable detail from the tool input.
+                const detail = (() => {
+                    const data = e.input;
+                    if (data.path && typeof data.path === 'string')
+                        return data.path;
+                    if (data.file_path && typeof data.file_path === 'string')
+                        return data.file_path;
+                    if (data.path && typeof data.path === 'number')
+                        return String(data.path);
+                    if (data.query && typeof data.query === 'string')
+                        return data.query;
+                    if (data.url && typeof data.url === 'string')
+                        return data.url;
+                    if (data.text && typeof data.text === 'string')
+                        return data.text;
+                    if (data.command && typeof data.command === 'string')
+                        return data.command;
+                    if (data.prompt && typeof data.prompt === 'string')
+                        return data.prompt.slice(0, 80);
+                    if (Object.keys(data).length > 0) {
+                        return Object.entries(data).map(([k, v]) => `${k}=${typeof v === 'string' ? v : JSON.stringify(v)}`).join(', ');
+                    }
+                    return '';
+                })();
+                const display = detail ? `${e.name}: ${detail}` : e.name;
+                // Update both per-channel and legacy messages
+                const updateToolCall = (msgs) => {
+                    const gi = toolGroupIndexRef.current;
+                    if (gi !== null && msgs[gi]?.role === 'tool-group') {
+                        const updated = { ...msgs[gi], content: `${msgs[gi].content} · ${display}` };
+                        return [...msgs.slice(0, gi), updated, ...msgs.slice(gi + 1)];
+                    }
+                    toolGroupIndexRef.current = msgs.length;
+                    return [...msgs, { role: 'tool-group', content: display }];
+                };
+                setChannelMessages((prev) => {
+                    const chMsgs = prev[targetChannel] || [];
+                    return { ...prev, [targetChannel]: updateToolCall(chMsgs) };
+                });
+                setMessages((prev) => updateToolCall(prev));
+            }),
+            loop.eventBus.subscribe('tool-result', (e) => {
+                if (e.type !== 'tool-result')
+                    return;
+                if (e.error) {
+                    const resultMsg = { role: 'tool', content: `Error: ${e.error}` };
+                    setChannelMessages((prev) => ({ ...prev, [targetChannel]: [...(prev[targetChannel] || []), resultMsg] }));
+                    setMessages((prev) => [...prev, resultMsg]);
+                    return;
+                }
+                // Detect plan file creation: Write result referencing plans/*.md while in plan mode.
+                if (currentMode === 'plan' && e.output && typeof e.output === 'object') {
+                    const path = e.output.path;
+                    if (typeof path === 'string' && /plans[\\/][^\\/]+\.md$/i.test(path)) {
+                        planFileRef.current = path;
+                    }
+                }
+            }),
+            loop.eventBus.subscribe('error', (e) => {
+                if (e.type === 'error') {
+                    const errMsg = { role: 'tool', content: 'Error: ' + e.message };
+                    setChannelMessages((prev) => ({ ...prev, [targetChannel]: [...(prev[targetChannel] || []), errMsg] }));
+                    setMessages((prev) => [...prev, errMsg]);
+                }
+            }),
+            loop.eventBus.subscribe('approval-request', (e) => {
+                if (e.type === 'approval-request' && e.decision === 'ask') {
+                    pendingToolCallIdRef.current = e.toolCallId;
+                }
+            }),
+        ];
+        let runResult;
+        try {
+            runResult = await loop.run(text);
+        }
+        finally {
+            // Update channel registry with the real session ID (handles placeholder → real session)
+            if (runResult) {
+                channelRegistry.updateSession(targetChannel, runResult.sessionId);
+            }
+            unsubs.forEach(u => u());
+            toolGroupIndexRef.current = null;
+            busyRef.current = false;
+            setStatus('idle');
+            // Route response back to Telegram if this is a Telegram channel
+            const telegramChatId = channelRouter.getTelegramChatId(targetChannel);
+            if (telegramChatId && assistantText) {
+                const text = assistantText.length > 4096 ? assistantText.slice(0, 4096) : assistantText;
+                await channelRouter.sendTelegramResponse(telegramChatId, text).catch(console.error);
+                telegramGateway?.stopTyping(telegramChatId);
+            }
+            else {
+                // Fallback: legacy Telegram routing for main channel
+                const chatId = telegramChatIdRef.current;
+                if (chatId && assistantText) {
+                    const text = assistantText.length > 4096 ? assistantText.slice(0, 4096) : assistantText;
+                    telegramGateway?.sendMessage(chatId, text).catch(console.error);
+                    telegramGateway?.stopTyping(chatId);
+                }
+                telegramChatIdRef.current = null;
+            }
+        }
+        // Post-turn: if a plan file was just written, auto-switch to `auto` mode
+        // and tell the user so they can approve by sending the next message.
+        if (planFileRef.current) {
+            const pf = planFileRef.current;
+            planFileRef.current = null;
+            const planMsg = {
+                role: 'system',
+                content: `Plan written to ${pf}. Switching to auto mode — send any message to execute, or /mode plan to keep planning.`,
+            };
+            setChannelMessages((prev) => ({
+                ...prev,
+                [targetChannel]: [...(prev[targetChannel] || []), planMsg],
+            }));
+            setMessages(prev => [...prev, planMsg]);
+            setCurrentMode('auto');
+            settingsMgr.current.update({ mode: 'auto' });
+        }
+    }, [streamProviderHolder, currentModel, currentMode, currentCwd, currentSystem, currentDebug, currentEffort, activeChannelId, channelMessages, channelRegistry, channelRouter]);
+    // Wire submit ref so gateway can inject Telegram messages into the turn loop
+    useEffect(() => {
+        telegramSubmitRef.current = onSubmit;
+    }, [onSubmit, telegramSubmitRef]);
+    const onBashCommand = useCallback((command) => {
+        if (busyRef.current)
+            return;
+        busyRef.current = true;
+        setStatus('running shell');
+        setMessages(prev => [...prev, { role: 'user', content: `! ${command}` }]);
+        // Handle `cd` (and `chdir`) ourselves so directory changes persist across
+        // subsequent `!` invocations. Match: cd, cd <arg>, cd "a b"/'a b', chdir.
+        const cdMatch = command.trim().match(/^(?:cd|chdir)(?:\s+(.+))?\s*$/i);
+        if (cdMatch) {
+            const rawArg = (cdMatch[1] ?? '').trim();
+            const stripped = rawArg
+                .replace(/^"(.*)"$/, '$1')
+                .replace(/^'(.*)'$/, '$1');
+            const target = stripped.length === 0
+                ? homedir()
+                : stripped === '-'
+                    ? shellCwdRef.current
+                    : stripped.startsWith('~')
+                        ? resolve(homedir(), stripped.slice(1).replace(/^[\\/]/, ''))
+                        : isAbsolute(stripped)
+                            ? stripped
+                            : resolve(shellCwdRef.current, stripped);
+            let content;
+            if (!existsSync(target)) {
+                content = `$ ${command}\ncd: no such directory: ${target}\n[exit 1]`;
+            }
+            else if (!statSync(target).isDirectory()) {
+                content = `$ ${command}\ncd: not a directory: ${target}\n[exit 1]`;
+            }
+            else {
+                shellCwdRef.current = target;
+                content = `$ ${command}\n${target}\n[exit 0]`;
+            }
+            setMessages(prev => [...prev, { role: 'tool', content }]);
+            busyRef.current = false;
+            setStatus('idle');
+            return;
+        }
+        const isWin = process.platform === 'win32';
+        const shell = isWin ? (process.env.ComSpec || 'cmd.exe') : '/bin/sh';
+        const shellArgs = isWin ? ['/c', command] : ['-c', command];
+        const child = spawn(shell, shellArgs, {
+            cwd: shellCwdRef.current,
+            env: process.env,
+        });
+        shellChildRef.current = child;
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', d => { stdout += d.toString(); });
+        child.stderr?.on('data', d => { stderr += d.toString(); });
+        child.on('close', code => {
+            const output = [stdout.trimEnd(), stderr.trimEnd()].filter(Boolean).join('\n');
+            const content = output.length
+                ? `$ ${command}\n${output}\n[exit ${code ?? 0}]`
+                : `$ ${command}\n[exit ${code ?? 0}]`;
+            setMessages(prev => [...prev, { role: 'tool', content }]);
+            shellChildRef.current = null;
+            busyRef.current = false;
+            setStatus('idle');
+        });
+        child.on('error', err => {
+            setMessages(prev => [
+                ...prev,
+                { role: 'tool', content: `$ ${command}\nError: ${err.message}` },
+            ]);
+            shellChildRef.current = null;
+            busyRef.current = false;
+            setStatus('idle');
+        });
+    }, []);
+    const onEffortChange = useCallback((effort) => {
+        setCurrentEffort(effort);
+        settingsMgr.current.update({ effort: effort });
+        loopRef.current = null;
+        const usr = { role: 'user', content: `/effort ${effort}` };
+        const asst = { role: 'assistant', content: `Effort set to ${effort}.` };
+        setChannelMessages((prev) => {
+            const ch = prev[activeChannelId] || [];
+            return { ...prev, [activeChannelId]: [...ch, usr, asst] };
+        });
+        setMessages(prev => [...prev, usr, asst]);
+    }, []);
+    const onModeChange = useCallback((mode) => {
+        setCurrentMode(mode);
+        settingsMgr.current.update({ mode: mode });
+        // Rebuild the TurnLoop on next turn so the permission engine picks up
+        // the new approval mode.
+        loopRef.current = null;
+        const usr = { role: 'user', content: `/mode ${mode}` };
+        const asst = { role: 'assistant', content: `Mode set to ${mode}.` };
+        setChannelMessages((prev) => {
+            const ch = prev[activeChannelId] || [];
+            return { ...prev, [activeChannelId]: [...ch, usr, asst] };
+        });
+        setMessages(prev => [...prev, usr, asst]);
+    }, []);
+    const onInterrupt = useCallback(() => {
+        let interrupted = false;
+        if (loopRef.current && busyRef.current) {
+            loopRef.current.cancel();
+            interrupted = true;
+        }
+        if (shellChildRef.current) {
+            try {
+                shellChildRef.current.kill('SIGTERM');
+            }
+            catch {
+                // ignore — child may have already exited
+            }
+            interrupted = true;
+        }
+        if (interrupted) {
+            setMessages(prev => [...prev, { role: 'system', content: '[interrupted]' }]);
+        }
+    }, []);
+    const onApprovalDecision = useCallback((decision) => {
+        setPendingApproval(prev => {
+            if (prev)
+                prev.resolve(decision === 'allow');
+            return null;
+        });
+        // Also clean up any stale Telegram pending approvals for this tool call
+        const currentToolCallId = pendingToolCallIdRef.current;
+        if (currentToolCallId) {
+            pendingApprovalsRef.current.delete(currentToolCallId);
+        }
+    }, []);
+    const onSelectProject = useCallback((p) => {
+        if (!existsSync(p.projectPath) || !statSync(p.projectPath).isDirectory()) {
+            setMessages(prev => [...prev, { role: 'system', content: `Cannot switch to project: directory not found (${p.projectPath})` }]);
+            return;
+        }
+        setCurrentCwd(p.projectPath);
+        shellCwdRef.current = p.projectPath;
+        setCurrentSystem(loadAgentPrompt(p.projectPath));
+        loopRef.current = null;
+        setMessages(prev => [...prev, { role: 'system', content: `Active project switched to ${p.label} (${p.projectPath})` }]);
+    }, []);
+    const project = basename(currentCwd);
+    const cost = estimateCost(currentModel, inputTokens ?? 0, outputTokens ?? 0);
+    // Build channel entries for the Channels tab
+    const channelList = channelRegistry.list();
+    const channelTabEntries = channelList.map(ch => ({
+        id: ch.id,
+        type: ch.type,
+        identifier: ch.identifier,
+        displayName: ch.displayName,
+        sessionId: ch.sessionId,
+        messageCount: (channelMessages[ch.id] || []).length,
+        isActive: ch.id === activeChannelId,
+    }));
+    return (_jsx(ChatSurface, { messages: channelMessages[activeChannelId] || [], model: currentModel, provider: currentProvider, approvalMode: currentMode, effort: currentEffort, inputTokens: inputTokens, outputTokens: outputTokens, contextWindowSize: contextWindowSize, project: project, duration: duration, costUsd: cost, activeTab: currentTab, status: status, contextMode: "CodeContext Zen", agent: currentModel, onSubmit: onSubmit, onSlashCommand: onSlashCommand, onBashCommand: onBashCommand, onInterrupt: onInterrupt, onEffortChange: onEffortChange, onModeChange: onModeChange, onCancel: () => process.exit(0), theme: theme, debug: currentDebug, projects: projects, agents: agents, channels: channelTabEntries, onChannelSelect: (channelId) => {
+            setActiveChannelId(channelId);
+            settingsMgr.current.update({ CHANNEL_TAB_ACTIVE: channelId });
+            setCurrentTab('assistant');
+        }, pendingApproval: pendingApproval ? {
+            toolName: pendingApproval.toolName,
+            input: pendingApproval.input,
+            reason: pendingApproval.reason,
+        } : null, onApprovalDecision: onApprovalDecision, onSelectProject: onSelectProject }));
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function createProvider(settings) {
+    const providerName = typeof settings.MODEL_PROVIDER === 'string'
+        ? settings.MODEL_PROVIDER.trim().toLowerCase()
+        : 'anthropic';
+    if (providerName === 'openai') {
+        const openaiKey = (typeof settings.OPENAI_API_KEY === 'string' ? settings.OPENAI_API_KEY.trim() : '') ||
+            process.env.OPENAI_API_KEY ||
+            '';
+        const openaiUrl = (typeof settings.OPENAI_URL === 'string' ? settings.OPENAI_URL.trim() : '') ||
+            process.env.OPENAI_BASE_URL ||
+            '';
+        if (!openaiKey) {
+            console.error('hopper-agent: no OpenAI API key configured.\n' +
+                '  Run `hopper-agent` and use `/init` to configure, or set "OPENAI_API_KEY" in ~/.hopper-agent/settings.json.');
+            return null;
+        }
+        const p = new OpenAIProvider(openaiKey, openaiUrl || undefined);
+        return { name: p.name, stream: p.stream.bind(p), check: p.check.bind(p) };
+    }
+    if (providerName === 'openrouter') {
+        const orKey = (typeof settings.OPENROUTER_API_KEY === 'string' ? settings.OPENROUTER_API_KEY.trim() : '') ||
+            process.env.OPENROUTER_API_KEY ||
+            '';
+        const orUrl = (typeof settings.OPENROUTER_URL === 'string' ? settings.OPENROUTER_URL.trim() : '') ||
+            process.env.OPENROUTER_URL ||
+            'https://openrouter.ai/api/v1';
+        if (!orKey) {
+            console.error('hopper-agent: no OpenRouter API key configured.\n' +
+                '  Run `hopper-agent` and use `/init` to configure, or set "OPENROUTER_API_KEY" in ~/.hopper-agent/settings.json.');
+            return null;
+        }
+        const p = new AnthropicProvider(orKey, orUrl);
+        return { name: 'openrouter', stream: p.stream.bind(p), check: p.check.bind(p) };
+    }
+    if (providerName === 'local') {
+        const localKey = (typeof settings.MODEL_API_KEY === 'string' ? settings.MODEL_API_KEY.trim() : '') ||
+            process.env.MODEL_API_KEY ||
+            '';
+        const localUrl = (typeof settings.MODEL_URL === 'string' ? settings.MODEL_URL.trim() : '') ||
+            process.env.MODEL_URL ||
+            '';
+        if (!localKey && !localUrl) {
+            console.error('hopper-agent: no local provider config.\n' +
+                '  Run `hopper-agent` and use `/init` to configure, or set "MODEL_API_KEY" and "MODEL_URL" in ~/.hopper-agent/settings.json.');
+            return null;
+        }
+        const p = new AnthropicProvider(localKey || undefined, localUrl || undefined, { local: true });
+        return { name: 'local', stream: p.stream.bind(p), check: p.check.bind(p) };
+    }
+    // anthropic (default)
+    const fromSettingsKey = typeof settings.MODEL_API_KEY === 'string' ? settings.MODEL_API_KEY.trim() : '';
+    const fromSettingsUrl = typeof settings.MODEL_URL === 'string' ? settings.MODEL_URL.trim() : '';
+    const apiKey = fromSettingsKey || process.env.ANTHROPIC_API_KEY || '';
+    const baseUrl = fromSettingsUrl || process.env.ANTHROPIC_BASE_URL || '';
+    if (!apiKey) {
+        console.error('hopper-agent: no API key configured.\n' +
+            `  Looked at ~/.hopper-agent/settings.json (MODEL_API_KEY = ${fromSettingsKey ? '[set]' : '[missing/empty]'}),\n` +
+            `  and ANTHROPIC_API_KEY env var (${process.env.ANTHROPIC_API_KEY ? '[set]' : '[missing]'}).\n` +
+            '  Run `hopper-agent` and use `/init` to configure, or set "MODEL_API_KEY" in ~/.hopper-agent/settings.json.');
+        return null;
+    }
+    const p = new AnthropicProvider(apiKey, baseUrl || undefined);
+    return { name: p.name, stream: p.stream.bind(p), check: p.check.bind(p) };
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const cwd = args.cwd || process.cwd();
+    if (args.version) {
+        console.log(`hopper-agent ${VERSION}`);
+        process.exit(0);
+    }
+    if (args.help) {
+        printHelp();
+        process.exit(0);
+    }
+    // Load persisted settings
+    const settingsManager = new SettingsManager();
+    const settings = settingsManager.load();
+    // CLI flags override settings, settings override defaults
+    const model = args.model || settings.model || DEFAULT_SETTINGS.model;
+    const themeName = settings.theme || DEFAULT_SETTINGS.theme;
+    const approvalMode = args.approvalMode || settings.mode || DEFAULT_SETTINGS.mode;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const streamProviderHolder = { current: null };
+    streamProviderHolder.current = createProvider(settings);
+    const system = loadAgentPrompt(cwd);
+    // Initialize cron manager for reminders
+    const cronManager = new CronManager();
+    // Auto-create unified heartbeat task if HEARTBEAT=on
+    const hbSettings = cronManager.load();
+    const s = settingsManager.load();
+    if (s.HEARTBEAT === 'on' && !hbSettings.tasks.some((t) => t.type === 'heartbeat')) {
+        const picked = pickNextSchedule({
+            HEARTBEAT_TIMES: s.HEARTBEAT_TIMES,
+            HEARTBEAT_DAILY: s.HEARTBEAT_DAILY,
+            HEARTBEAT_WEEKLY: s.HEARTBEAT_WEEKLY,
+            HEARTBEAT_MONTHLY: s.HEARTBEAT_MONTHLY,
+        }, Date.now());
+        if (picked) {
+            cronManager.createHeartbeat('Heartbeat: unified schedule', picked);
+            console.error(`[cron] Created unified heartbeat task (${picked.type}: ${picked.value})`);
+        }
+    }
+    else if (hbSettings.tasks.some((t) => t.type === 'heartbeat')) {
+        // Consolidate: if multiple pending heartbeat tasks exist, cancel duplicates
+        const hbTasks = hbSettings.tasks.filter((t) => t.type === 'heartbeat' && t.status === 'pending');
+        if (hbTasks.length > 1) {
+            hbTasks.sort((a, b) => a.scheduledAt - b.scheduledAt);
+            for (const dup of hbTasks.slice(1)) {
+                dup.status = 'cancelled';
+                console.error('[cron] Consolidated duplicate heartbeat task');
+            }
+            cronManager.save();
+        }
+    }
+    // Mutable holder for the reminder notification callback.
+    // Created outside the component since hooks can't be called in main().
+    const onReminderHolder = { current: null };
+    // Ref to the submit function — the Telegram gateway uses this to inject messages into the turn loop
+    const telegramSubmitRef = { current: null };
+    // Ref to store the chat ID of the current Telegram conversation (set by gateway callback)
+    const telegramChatIdRef = { current: null };
+    // Ref to track the active channel for multi-channel support
+    const activeChannelRef = { current: null };
+    // Channel management for multi-channel conversation separation
+    const channelRegistry = new ChannelRegistry();
+    // Send function for ChannelRouter
+    const sendTelegram = async (chatId, text) => {
+        if (telegramGateway) {
+            await telegramGateway.sendMessage(chatId, text);
+        }
+    };
+    // Send approval request for ChannelRouter
+    const sendApproval = async (chatId, toolName, input, toolCallId) => {
+        if (telegramGateway) {
+            // Build a human-readable summary from the tool input
+            const data = input;
+            const esc = (s) => {
+                const str = typeof s === 'string' ? s : JSON.stringify(s);
+                return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/[^\x20-\x7E]/g, '');
+            };
+            let summary = '';
+            if (toolName === 'Edit') {
+                const filePath = esc(data.path ?? data.file_path ?? 'unknown');
+                const oldLines = esc(data.old_string)?.split('\n').slice(0, 3).join(' ') || '';
+                const newLines = esc(data.new_string)?.split('\n').slice(0, 3).join(' ') || '';
+                summary = `File: ${filePath}\n---\n${oldLines}\n+++\n${newLines}`;
+            }
+            else if (data.command && typeof data.command === 'string')
+                summary = 'Command: ' + esc(data.command);
+            else if (data.path && typeof data.path === 'string')
+                summary = 'Path: ' + esc(data.path);
+            else if (data.file_path && typeof data.file_path === 'string')
+                summary = 'Path: ' + esc(data.file_path);
+            else if (data.query && typeof data.query === 'string')
+                summary = 'Query: ' + esc(data.query);
+            else if (data.url && typeof data.url === 'string')
+                summary = 'URL: ' + esc(data.url);
+            else if (data.text && typeof data.text === 'string')
+                summary = 'Text: ' + esc(data.text).slice(0, 100);
+            else
+                summary = esc(JSON.stringify(data));
+            try {
+                await telegramGateway.sendApprovalRequest(chatId, toolCallId, toolName, summary);
+            }
+            catch (err) {
+                console.error('[cli] sendApproval failed:', err);
+            }
+        }
+    };
+    const channelRouter = new ChannelRouter(channelRegistry, sendTelegram, settingsManager, sendApproval);
+    // Create the "main" channel if it doesn't exist
+    const mainSessionId = ''; // Will be created on first turn
+    channelRegistry.getOrCreate('cli', 'main', mainSessionId, 'Main');
+    // Create Telegram gateway outside React lifecycle so it stays alive
+    let telegramGateway = null;
+    if (settings.TELEGRAM_BOT_TOKEN && settings.TELEGRAM_USER_ID) {
+        telegramGateway = new TelegramGateway({
+            botToken: settings.TELEGRAM_BOT_TOKEN,
+            allowedUserId: settings.TELEGRAM_USER_ID,
+            onUserMessage: (ctx) => {
+                console.error(`[telegram-gateway] onUserMessage: chatId=${ctx.chatId}, isGroup=${ctx.isGroup}`);
+                // Route through ChannelRouter to get the channel for this chat
+                const route = channelRouter.onTelegramMessage(ctx);
+                if (route) {
+                    // Store for response routing
+                    telegramChatIdRef.current = ctx.chatId;
+                    settingsManager.update({ TELEGRAM_CHAT_ID: ctx.chatId });
+                    // Set active channel so onSubmit knows where to route
+                    activeChannelRef.current = route.channelId;
+                    if (telegramSubmitRef.current) {
+                        telegramSubmitRef.current(ctx.text);
+                    }
+                    else {
+                        console.error('[telegram-gateway] No submit handler available');
+                    }
+                }
+                else {
+                    console.error('[telegram-gateway] Message rejected (group or channel error)');
+                }
+            },
+        });
+        telegramGateway.start().catch(console.error);
+        console.error(`[telegram-gateway] Bot started for user ${settings.TELEGRAM_USER_ID}`);
+    }
+    // --- MCP server connections ---
+    const mcpServersRaw = settings.MCP_SERVERS;
+    const mcpToolsRef = { current: [] };
+    const mcpClientsRef = { current: [] };
+    const mcpRawClientsRef = { current: [] };
+    const parseMcpConfigs = (raw) => {
+        if (!raw)
+            return [];
+        try {
+            const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+            return Object.values(parsed).map((v) => {
+                const r = v;
+                return {
+                    id: r.id ?? '',
+                    name: r.name ?? '',
+                    transport: r.transport ?? 'stdio',
+                    command: r.command,
+                    args: r.args,
+                    env: r.env,
+                    url: r.url,
+                    headers: r.headers,
+                };
+            });
+        }
+        catch {
+            return [];
+        }
+    };
+    const reconnectMcp = async () => {
+        // Disconnect existing clients
+        for (const client of mcpRawClientsRef.current) {
+            client.disconnect().catch(() => { });
+        }
+        mcpRawClientsRef.current = [];
+        mcpClientsRef.current = [];
+        mcpToolsRef.current = [];
+        // Read fresh settings from disk so we pick up settingsManager updates
+        const freshSettings = settingsManager.get();
+        const configs = parseMcpConfigs(freshSettings.MCP_SERVERS);
+        if (configs.length > 0) {
+            try {
+                console.error(`[mcp] Reconnecting to ${configs.length} MCP server(s)...`);
+                const result = await createMcpTools(configs);
+                mcpToolsRef.current = result.tools;
+                mcpClientsRef.current = result.clients.map((c) => ({
+                    serverId: c.serverId,
+                    isConnected: c.isConnected,
+                    tools: c.tools,
+                }));
+                mcpRawClientsRef.current = result.clients;
+                console.error(`[mcp] Connected — ${mcpToolsRef.current.length} tool(s) from ${mcpClientsRef.current.length} server(s)`);
+            }
+            catch (err) {
+                console.error(`[mcp] Reconnect failed: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+    };
+    // Initial MCP connection
+    if (mcpServersRaw && (typeof mcpServersRaw === 'string' || typeof mcpServersRaw === 'object')) {
+        try {
+            const configs = parseMcpConfigs(mcpServersRaw);
+            if (configs.length > 0) {
+                console.error(`[mcp] Connecting to ${configs.length} MCP server(s)...`);
+                const result = await createMcpTools(configs);
+                mcpToolsRef.current = result.tools;
+                mcpClientsRef.current = result.clients.map((c) => ({
+                    serverId: c.serverId,
+                    isConnected: c.isConnected,
+                    tools: c.tools,
+                }));
+                mcpRawClientsRef.current = result.clients;
+                console.error(`[mcp] Connected — ${mcpToolsRef.current.length} tool(s) exposed from ${mcpClientsRef.current.length} server(s)`);
+            }
+        }
+        catch (err) {
+            console.error(`[mcp] Failed to load MCP configs: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    const mergedTools = [...allTools, ...mcpToolsRef.current];
+    if (args.prompt && args.headless) {
+        const loop = new TurnLoop({
+            provider: streamProviderHolder.current,
+            model,
+            tools: mergedTools,
+            cwd,
+            settings,
+            approvalMode: args.approvalMode || 'yolo',
+            effort: settings.effort,
+            system,
+        });
+        loop.eventBus.subscribe('assistant-delta', (e) => {
+            if (e.type === 'assistant-delta') {
+                process.stdout.write(e.text);
+            }
+        });
+        const result = await loop.run(args.prompt);
+        process.exit(result.reason === 'error' ? 1 : 0);
+    }
+    // Switch to the alternate screen buffer so the TUI owns the full window and
+    // the header stays pinned at the top. Restore on exit. We also override the
+    // terminal's default background via OSC 11 so the unpainted cells (padding,
+    // gaps between widgets) match the theme instead of showing whatever color
+    // the user's terminal profile happens to use.
+    const theme = getTheme(themeName);
+    const ENTER_ALT = '\x1b[?1049h\x1b[H';
+    const LEAVE_ALT = '\x1b[?1049l';
+    const SET_BG = `\x1b]11;${theme.background}\x07`;
+    const RESET_BG = '\x1b]111\x07';
+    process.stdout.write(ENTER_ALT + SET_BG);
+    let restored = false;
+    const restore = () => {
+        if (restored)
+            return;
+        restored = true;
+        // Disconnect MCP clients
+        for (const client of mcpRawClientsRef.current) {
+            client.disconnect().catch(() => { });
+        }
+        process.stdout.write(RESET_BG + LEAVE_ALT);
+        const id = globalThis.__hopperSessionId;
+        if (id) {
+            process.stdout.write(`\nSession saved. Resume with: hopper-agent resume ${id}\n`);
+        }
+    };
+    process.on('exit', restore);
+    process.on('SIGINT', () => {
+        telegramGateway?.stop();
+        cronManager.stopChecker();
+        for (const client of mcpRawClientsRef.current) {
+            client.disconnect().catch(() => { });
+        }
+        restore();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        telegramGateway?.stop();
+        cronManager.stopChecker();
+        for (const client of mcpRawClientsRef.current) {
+            client.disconnect().catch(() => { });
+        }
+        restore();
+        process.exit(0);
+    });
+    const claudeProjects = loadClaudeProjects();
+    // Start the background checker — fires reminders every 60 seconds.
+    // Notification rendering is handled by App via onReminderHolder.
+    // Telegram sends happen here (in main()'s closure) so settingsManager
+    // is always fresh — never stale from React props.
+    cronManager.startChecker(60_000, async (task) => {
+        console.error(`[cron] Fired: ${task.message}`);
+        // Handle heartbeat tasks
+        if (task.type === 'heartbeat' && task.schedule) {
+            const scheduleType = task.schedule.type;
+            const settings = settingsManager.load();
+            if (settings.HEARTBEAT !== 'on') {
+                console.error(`[cron] Heartbeat disabled, skipping: ${scheduleType}`);
+                return;
+            }
+            console.error(`[cron] Running heartbeat: ${scheduleType}`);
+            const mcpTools = mcpToolsRef.current;
+            const heartbeatTools = mcpTools.length > 0
+                ? [...allTools, ...mcpTools]
+                : allTools;
+            const executor = new HeartbeatExecutor({
+                provider: streamProviderHolder.current,
+                model: settings.model,
+                tools: heartbeatTools,
+                cwd: cwd,
+                settings,
+                effort: 'auto',
+                scheduleType,
+            });
+            try {
+                const result = await executor.execute();
+                const formatted = HeartbeatDelivery.formatBrief(result);
+                const label = `[${scheduleLabel(task.schedule.type)}] `;
+                // Deliver to Telegram if configured
+                const tgChatId = settings.TELEGRAM_CHAT_ID || null;
+                const tgChat = tgChatId ?? telegramChatIdRef.current;
+                if (tgChat && telegramGateway) {
+                    await telegramGateway.sendMessage(tgChat, label + formatted);
+                }
+                // Re-evaluate all four schedules and update the task's next fire time
+                const currentSettings = settingsManager.load();
+                cronManager.rescheduleFromSettings({
+                    HEARTBEAT_TIMES: currentSettings.HEARTBEAT_TIMES,
+                    HEARTBEAT_DAILY: currentSettings.HEARTBEAT_DAILY,
+                    HEARTBEAT_WEEKLY: currentSettings.HEARTBEAT_WEEKLY,
+                    HEARTBEAT_MONTHLY: currentSettings.HEARTBEAT_MONTHLY,
+                });
+                // Show in TUI via reminder holder (attaches brief to task for UI)
+                const briefTask = task;
+                briefTask.heartbeatBrief = formatted;
+                onReminderHolder.current?.(briefTask);
+            }
+            catch (err) {
+                console.error(`[cron] Heartbeat failed:`, err instanceof Error ? err.message : err);
+            }
+            return;
+        }
+        // Original reminder handling
+        const cb = onReminderHolder.current;
+        if (cb)
+            cb(task);
+        else
+            console.error(`[cron] Reminder fired: ${task.message} but no UI handler`);
+        // Send to Telegram if configured — settings.json is the source of truth
+        const settings = settingsManager.load(); // reload from disk
+        const settingsChatId = settings.TELEGRAM_CHAT_ID || null;
+        const chatId = settingsChatId ?? telegramChatIdRef.current;
+        console.error(`[cron] telegramGateway=${!!telegramGateway} chatId=${chatId} botToken=${!!settings.TELEGRAM_BOT_TOKEN} settings.TELEGRAM_CHAT_ID=${settings.TELEGRAM_CHAT_ID}`);
+        if (chatId && telegramGateway) {
+            const timeStr = new Date(task.scheduledAt).toLocaleString();
+            const reminderText = `Hopper reminder:\nDate: ${timeStr}\n${task.message}`;
+            console.error(`[cron] Sending to Telegram chat ${chatId}: ${reminderText}`);
+            telegramGateway.sendMessage(chatId, reminderText).catch((err) => {
+                console.error('[cron] Telegram send failed:', err instanceof Error ? err.message : err);
+            });
+        }
+    });
+    console.error(`[cron] Checker started. Pending: ${cronManager.pendingCount}`);
+    render(_jsx(App, { provider: streamProviderHolder.current, streamProviderHolder: streamProviderHolder, model: model, approvalMode: approvalMode, cwd: cwd, themeName: themeName, system: system, settings: settings, projects: claudeProjects, cronManager: cronManager, onReminderHolder: onReminderHolder, telegramChatIdRef: telegramChatIdRef, telegramSubmitRef: telegramSubmitRef, telegramGateway: telegramGateway, channelRegistry: channelRegistry, channelRouter: channelRouter, activeChannelRef: activeChannelRef, mcpToolsRef: mcpToolsRef, mcpClientsRef: mcpClientsRef, onMcpReconnect: reconnectMcp, contextWindowSize: 200_000 }), {
+        exitOnCtrlC: false,
+    });
+}
+main().catch((err) => {
+    console.error('hopper-agent error:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map