hyacinth-ai 0.9.6

package/dist/gateway/tui.js

@@ -0,0 +1,3273 @@
+/**
+ * TUI Gateway — pi-tui component-based terminal UI for the Agent framework.
+ *
+ * Powered by @earendil-works/pi-tui.
+ *
+ * Layout (top to bottom):
+ *   headerContainer — Agent · model · Turns · Mode · Provider
+ *   contextBarText  — Context ████░░░░ 45%
+ *   chatLog         — message history (grows to fill)
+ *   footerText      — Ctrl+C exit | Ctrl+L clear | ...
+ *   editor          — user input area
+ */
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import http from 'node:http';
+import { CombinedAutocompleteProvider, Container, Key, Loader, matchesKey, ProcessTerminal, Text, TUI, } from '@earendil-works/pi-tui';
+import { StatsManager } from '../memory/stats.js';
+import { ConfigManager } from '../setup/config.js';
+import { getModelContextWindow } from '../setup/model-defaults.js';
+import { RuntimeConfigCenter } from '../runtime/config-center.js';
+import { ProviderManager } from '../provider/manager.js';
+import { LifecycleSupervisor } from '../lifecycle/index.js';
+import { createAgent } from './factory.js';
+import { getBootstrapStatus, DEFAULT_PERSONA_DIR } from '../setup/persona-bootstrap.js';
+import { createLogger } from '../logging/logger.js';
+import { TuiChannel } from '../channels/builtin/tui-channel.js';
+import { ChannelManager } from '../channels/manager.js';
+import { MessageQueue, QueueMessageMode } from '../channels/index.js';
+import { registerConfigChannels, getChannelPlugins } from '../channels/auto-detect.js';
+import { filterCommands, getCommandsByCategory, getCategoryLabel, } from '../ui/slash-commands.js';
+import { SlashSubPanel } from '../ui/slash-panel.js';
+import { CommandRegistry } from '../ui/command-registry.js';
+import { ChatLog } from '../ui/chat-log.js';
+import { CustomEditor } from '../ui/pi-tui-editor.js';
+import { theme, editorTheme } from '../ui/theme.js';
+import { readRecentEvents } from '../event-store.js';
+import { LocalModelModule } from '../local-model/index.js';
+import { setAskUserHandler } from '../tools/ask-user.js';
+const logger = createLogger('tui');
+// ─── Constants ────────────────────────────────────────────────────────────
+const BOX_H = '\u2500'; // ─
+// ─── Status Bar Formatters ────────────────────────────────────────────────
+function visualWidth(s) {
+    let w = 0;
+    for (const ch of s) {
+        const cp = ch.codePointAt(0) ?? 0;
+        // CJK, fullwidth forms, emoji: count as 2
+        w += (cp >= 0x1100 && cp <= 0x115f) || // Hangul Jamo
+            (cp >= 0x2e80 && cp <= 0xa4cf) || // CJK Radicals, Kangxi, Ideographs
+            (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables
+            (cp >= 0xf900 && cp <= 0xfaff) || // CJK Compatibility Ideographs
+            (cp >= 0xfe10 && cp <= 0xfe19) || // Vertical forms
+            (cp >= 0xfe30 && cp <= 0xfe6f) || // CJK Compatibility Forms
+            (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth Forms
+            (cp >= 0xffe0 && cp <= 0xffe6) || // Fullwidth Signs
+            (cp >= 0x1f300 && cp <= 0x1f9ff) || // Emoji & Symbols
+            (cp >= 0x20000 && cp <= 0x2fa1f) // CJK Extension
+            ? 2 : 1;
+    }
+    return w;
+}
+function truncateByVisualWidth(s, maxVisualWidth) {
+    if (visualWidth(s) <= maxVisualWidth)
+        return s;
+    let w = 0;
+    let result = '';
+    for (const ch of s) {
+        const cw = visualWidth(ch);
+        if (w + cw + 3 > maxVisualWidth) {
+            result += '...';
+            break;
+        }
+        w += cw;
+        result += ch;
+    }
+    return result;
+}
+function formatStatusBar(info, modelName, providerInfo, modeLabel) {
+    const planInfo = info.planStepsTotal !== undefined
+        ? `Plan: ${info.planStepsDone ?? 0}/${info.planStepsTotal}`
+        : '';
+    const modelDisplay = truncateByVisualWidth(modelName, 28);
+    const providerPart = providerInfo
+        ? theme.dim(' | ') +
+            'Provider: ' +
+            (providerInfo.isLocal ? theme.success : theme.accent)(providerInfo.providerLabel)
+        : '';
+    const parts = [
+        theme.fg(' Hyacinth'),
+        theme.dim(' \u00b7 '),
+        theme.accent(modelDisplay),
+        theme.dim(' | '),
+        `Turns: ${theme.fg(String(info.turnCount))}/${theme.fg(String(info.maxTurns))}`,
+        providerPart,
+    ];
+    if (planInfo) {
+        parts.push(theme.dim(' | '), planInfo);
+    }
+    if (modeLabel) {
+        parts.push(theme.dim(' | '), theme.accent(modeLabel));
+    }
+    return parts.join('');
+}
+function formatContextBar(tokensUsed, maxTokens, width = 40) {
+    const ratio = Math.min(tokensUsed / maxTokens, 1);
+    const filledW = Math.floor(ratio * width);
+    const emptyW = width - filledW;
+    const bar = '\u2588'.repeat(filledW) + '\u2591'.repeat(emptyW);
+    let colorFn;
+    if (ratio < 0.5)
+        colorFn = theme.success;
+    else if (ratio < 0.8)
+        colorFn = theme.warning;
+    else
+        colorFn = theme.error;
+    const usedK = (tokensUsed / 1000).toFixed(0) + 'K';
+    const maxK = (maxTokens / 1000).toFixed(0) + 'K';
+    const pct = (ratio * 100).toFixed(0) + '%';
+    return theme.dim('Context: ') + colorFn(bar) + ' ' + theme.fg(pct) + theme.dim(` (${usedK} / ${maxK} tokens)`);
+}
+// ─── Event Replay ─────────────────────────────────────────────────────────
+/**
+ * Replay recent events from the previous session into the chat log.
+ * Shows the last conversation on TUI re-entry.
+ */
+function replayEvents(chatLog, sessionDir) {
+    readRecentEvents(sessionDir, 50).then(events => {
+        if (events.length === 0)
+            return;
+        chatLog.addSystem('── Previous Session ──');
+        let pendingText = '';
+        let pendingThinking = '';
+        let userMsgSeen = false;
+        for (const event of events) {
+            switch (event.type) {
+                case 'user_input':
+                    // Flush any pending thinking + text before showing user message
+                    if (pendingThinking) {
+                        pendingThinking = '';
+                    }
+                    if (pendingText) {
+                        chatLog.addSystem(pendingText);
+                        pendingText = '';
+                    }
+                    chatLog.addUser(event.content || '');
+                    userMsgSeen = true;
+                    break;
+                case 'text':
+                    // Accumulate text chunks into one message
+                    pendingText += event.content || '';
+                    break;
+                case 'thinking':
+                    pendingThinking += event.content || '';
+                    break;
+                case 'tool_call':
+                    // Flush pending thinking + text before tool call
+                    if (pendingThinking) {
+                        pendingThinking = '';
+                    }
+                    if (pendingText) {
+                        chatLog.addSystem(pendingText);
+                        pendingText = '';
+                    }
+                    chatLog.startTool(event.id || 'replay', event.name || 'unknown', JSON.stringify(event.input || {}).slice(0, 100));
+                    break;
+                case 'tool_result':
+                    chatLog.updateToolResult(event.tool_use_id || 'replay', (event.content || '').slice(0, 500), { isError: event.name === 'error' });
+                    break;
+                case 'error':
+                    // 跳过回放中的原始错误日志（避免旧 session 的 API 错误 JSON 污染 UI）
+                    break;
+                case 'stop':
+                    // Flush remaining thinking + text
+                    if (pendingThinking) {
+                        pendingThinking = '';
+                    }
+                    if (pendingText) {
+                        chatLog.addSystem(pendingText);
+                        pendingText = '';
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        // Flush any remaining thinking + text
+        if (pendingThinking) {
+            pendingThinking = '';
+        }
+        if (pendingText) {
+            chatLog.addSystem(pendingText);
+        }
+    }).catch(() => {
+        // Silently ignore replay errors — don't block TUI startup
+    });
+}
+// ─── Main TUI ─────────────────────────────────────────────────────────────
+export async function runTui(provider, sessionId, shouldContinue, maxTurns, maxContext, maxMessages = 10000, skipSetup, personaDir = DEFAULT_PERSONA_DIR, bootstrapStatus, localModelProvider, continuationMessage) {
+    // ── Force UTF-8 console encoding on Windows ──
+    if (process.platform === 'win32') {
+        try {
+            execSync('chcp 65001 > nul', { stdio: 'ignore' });
+        }
+        catch {
+            // non-fatal: terminal may still work with limited character support
+        }
+    }
+    // ── Redirect stderr to file ──
+    const logDir = path.join(os.homedir(), '.agent');
+    await fs.promises.mkdir(logDir, { recursive: true });
+    const logStream = fs.createWriteStream(path.join(logDir, 'tui.log'), { flags: 'a' });
+    const origStderrWrite = process.stderr.write.bind(process.stderr);
+    process.stderr.write = (chunk, ...args) => {
+        logStream.write(typeof chunk === 'string' ? chunk : String(chunk));
+        const cb = args[args.length - 1];
+        if (typeof cb === 'function')
+            cb();
+        return true;
+    };
+    // ── Provider ──
+    const configManager = new ConfigManager(process.cwd());
+    await configManager.loadEnvKeys();
+    let activeProvider = provider;
+    if (!provider.getModel() || provider.getModel() === '') {
+        try {
+            const manager = await ProviderManager.createFromConfigFile(undefined, process.cwd());
+            activeProvider = manager.getProvider();
+        }
+        catch {
+            // fallback
+        }
+    }
+    let providerTypeStart = activeProvider.getProviderType();
+    let modelName = activeProvider.getModel();
+    // ── Last known TurnInfo (updated each turn, used by /provider handler) ──
+    let lastTurnCount = 0;
+    let lastTokensUsed = 0;
+    // ── Lifecycle ──
+    const supervisor = new LifecycleSupervisor();
+    supervisor.installSignalHandlers();
+    // ── Local Model ──
+    const localModel = LocalModelModule.getInstance();
+    localModel.initialize(process.cwd());
+    let slashSubPanelActive = false; // 二级菜单激活时跳过主监听器的上下键处理
+    // ── TUI — pi-tui setup ──
+    const tui = new TUI(new ProcessTerminal());
+    const root = new Container();
+    // Header area: contains Text only (no Loader)
+    const headerContainer = new Container();
+    let headerText = new Text('', 0, 0);
+    headerContainer.addChild(headerText);
+    const contextBarText = new Text('', 0, 0);
+    const chatLog = new ChatLog();
+    const footerText = new Text('', 0, 0);
+    const editor = new CustomEditor(tui, editorTheme);
+    // Permission selection bar — shown between chat and editor during tool permission prompts
+    const permissionBar = new Text('', 0, 0);
+    const permissionQueue = [];
+    let permissionSelection = 0; // 0=Yes, 1=AOR, 2=Always, 3=No
+    let askUserState = null;
+    const askUserBar = new Text('', 0, 0);
+    const askUserContent = new Text('', 0, 0);
+    root.addChild(headerContainer);
+    root.addChild(chatLog);
+    root.addChild(contextBarText);
+    // Thinking indicator — below chatLog, above editor (prevents content jitter)
+    const thinkingBar = new Container();
+    let thinkingLoader = null;
+    root.addChild(thinkingBar);
+    root.addChild(footerText);
+    root.addChild(permissionBar);
+    root.addChild(askUserContent);
+    root.addChild(askUserBar);
+    root.addChild(editor);
+    tui.addChild(root);
+    tui.setFocus(editor);
+    // ── Header helpers — header always shows text (never Loader) ──
+    function updateHeaderText(text) {
+        headerText.setText(text);
+    }
+    // ── Thinking indicator helpers — Loader between chatLog and editor ──
+    function showThinkingIndicator(message) {
+        if (thinkingLoader) {
+            thinkingLoader.setMessage(message);
+            return thinkingLoader;
+        }
+        const loader = new Loader(tui, (spinner) => theme.accent(spinner), (text) => theme.accent(text), message);
+        thinkingBar.addChild(loader);
+        thinkingLoader = loader;
+        return loader;
+    }
+    function hideThinkingIndicator() {
+        if (thinkingLoader) {
+            thinkingLoader.stop();
+            thinkingBar.removeChild(thinkingLoader);
+            thinkingLoader = null;
+        }
+    }
+    // ── State for refreshStatus ──
+    let prevCompressCount = 0;
+    let compactionMessage = null;
+    let compressionLoader = null;
+    let compressionTimeout = null;
+    let prevProviderLabel = null;
+    let prevProviderIsLocal = false;
+    let fallbackMessage = null;
+    let isThinking = false;
+    function refreshStatus(info) {
+        // ── Track last known values for /provider handler ──
+        lastTurnCount = info.turnCount;
+        lastTokensUsed = info.tokensUsed;
+        // ── Read live config (overrides startup defaults) ──
+        const liveCfg = RuntimeConfigCenter.getInstance();
+        const liveMaxContext = liveCfg.get('session.maxContext');
+        const liveMaxTurns = liveCfg.get('session.maxTurns') || maxTurns;
+        const activeInfo = {
+            ...info,
+            maxTurns: liveMaxTurns,
+        };
+        // Compaction detection
+        if (info.compressCount > prevCompressCount) {
+            prevCompressCount = info.compressCount;
+            compactionMessage = '\u27f3 Compacting...';
+            setTimeout(() => {
+                compactionMessage = '\u2713 Compacted';
+                tui.requestRender();
+                setTimeout(() => {
+                    compactionMessage = null;
+                    tui.requestRender();
+                }, 2000);
+            }, 1000);
+        }
+        // Provider fallback detection \u2014 event-driven from onFallback callback
+        const providerInfo = loop.getProviderRoutingInfo();
+        if (providerInfo) {
+            if (prevProviderLabel !== null && providerInfo.providerLabel !== prevProviderLabel) {
+                // Provider changed via fallback \u2014 one-time notification already sent by onFallback
+                fallbackMessage = `\u26a0 Fallback: ${providerInfo.providerLabel}`;
+                setTimeout(() => { fallbackMessage = null; tui.requestRender(); }, 5000);
+            }
+            prevProviderLabel = providerInfo.providerLabel;
+            prevProviderIsLocal = providerInfo.isLocal;
+        }
+        const ap = loop.getActiveProvider();
+        const currentModel = ap.getModel();
+        const currentProviderType = ap.getProviderType();
+        const currentProviderInfo = providerInfo ?? { providerLabel: currentProviderType, isLocal: false, mode: 'auto' };
+        // Build mode label for header display
+        let modeHeaderLabel = null;
+        let statusContent = formatStatusBar(activeInfo, currentModel, currentProviderInfo, modeHeaderLabel);
+        // Compaction message
+        if (compactionMessage) {
+            statusContent += ' ' + theme.warning(compactionMessage);
+        }
+        // Fallback message
+        if (fallbackMessage) {
+            statusContent += ' ' + theme.warning(fallbackMessage);
+        }
+        // Update header (always Text)
+        if (isThinking && thinkingLoader) {
+            thinkingLoader.setMessage(statusContent);
+        }
+        else if (!isThinking) {
+            updateHeaderText(statusContent);
+        }
+        let ctxBar = formatContextBar(info.tokensUsed, liveMaxContext);
+        // 优先使用最新轮次的缓存命中率，否则从累计值计算
+        const hitRate = info.cacheHitRate != null
+            ? info.cacheHitRate.toFixed(1)
+            : (info.cacheHitTokens != null && info.cacheMissTokens != null)
+                ? (() => { const t = info.cacheHitTokens + info.cacheMissTokens; return t > 0 ? (info.cacheHitTokens / t * 100).toFixed(1) : null; })()
+                : null;
+        if (hitRate != null) {
+            ctxBar += theme.dim(` | Cache: ${hitRate}%`);
+            if (info.cacheHistory && info.cacheHistory.length > 1) {
+                ctxBar += theme.dim(` (${info.cacheHistory.length}t)`);
+            }
+        }
+        // Background process count
+        if (backgroundRegistry) {
+            const bgProcs = backgroundRegistry.list();
+            if (bgProcs.length > 0) {
+                const running = bgProcs.filter((p) => p.status === 'running').length;
+                ctxBar += theme.dim(' | ') + theme.accent(`⚙ ${running} bg`);
+            }
+        }
+        contextBarText.setText(ctxBar);
+        tui.requestRender();
+        updateTokenEstimate(); // 同步刷新 footer（工作流状态等）
+    }
+    // ── Output handler ──
+    let currentTextLine = '';
+    let pendingThinking = '';
+    let toolCounterFallback = 0;
+    let showThinking = false;
+    function showPermissionDialog(toolName, inputStr) {
+        permissionSelection = 0;
+        chatLog.addSystem(theme.warning(`\u250c Permission Required \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510`));
+        chatLog.addSystem(theme.warning('\u2502 ') + theme.fg(`${toolName}(${inputStr})`) + theme.warning(' \u2502'));
+        chatLog.addSystem(theme.warning(`\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518`));
+        updatePermissionBar();
+        tui.requestRender();
+    }
+    function resolvePermission(result) {
+        const req = permissionQueue.shift();
+        if (!req)
+            return;
+        permissionBar.setText('');
+        chatLog.addSystem(result === 'no' ? theme.error('  \u25c6 Denied')
+            : result === 'aor' ? theme.warning('  \u25c6 AOR \u2014 all restrictions lifted')
+                : result === 'always' ? theme.success('  \u25c6 Always allowed')
+                    : theme.success('  \u25c6 Approved'));
+        req.resolve(result);
+        if (permissionQueue.length > 0) {
+            const next = permissionQueue[0];
+            showPermissionDialog(next.toolName, next.inputStr);
+        }
+        tui.requestRender();
+    }
+    function updatePermissionBar() {
+        const labels = ['Yes', 'AOR', 'Always', 'No'];
+        const shortcuts = ['Y', 'O', 'A', 'N'];
+        const parts = labels.map((l, i) => {
+            const prefix = i === permissionSelection ? '\u25b6 ' : '  ';
+            if (i === permissionSelection) {
+                return theme.fg(`[ ${prefix}${l} (${shortcuts[i]}) ]`);
+            }
+            return theme.dim(`  ${prefix}${l} (${shortcuts[i]})  `);
+        });
+        permissionBar.setText(theme.warning('\u250c Permission Required \u2500 ') +
+            parts.join(theme.dim(' \u2502 ')) +
+            theme.warning(' \u2500\u2500 Use \u2190\u2192 to select, Enter to confirm'));
+    }
+    // \u2500\u2500 Ask User \u6e32\u67d3 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    function renderAskUserForm() {
+        if (!askUserState) {
+            askUserContent.setText('');
+            askUserBar.setText('');
+            return;
+        }
+        const { questions, selectedOptions, customTexts, activeQuestion } = askUserState;
+        const supplementIdx = questions.length;
+        const totalTabs = supplementIdx + 1;
+        // \u6784\u5efa\u6807\u7b7e\u884c
+        let tabLine = '';
+        for (let i = 0; i < questions.length; i++) {
+            const isActive = i === activeQuestion;
+            const header = questions[i].header || `\u95ee\u9898${i + 1}`;
+            tabLine += isActive ? ` ${theme.fg(`[${header}]`)} ` : ` ${theme.dim(header)}  `;
+        }
+        tabLine += activeQuestion === supplementIdx
+            ? ` ${theme.fg('[\u8865\u5145]')} `
+            : ` ${theme.dim('\u8865\u5145')}  `;
+        // \u6784\u5efa\u5185\u5bb9
+        let content = theme.warning('\u250c Ask User \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500') + '\n';
+        content += tabLine + '\n';
+        content += theme.warning('\u251c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500') + '\n';
+        if (activeQuestion < supplementIdx) {
+            // \u666e\u901a\u95ee\u9898
+            const q = questions[activeQuestion];
+            content += `${q.question}\n\n`;
+            const opts = q.options ?? [];
+            const sel = selectedOptions.get(activeQuestion) ?? new Set();
+            const isMulti = q.multiSelect ?? false;
+            for (let i = 0; i < opts.length; i++) {
+                const selected = sel.has(i);
+                const bullet = isMulti
+                    ? (selected ? theme.fg('\u25c9') : '\u25cb')
+                    : (selected ? theme.fg('\u25cf') : '\u25cb');
+                const highlight = i === askUserState.activeOption;
+                content += (highlight ? theme.fg(` ${bullet} ${opts[i]}`) : theme.dim(` ${bullet} ${opts[i]}`)) + '\n';
+            }
+            // \u81ea\u5b9a\u4e49\u8f93\u5165
+            if (q.customInput ?? false) {
+                const custom = customTexts.get(activeQuestion) ?? '';
+                content += `\n${theme.dim('\u81ea\u5b9a\u4e49:')} ${custom}${theme.dim('\u258c')}\n`;
+            }
+        }
+        else {
+            // "\u8865\u5145" tab
+            const custom = customTexts.get(supplementIdx) ?? '';
+            content += `${theme.fg('\u8865\u5145\u8bf4\u660e\uff08\u81ea\u7531\u8f93\u5165\uff0c\u6309 Enter \u63d0\u4ea4\u5168\u90e8\uff09')}\n\n`;
+            content += `${custom}${theme.dim('\u258c')}\n`;
+        }
+        content += theme.warning('\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500');
+        askUserContent.setText(content);
+        // \u5bfc\u822a\u680f
+        const currentLabel = activeQuestion < supplementIdx
+            ? (questions[activeQuestion].header || `\u95ee\u9898${activeQuestion + 1}`)
+            : '\u8865\u5145';
+        const nav = activeQuestion < supplementIdx
+            ? theme.warning(`\u2190\u2192 \u5207\u6362  \u2191\u2193 \u9009\u9879  \u7a7a\u683c \u9009\u4e2d  \u21b5 ${currentLabel === '\u8865\u5145' ? '\u63d0\u4ea4' : '\u786e\u8ba4'}`)
+            : theme.warning(`\u2190\u2192 \u5207\u6362  \u21b5 \u63d0\u4ea4\u5168\u90e8\u7b54\u6848`);
+        askUserBar.setText(nav);
+    }
+    function resolveAskUser() {
+        if (!askUserState)
+            return;
+        const { questions, selectedOptions, customTexts, resolve } = askUserState;
+        const suppIdx = questions.length;
+        const result = {};
+        for (let i = 0; i < questions.length; i++) {
+            const q = questions[i];
+            const answers = [];
+            // \u9009\u4e2d\u7684\u9009\u9879
+            const sel = selectedOptions.get(i) ?? new Set();
+            for (const idx of sel) {
+                if (q.options && q.options[idx]) {
+                    answers.push(q.options[idx]);
+                }
+            }
+            // \u81ea\u5b9a\u4e49\u8f93\u5165
+            const custom = customTexts.get(i) ?? '';
+            if (custom.trim()) {
+                answers.push(custom.trim());
+            }
+            // \u7528\u95ee\u9898\u539f\u6587\u4f5c\u4e3a key\uff08\u957f\u4e0a\u4e0b\u6587\u91cc\u6bd4 "0" "1" \u66f4\u6709\u8bed\u4e49\uff09
+            if (answers.length > 0) {
+                result[q.question] = answers;
+            }
+        }
+        // "\u8865\u5145" \u8f93\u5165
+        const suppText = customTexts.get(suppIdx) ?? '';
+        if (suppText.trim()) {
+            result['\u8865\u5145\u8bf4\u660e'] = [suppText.trim()];
+        }
+        askUserContent.setText('');
+        askUserBar.setText('');
+        const answeredCount = Object.keys(result).length;
+        chatLog.addSystem(theme.success(`\u25c6 Answered ${answeredCount} question(s)`));
+        askUserState = null;
+        resolve(JSON.stringify(result, null, 2));
+        tui.requestRender();
+    }
+    const tuiHandler = {
+        onText(content) {
+            currentTextLine += content;
+        },
+        onThinking(content) {
+            pendingThinking += content;
+        },
+        onTurnStart() {
+            isThinking = true;
+            pendingThinking = '';
+            const label = loop.pendingTaskName
+                ? `⏰ ${loop.pendingTaskName}`
+                : 'Thinking...';
+            showThinkingIndicator(theme.accent(label));
+        },
+        onToolUse(name, inputSummary, toolId) {
+            if (pendingThinking.trim()) {
+                if (showThinking) {
+                    chatLog.addSystem(theme.dim('\u{1F9E0} Thinking:\n') + theme.dim(pendingThinking.trim()));
+                }
+                pendingThinking = '';
+            }
+            if (currentTextLine.trim()) {
+                chatLog.finalizeAssistant(currentTextLine.trim());
+                currentTextLine = '';
+            }
+            const summary = inputSummary.length > 100 ? inputSummary.slice(0, 97) + '...' : inputSummary;
+            const id = toolId ?? `tool_${Date.now()}_${++toolCounterFallback}`;
+            chatLog.startTool(id, name, summary);
+            tui.requestRender();
+        },
+        onToolResult(content, isError, toolId) {
+            if (toolId) {
+                chatLog.updateToolResult(toolId, content, { isError });
+            }
+            tui.requestRender();
+        },
+        onDiff(toolId, filePath, diffLines) {
+            if (toolId) {
+                chatLog.showDiff(toolId, filePath, diffLines);
+            }
+            tui.requestRender();
+        },
+        onStatus(message, level) {
+            // 压缩指示器
+            if (message === 'compress-start') {
+                if (!compressionLoader) {
+                    compressionLoader = new Loader(tui, (spinner) => theme.accent(spinner), (text) => theme.accent(text), 'Compressing...');
+                    thinkingBar.addChild(compressionLoader);
+                }
+                // 超时保护：30 秒后自动清除 Loader
+                if (compressionTimeout)
+                    clearTimeout(compressionTimeout);
+                compressionTimeout = setTimeout(() => {
+                    if (compressionLoader) {
+                        compressionLoader.stop();
+                        thinkingBar.removeChild(compressionLoader);
+                        compressionLoader = null;
+                    }
+                    compressionTimeout = null;
+                }, 30000);
+                return;
+            }
+            if (message === 'compress-end') {
+                if (compressionTimeout) {
+                    clearTimeout(compressionTimeout);
+                    compressionTimeout = null;
+                }
+                if (compressionLoader) {
+                    compressionLoader.stop();
+                    thinkingBar.removeChild(compressionLoader);
+                    compressionLoader = null;
+                }
+                return;
+            }
+            if (message.startsWith('compress-result:')) {
+                const parts = message.split(':');
+                const pre = parseInt(parts[1], 10);
+                const post = parseInt(parts[2], 10);
+                if (!isNaN(pre) && !isNaN(post)) {
+                    const ratio = Math.round((1 - post / pre) * 100);
+                    chatLog.addSystem(theme.success('Compressed: ') +
+                        theme.dim(`${pre.toLocaleString()} → ${post.toLocaleString()} tokens`) +
+                        theme.fg(` (${ratio}% reduced)`));
+                    // 用压缩后的 token 数刷新 context bar
+                    refreshStatus(loop.getTurnInfo(lastTurnCount, post));
+                }
+                return;
+            }
+            if (level === 'error') {
+                // 原始 API 错误细节走日志，TUI 只显示简洁消息
+                if (message.length > 150 || message.includes('{') || message.includes('\n')) {
+                    process.stderr.write(`[tui:error] ${message}\n`);
+                    chatLog.addSystem(theme.errorBright('[Error] ') + theme.dim('Provider request failed, auto-switching...'));
+                }
+                else {
+                    chatLog.addSystem(theme.errorBright('[Error] ') + theme.error(message));
+                }
+            }
+            else if (level === 'warn') {
+                chatLog.addSystem(theme.warning(message));
+            }
+            else {
+                chatLog.addSystem(theme.fg(message));
+                // 如果消息是 provider 切换，同步刷新 UI
+                if (message.startsWith('Provider switched to ')) {
+                    modelName = loop.getActiveProvider().getModel();
+                    providerTypeStart = loop.getActiveProvider().getProviderType();
+                    refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+                }
+            }
+            tui.requestRender();
+        },
+        onFlush() {
+            hideThinkingIndicator();
+            isThinking = false;
+            // 陪伴模式 session 切换 → 清空显示并重放新 session 历史，同步 sessionDir
+            if (loop._sessionSwitched) {
+                sessionDir = loop._sessionSwitched;
+                chatLog.clearAll();
+                replayEvents(chatLog, loop._sessionSwitched);
+                loop._sessionSwitched = undefined;
+            }
+            updateHeaderText(modelName);
+            const providerInfo = loop.getProviderRoutingInfo();
+            if (pendingThinking.trim()) {
+                if (showThinking) {
+                    chatLog.addSystem(theme.dim('\u{1F9E0} Thinking:\n') + theme.dim(pendingThinking.trim()));
+                }
+                // thinking-only 模型兜底：thinking 有内容但 text 为空时，将 thinking 作为回复显示
+                if (!currentTextLine.trim()) {
+                    currentTextLine = pendingThinking.trim();
+                }
+                pendingThinking = '';
+            }
+            if (currentTextLine.trim()) {
+                chatLog.finalizeAssistant(currentTextLine.trim());
+                currentTextLine = '';
+            }
+            tui.requestRender();
+        },
+        onPermissionRequest(toolName, input) {
+            const inputStr = Object.entries(input)
+                .map(([k, v]) => `${k}=${String(v).substring(0, 60)}`)
+                .join(', ');
+            return new Promise((resolve) => {
+                const isFirst = permissionQueue.length === 0;
+                permissionQueue.push({ resolve, toolName, inputStr });
+                if (isFirst) {
+                    showPermissionDialog(toolName, inputStr);
+                }
+            });
+        },
+        onInterrupt() {
+            hideThinkingIndicator();
+            isThinking = false;
+            pendingThinking = '';
+            currentTextLine = '';
+        },
+        onAskUser(questions) {
+            return new Promise((resolve) => {
+                const selectedOptions = new Map();
+                const customTexts = new Map();
+                for (let i = 0; i < questions.length; i++) {
+                    selectedOptions.set(i, new Set());
+                    customTexts.set(i, '');
+                }
+                // "补充" tab custom text
+                customTexts.set(questions.length, '');
+                askUserState = {
+                    questions,
+                    selectedOptions,
+                    customTexts,
+                    activeQuestion: 0,
+                    activeOption: 0,
+                    resolve,
+                };
+                renderAskUserForm();
+                tui.requestRender();
+            });
+        },
+    };
+    // ── Bootstrap detection ──
+    const resolvedBootstrapStatus = bootstrapStatus ?? (await getBootstrapStatus(personaDir));
+    // ── Local Model (llama.cpp) ──
+    try {
+        const loadedModels = await supervisor.loadAndStartModels(process.cwd());
+        if (loadedModels.length > 0) {
+            chatLog.addSystem(theme.success('\uD83D\uDDA5  Local Model Server'));
+            for (const m of loadedModels) {
+                chatLog.addSystem(theme.success('   \u2022 ') + theme.accent(m.name) + theme.dim(' \u2192 ') + theme.accent(m.baseUrl));
+            }
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        chatLog.addSystem(theme.warning('\u26a0  Local model server not available: ' + msg));
+    }
+    tui.requestRender();
+    // ── 远程模式下跳过 createAgent，这些组件需手动初始化 ──
+    try {
+        CommandRegistry.getInstance(process.cwd());
+    }
+    catch { /* already initialized */ }
+    try {
+        const { RuntimeConfigCenter } = await import('../runtime/config-center.js');
+        const { getDefaultConfig } = await import('../runtime/defaults.js');
+        const configCenter = RuntimeConfigCenter.getInstance();
+        // 尝试读取配置——如果未初始化会抛异常
+        configCenter.get('session.maxTurns');
+    }
+    catch {
+        // 初始化 RuntimeConfigCenter
+        const { ConfigManager } = await import('../setup/config.js');
+        const { getDefaultConfig } = await import('../runtime/defaults.js');
+        const { RuntimeConfigCenter: RCC } = await import('../runtime/config-center.js');
+        const cm = new ConfigManager(process.cwd());
+        await cm.loadEnvKeys();
+        const cfg = await cm.load();
+        RCC.getInstance().initialize(getDefaultConfig(), cm);
+        RCC.getInstance().merge(cfg);
+    }
+    // ── 检测统一后端是否已运行 ──
+    let remoteWs = null;
+    try {
+        const healthy = await new Promise((resolve) => {
+            const req = http.get('http://127.0.0.1:3000/api/health', (res) => {
+                let d = '';
+                res.on('data', (c) => d += c);
+                res.on('end', () => resolve(d.includes('"ok"')));
+            });
+            req.on('error', () => resolve(false));
+            req.setTimeout(1500, () => { req.destroy(); resolve(false); });
+        });
+        if (healthy) {
+            const { default: WebSocket } = await import('ws');
+            remoteWs = await new Promise((resolve) => {
+                const ws = new WebSocket('ws://127.0.0.1:3000/tui');
+                ws.on('open', () => resolve(ws));
+                ws.on('error', () => resolve(null));
+                setTimeout(() => resolve(null), 3000);
+            });
+        }
+    }
+    catch { /* fall through to standalone */ }
+    // ── Agent + Session（远程模式下跳过，使用 WebSocket 连接） ──
+    let agent;
+    let sessionDir;
+    if (!remoteWs) {
+        agent = await createAgent({
+            cwd: process.cwd(),
+            provider: activeProvider,
+            maxTurns,
+            maxContext,
+            outputHandler: tuiHandler,
+            sessionId,
+            shouldContinue,
+            maxMessages,
+            personaDir,
+            bootstrapStatus: resolvedBootstrapStatus,
+            localModelProvider,
+            channel: 'tui',
+        });
+        sessionDir = agent.sessionDir;
+        // Wire ask_user tool to TUI handler
+        if (tuiHandler.onAskUser) {
+            setAskUserHandler((questions) => tuiHandler.onAskUser(questions));
+        }
+    }
+    else {
+        agent = undefined;
+        sessionDir = '';
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const loop = agent?.loop ?? {
+        getActiveProvider: () => activeProvider,
+        getProviderRoutingInfo: () => null,
+        getTurnInfo: (_tc, _tu) => ({ turnCount: lastTurnCount, maxTurns, tokensUsed: lastTokensUsed, maxContextTokens: maxContext, sessionId: '', compressCount: 0 }),
+        setLifecycleSupervisor: () => { },
+        run: async () => { },
+        switchSession: async () => { },
+        switchProvider: async () => { },
+        getModelSources: () => null,
+        composeStrategy: null,
+        setScheduler: () => { },
+        notifyTaskFired: async () => { },
+        subscribeConfig: () => { },
+        isBootstrapPending: () => false,
+        shutdown: async () => { },
+    };
+    // 远程模式下 agent 为 undefined，这些变量仅用于本地 TUI 功能（斜杠命令等），用 any 避免 null 检查
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const backgroundRegistry = agent?.backgroundRegistry;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const modelRouter = agent?.modelRouter;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const knowledgeBase = agent?.knowledgeBase;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const composeStrategy = agent?.composeStrategy;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const sessionManager = agent?.sessionManager;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const contextComposer = agent?.contextComposer;
+    let originalSessionDir = null; // /precise on 前保存的原始 session
+    let preciseModeActive = false;
+    // 检测启动时恢复的 session 类型（仅本地模式）
+    if (!remoteWs) {
+        const currentSessionId = path.basename(sessionDir);
+        const sessions = await sessionManager.list();
+        const resumedSession = sessions.find((s) => s.id === currentSessionId);
+        if (resumedSession?.type === 'precise') {
+            const { PreciseStrategy } = await import('../context/precision/index.js');
+            loop.composeStrategy = new PreciseStrategy(sessionDir);
+            preciseModeActive = true;
+            const normalSessions = sessions.filter((s) => (s.type ?? 'normal') === 'normal');
+            if (normalSessions.length > 0) {
+                originalSessionDir = sessionManager.getSessionDir(normalSessions[0].id);
+            }
+            chatLog.addSystem(theme.dim('精确模式 session 已恢复'));
+        }
+    }
+    // 注入 LifecycleSupervisor，实现运行时 provider 切换时自动管理本地模型进程
+    loop.setLifecycleSupervisor(supervisor);
+    const statsManager = new StatsManager();
+    // ── Channel bridge ──
+    const tuiChannel = new TuiChannel();
+    const channelManager = new ChannelManager();
+    channelManager.register(tuiChannel, { enabled: true });
+    // 自动检测配置驱动渠道（飞书等），有配置则自动注册
+    await registerConfigChannels(channelManager, process.cwd());
+    // 调用所有插件的 onGatewayInit 钩子（如飞书 SDK 日志拦截）
+    const cleanupFns = [];
+    for (const plugin of getChannelPlugins()) {
+        if (plugin.onGatewayInit) {
+            const cleanup = plugin.onGatewayInit();
+            if (cleanup)
+                cleanupFns.push(cleanup);
+        }
+    }
+    // 为所有渠道注入 TUI 同步回调（渠道自行决定是否启用 tuiSync）
+    for (const state of channelManager.getAll()) {
+        if (state.handler.id === 'tui')
+            continue;
+        state.config = {
+            ...state.config,
+            onUserMessage: (label, content) => {
+                chatLog.addSystem(`💬 [${state.handler.name}:${label}] ${content}`);
+                tui.requestRender();
+            },
+            onAgentReply: (content) => {
+                chatLog.addSystem(`📤 [${state.handler.name}回复] ${content}`);
+                tui.requestRender();
+            },
+        };
+    }
+    tuiChannel.onReply = (content) => {
+        chatLog.addSystem(content);
+        tui.requestRender();
+    };
+    // 创建 AgentFactory（注入到渠道，渠道通过此接口创建 AgentLoop）
+    const agentFactory = {
+        createAgent: async (options) => {
+            return createAgent({
+                cwd: process.cwd(),
+                provider: activeProvider,
+                maxTurns: maxTurns ?? 20,
+                maxContext: maxContext ?? 40_000,
+                outputHandler: options.outputHandler,
+                sessionId: options.sessionId,
+                channel: options.channel ?? 'tui',
+            });
+        },
+    };
+    // 设置 TUI 渠道的消息处理回调
+    if (remoteWs) {
+        // ── 远程模式：通过 WebSocket 连接统一后端 ──
+        chatLog.addSystem(theme.success('🔗 Connected to running backend (port 3000)'));
+        remoteWs.on('message', (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                switch (msg.type) {
+                    case 'text':
+                        tuiHandler.onText?.(msg.content);
+                        break;
+                    case 'thinking':
+                        tuiHandler.onThinking?.(msg.content);
+                        break;
+                    case 'tool_use':
+                        tuiHandler.onToolUse?.(msg.name, msg.inputSummary, msg.id);
+                        break;
+                    case 'tool_result':
+                        tuiHandler.onToolResult?.(msg.content, msg.isError, msg.id);
+                        break;
+                    case 'diff':
+                        tuiHandler.onDiff?.(msg.id, msg.filePath, msg.diffLines);
+                        break;
+                    case 'status':
+                        tuiHandler.onStatus?.(msg.message, msg.level);
+                        break;
+                    case 'turn_start':
+                        tuiHandler.onTurnStart?.();
+                        break;
+                    case 'flush':
+                        tuiHandler.onFlush?.();
+                        break;
+                    case 'interrupt':
+                        tuiHandler.onInterrupt?.();
+                        break;
+                    case 'turn_info': {
+                        lastTurnCount = msg.turnCount ?? lastTurnCount;
+                        lastTokensUsed = msg.tokensUsed ?? lastTokensUsed;
+                        refreshStatus({ turnCount: lastTurnCount, maxTurns, tokensUsed: lastTokensUsed, maxContextTokens: maxContext, sessionId: '', compressCount: 0 });
+                        break;
+                    }
+                    case 'error':
+                        chatLog.addSystem(theme.errorBright('[Error] ') + theme.error(msg.message));
+                        break;
+                }
+            }
+            catch { /* ignore */ }
+        });
+        remoteWs.on('close', () => {
+            chatLog.addSystem(theme.warning('⚠ Backend connection lost. Restart to reconnect.'));
+        });
+        tuiChannel.onHandleMessage = async (event) => {
+            if (remoteWs?.readyState === 1) {
+                remoteWs.send(JSON.stringify({ type: 'chat', content: event.content }));
+            }
+        };
+    }
+    else {
+        tuiChannel.onHandleMessage = async (event) => {
+            await loop.run(event.content);
+            const stats = await statsManager.get(sessionDir);
+            const tc = stats.turn_count ?? 0;
+            refreshStatus(loop.getTurnInfo(tc, stats.current_context_tokens ?? 0));
+        };
+    }
+    // 启动所有渠道（每个渠道自行处理消息）
+    await channelManager.startAll(agentFactory);
+    // ── ASCII Art loader ──────────────────────────────────────────────
+    async function loadAsciiArt(maxWidth = 54) {
+        const asciiDir = path.join(os.homedir(), '.agent', 'ascii');
+        const lastFile = path.join(asciiDir, '_last.txt');
+        try {
+            if (!fs.existsSync(asciiDir)) {
+                fs.mkdirSync(asciiDir, { recursive: true });
+                return null;
+            }
+            const files = fs.readdirSync(asciiDir);
+            const imageExts = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp'];
+            const imageFiles = files.filter(f => imageExts.includes(path.extname(f).toLowerCase()));
+            if (imageFiles.length === 0)
+                return null;
+            let prevName = '';
+            try {
+                prevName = fs.readFileSync(lastFile, 'utf-8').trim();
+            }
+            catch { /* first */ }
+            const candidates = imageFiles.length > 1 ? imageFiles.filter(f => f !== prevName) : imageFiles;
+            const pool = candidates.length > 0 ? candidates : imageFiles;
+            const picked = pool[Math.floor(Math.random() * pool.length)];
+            try {
+                fs.writeFileSync(lastFile, picked, 'utf-8');
+            }
+            catch { /* ignore */ }
+            const imgPath = path.join(asciiDir, picked);
+            const cachePath = path.join(asciiDir, picked + '.txt');
+            try {
+                const imgStat = fs.statSync(imgPath);
+                const cacheStat = fs.statSync(cachePath);
+                if (cacheStat.mtimeMs >= imgStat.mtimeMs) {
+                    return JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+                }
+            }
+            catch { /* cache miss */ }
+            const { imageToAscii } = await import('../orchestrator/loop.js');
+            const result = await imageToAscii(imgPath, maxWidth);
+            if (result) {
+                try {
+                    fs.writeFileSync(cachePath, JSON.stringify(result), 'utf-8');
+                }
+                catch { /* ignore */ }
+            }
+            return result;
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── Welcome ──
+    const asciiArt = await loadAsciiArt(54);
+    const cwd = process.cwd();
+    const cwdDisplay = cwd.length > 50 ? '...' + cwd.slice(-47) : cwd;
+    const boxLines = [];
+    boxLines.push(theme.fg('\u256d' + BOX_H.repeat(58) + '\u256e'));
+    if (asciiArt) {
+        const artWidth = asciiArt.width;
+        const pad = Math.max(0, 56 - artWidth);
+        for (const line of asciiArt.text.split('\n')) {
+            boxLines.push(theme.fg('\u2502 ') + line + ' '.repeat(pad) + theme.fg(' \u2502'));
+        }
+    }
+    // Hyacinth \u6807\u9898\u884c
+    const titleLine = theme.fg(' Hyacinth');
+    const titlePad = Math.max(0, 56 - 9); // ' Hyacinth' = 9 chars visible
+    boxLines.push(theme.fg('\u2502 ') + titleLine + ' '.repeat(titlePad) + theme.fg(' \u2502'));
+    // CWD \u884c
+    const cwdPad = Math.max(0, 56 - [...cwdDisplay].length);
+    boxLines.push(theme.fg('\u2502 ') + theme.dim(cwdDisplay) + ' '.repeat(cwdPad) + theme.fg(' \u2502'));
+    boxLines.push(theme.fg('\u2570' + BOX_H.repeat(58) + '\u256f'));
+    chatLog.addSystem(boxLines.join('\n'));
+    chatLog.addSystem('');
+    chatLog.addSystem(theme.dim('Persona: ') + theme.accent(personaDir));
+    chatLog.addSystem('');
+    // ── Bootstrap ──
+    if (resolvedBootstrapStatus === 'pending') {
+        chatLog.addSystem(theme.warning('\u256d' + BOX_H.repeat(56) + '\u256e'));
+        chatLog.addSystem(theme.warning('\u2502  \uD83D\uDD27 Bootstrap Init'));
+        chatLog.addSystem(theme.warning('\u2502  AI will ask you setup questions to configure the persona.'));
+        chatLog.addSystem(theme.warning('\u2570' + BOX_H.repeat(56) + '\u256f'));
+        chatLog.addSystem('');
+        try {
+            // Flow 已在 factory.ts 中自动激活，发送空消息让模型根据 flow_injection 引导对话
+            await loop.run('');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            chatLog.addSystem(theme.errorBright('[Bootstrap Error] ') + theme.error(message));
+        }
+    }
+    chatLog.addSystem(theme.dim('Type ') +
+        theme.success('exit') +
+        theme.dim(' to quit. ') +
+        theme.success('Ctrl+C') +
+        theme.dim(' twice to force. ') +
+        theme.success('Ctrl+P') +
+        theme.dim(' to toggle provider.'));
+    chatLog.addSystem('');
+    tui.requestRender();
+    // Replay previous session events
+    if (sessionDir) {
+        replayEvents(chatLog, sessionDir);
+    }
+    // ── Input state ──
+    let isProcessing = false;
+    const messageQueue = new MessageQueue();
+    let inputHistory = [];
+    let historyIndex = -1;
+    // ── History persistence ──
+    const historyFilePath = path.join(os.homedir(), '.agent', 'history.json');
+    const HISTORY_MAX = 500;
+    try {
+        if (fs.existsSync(historyFilePath)) {
+            const raw = fs.readFileSync(historyFilePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                inputHistory = parsed.slice(-HISTORY_MAX);
+            }
+        }
+    }
+    catch { /* ignore corrupt history */ }
+    function saveHistory() {
+        try {
+            const dir = path.dirname(historyFilePath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(historyFilePath, JSON.stringify(inputHistory.slice(-HISTORY_MAX), null, 2), 'utf-8');
+        }
+        catch { /* ignore write errors */ }
+    }
+    function updateTokenEstimate() {
+        const text = editor.getText();
+        const estimated = Math.ceil(text.length / 4);
+        const ap = loop.getActiveProvider();
+        const providerLabel = `${ap.getProviderType()} \u00b7 `;
+        let footer = theme.dim(`Ctrl+C exit | Ctrl+L clear | Ctrl+P provider | Ctrl+F search | Ctrl+T tools`);
+        // Context-aware hints
+        if (isThinking) {
+            footer += theme.accent(' | Esc to stop');
+        }
+        if (permissionQueue.length > 0) {
+            footer += theme.warning(' | \u2190\u2192 select  Enter confirm');
+        }
+        if (backgroundRegistry) {
+            const bgCount = backgroundRegistry.list().filter((p) => p.status === 'running').length;
+            if (bgCount > 0) {
+                footer += theme.accent(` | \u2699 ${bgCount} bg process(es)`);
+            }
+        }
+        footer += theme.dim(`\n${providerLabel}${ap.getModel()} \u00b7 ~${estimated} tokens`);
+        if (messageQueue.size > 0) {
+            footer += theme.fg(` | Queue: ${messageQueue.size}`);
+        }
+        footerText.setText(footer);
+    }
+    function truncateMsg(text, max = 40) {
+        return text.length > max ? text.slice(0, max) + '...' : text;
+    }
+    /**
+     * Process one message through the agent loop, then drain any queued messages.
+     * Called by handleInput when the agent is idle.
+     */
+    async function processBatch(initialText) {
+        let text = initialText;
+        while (text !== undefined) {
+            isProcessing = true;
+            editor.setText('');
+            chatLog.addUser('❯ ' + text);
+            chatLog.addSystem(theme.dim('─'.repeat(30)));
+            try {
+                const sid = sessionDir.split(/[\\/]/).pop() ?? 'tui-default';
+                await tuiChannel.sendMessage(sid, text);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                chatLog.addSystem(theme.errorBright('[Error] ') + theme.error(message));
+            }
+            isProcessing = false;
+            // Check queue for pending messages
+            const next = messageQueue.dequeue();
+            text = next?.text;
+        }
+        updateTokenEstimate();
+        tui.requestRender();
+    }
+    async function handleInput(text) {
+        let input = text.trim();
+        if (!input) {
+            // 定时任务完成后队列中有待处理消息 → 空回车触发队列消费
+            if (!isProcessing && !loop.pendingTaskName && messageQueue.size > 0) {
+                const next = messageQueue.dequeue();
+                if (next)
+                    await processBatch(next.text);
+            }
+            return;
+        }
+        // Push to history
+        if (inputHistory.length === 0 || inputHistory[inputHistory.length - 1] !== input) {
+            inputHistory.push(input);
+            if (inputHistory.length > HISTORY_MAX) {
+                inputHistory.shift();
+            }
+            saveHistory();
+        }
+        historyIndex = -1;
+        if (input === 'exit' || input === 'quit') {
+            chatLog.addSystem(theme.dim('Goodbye.'));
+            tui.requestRender();
+            await channelManager.stopAll();
+            await loop.shutdown();
+            // 清理插件钩子
+            for (const cleanup of cleanupFns)
+                cleanup();
+            await supervisor.shutdownAll();
+            tui.stop();
+            process.exit(0);
+        }
+        // 二级菜单：检查命令是否有 children
+        if (input.startsWith('/')) {
+            const spaceIdx = input.indexOf(' ');
+            const cmdName = spaceIdx > 0 ? input.slice(1, spaceIdx) : input.slice(1);
+            const cmdDef = CommandRegistry.getInstance().find(cmdName);
+            if ((cmdDef?.children && cmdDef.children.length > 0) || !!cmdDef?.childrenProvider) {
+                const args = spaceIdx > 0 ? input.slice(spaceIdx + 1).trim() : '';
+                // Build dynamic entries for /model L1 panel
+                let effectiveDef = cmdDef;
+                if (cmdName === 'model') {
+                    const dynamicChildren = [];
+                    // a) Current online model
+                    const activeP = loop.getActiveProvider();
+                    dynamicChildren.push({
+                        name: 'current_online',
+                        description: `${activeP.getProviderType()} (online) - ${activeP.getModel()}`,
+                        icon: '\u2601',
+                        category: 'model',
+                    });
+                    // b) Local models
+                    for (const m of localModel.list()) {
+                        const isRunning = localModel.getBridge().isRunning(m.name);
+                        const status = isRunning ? '\u25C9 running' : '\u25CB stopped';
+                        dynamicChildren.push({
+                            name: 'local_' + m.name,
+                            description: `${m.name} (local) - ${status}`,
+                            icon: '\u{1F4BB}',
+                            category: 'model',
+                        });
+                    }
+                    effectiveDef = {
+                        ...cmdDef,
+                        children: [...dynamicChildren, ...(cmdDef.children ?? [])],
+                    };
+                }
+                if (!args) {
+                    // 无参数 → 弹出二级面板
+                    slashSubPanelActive = true;
+                    const panel = new SlashSubPanel(effectiveDef);
+                    panel.show(tui, (result) => {
+                        slashSubPanelActive = false;
+                        if (result) {
+                            // 如果叶子命令有 args 占位符 → 自动填充到输入框，让用户继续输入
+                            const leafDef = CommandRegistry.getInstance().find(result.path);
+                            if (leafDef?.args && !leafDef.children && !leafDef.childrenProvider) {
+                                editor.setText(`/${result.path} `);
+                                updateTokenEstimate();
+                                return;
+                            }
+                            handleSlashSubCommand(result.path, '');
+                        }
+                    });
+                    return;
+                }
+                // 有参数 → 解析子命令路径并直接执行
+                const subSpaceIdx = args.indexOf(' ');
+                const subCmdName = subSpaceIdx > 0 ? args.slice(0, subSpaceIdx) : args;
+                const subArgs = subSpaceIdx > 0 ? args.slice(subSpaceIdx + 1) : '';
+                const subCmd = cmdDef?.children?.find((c) => c.name.toLowerCase() === subCmdName.toLowerCase());
+                if (subCmd) {
+                    handleSlashSubCommand(`${cmdName}/${subCmd.name}`, subArgs);
+                    return;
+                }
+                const childNames = (cmdDef?.children ?? []).map((c) => c.name).join(', ');
+                chatLog.addSystem(theme.warning(`Unknown sub-command: /${cmdName} ${subCmdName}`) +
+                    theme.dim(`\nAvailable: /${cmdName} ${childNames}`));
+                tui.requestRender();
+                return;
+            }
+        }
+        // ===== Sub-Command Handler =====
+        /** 持久化单个配置字段到 JSON 文件（不展开默认值） */
+        async function persistConfigField(key, value) {
+            const configPath = path.join(os.homedir(), '.agent', 'config.json');
+            try {
+                const raw = await fs.promises.readFile(configPath, 'utf-8');
+                const obj = JSON.parse(raw);
+                const parts = key.split('.');
+                let cur = obj;
+                for (let i = 0; i < parts.length - 1; i++) {
+                    if (!cur[parts[i]] || typeof cur[parts[i]] !== 'object') {
+                        cur[parts[i]] = {};
+                    }
+                    cur = cur[parts[i]];
+                }
+                cur[parts[parts.length - 1]] = value;
+                await fs.promises.writeFile(configPath, JSON.stringify(obj, null, 2), 'utf-8');
+            }
+            catch { /* 文件不存在或解析失败，跳过持久化 */ }
+        }
+        /** /model thinking 公共逻辑 */
+        function applyThinking(action) {
+            const cfg = RuntimeConfigCenter.getInstance();
+            const activeP = loop.getActiveProvider();
+            const providerType = activeP.getProviderType();
+            const effortOptions = {};
+            if (providerType === 'deepseek') {
+                effortOptions.high = { label: 'high', effort: 'high' };
+                effortOptions.max = { label: 'max', effort: 'max' };
+            }
+            else if (providerType === 'anthropic') {
+                effortOptions['4k'] = { label: '4K', effort: 4000 };
+                effortOptions['8k'] = { label: '8K', effort: 8000 };
+                effortOptions['16k'] = { label: '16K', effort: 16000 };
+                effortOptions['32k'] = { label: '32K', effort: 32000 };
+            }
+            if (action === 'on') {
+                cfg.set('provider.enableThinking', true);
+                activeP.setThinking?.(true);
+                persistConfigField('provider.enableThinking', true);
+                chatLog.addSystem(theme.success('Thinking enabled'));
+            }
+            else if (action === 'off') {
+                cfg.set('provider.enableThinking', false);
+                activeP.setThinking?.(false);
+                persistConfigField('provider.enableThinking', false);
+                chatLog.addSystem(theme.success('Thinking disabled'));
+            }
+            else if (effortOptions[action]) {
+                const opt = effortOptions[action];
+                cfg.set('provider.enableThinking', true);
+                activeP.setThinking?.(true, opt.effort);
+                persistConfigField('provider.enableThinking', true);
+                chatLog.addSystem(theme.success(`Thinking enabled (${opt.label})`));
+            }
+            else {
+                const optsStr = Object.entries(effortOptions)
+                    .map(([k, v]) => `  ${k}  → ${v.label}`)
+                    .join('\n');
+                chatLog.addSystem(theme.warning(`Usage: /model thinking <on|off${optsStr ? '|' + Object.keys(effortOptions).join('|') : ''}>` + (optsStr ? '\n' + optsStr : '')));
+            }
+            tui.requestRender();
+            updateTokenEstimate();
+        }
+        /**
+         * 通用 handler 路由：根据 "module.method" 格式的 handler 字符串，
+         * 动态查找并调用对应模块的方法。
+         */
+        function resolveHandler(handlerStr, args, localModel, chatLog, themeObj, tui) {
+            const parts = handlerStr.split('.');
+            if (parts.length < 2)
+                return false;
+            const moduleName = parts[0];
+            const methodChain = parts.slice(1);
+            let target;
+            if (moduleName === 'localModel') {
+                target = localModel;
+            }
+            else {
+                return false;
+            }
+            let fn = target;
+            for (const prop of methodChain) {
+                if (fn && typeof fn === 'object' && prop in fn) {
+                    fn = fn[prop];
+                }
+                else {
+                    chatLog.addSystem(themeObj.error(`Command handler not found: ${handlerStr}`));
+                    tui.requestRender();
+                    return true;
+                }
+            }
+            if (typeof fn !== 'function') {
+                chatLog.addSystem(themeObj.error(`Command handler not found: ${handlerStr}`));
+                tui.requestRender();
+                return true;
+            }
+            try {
+                const result = args ? fn(args) : fn();
+                if (result instanceof Promise) {
+                    result.then((val) => {
+                        if (val !== undefined && val !== null) {
+                            const display = typeof val === 'object' ? JSON.stringify(val, null, 2) : String(val);
+                            chatLog.addSystem(themeObj.success(display));
+                        }
+                        tui.requestRender();
+                    }).catch((err) => {
+                        chatLog.addSystem(themeObj.error(`Handler error: ${err.message}`));
+                        tui.requestRender();
+                    });
+                }
+                else if (result !== undefined && result !== null) {
+                    const display = typeof result === 'object' ? JSON.stringify(result, null, 2) : String(result);
+                    chatLog.addSystem(themeObj.success(display));
+                }
+            }
+            catch (err) {
+                chatLog.addSystem(themeObj.error(`Handler error: ${err.message}`));
+                tui.requestRender();
+                return true;
+            }
+            return true;
+        }
+        /**
+         * 处理二级菜单子命令的执行。
+         * path 格式: "model/switch" / "model/provider" 等
+         */
+        async function handleSlashSubCommand(cmdPath, restArgs) {
+            const cfg = RuntimeConfigCenter.getInstance();
+            if (cmdPath.startsWith('session/')) {
+                let sub = cmdPath.slice('session/'.length);
+                // 支持嵌套路径: session/<id>/load → sub = "<id>/load"
+                const subParts = sub.split('/');
+                if (subParts.length === 2 && (subParts[1] === 'load' || subParts[1] === 'delete')) {
+                    // session/<id>/load 或 session/<id>/delete
+                    const sessionId = subParts[0];
+                    if (subParts[1] === 'load') {
+                        const SessionManager = (await import('../memory/session.js')).SessionManager;
+                        const sm = new SessionManager(process.cwd());
+                        const dir = sm.getSessionDir(sessionId);
+                        const fsPromises = await import('node:fs/promises');
+                        try {
+                            await fsPromises.access(dir);
+                        }
+                        catch {
+                            chatLog.addSystem(theme.warning(`Session "${sessionId}" not found. Use /session list to see available sessions.`));
+                            tui.requestRender();
+                            updateTokenEstimate();
+                            return;
+                        }
+                        // 就地切换，不重启
+                        await loop.switchSession(dir);
+                        sessionDir = dir;
+                        chatLog.clearAll();
+                        replayEvents(chatLog, dir);
+                        chatLog.addSystem(theme.success(`已切换到 session ${sessionId}`));
+                        updateTokenEstimate();
+                    }
+                    else {
+                        const SessionManager = (await import('../memory/session.js')).SessionManager;
+                        const sm = new SessionManager(process.cwd());
+                        const dir = sm.getSessionDir(sessionId);
+                        // 保护当前活跃 session
+                        if (dir === sessionDir) {
+                            chatLog.addSystem(theme.warning(`Cannot delete the currently active session "${sessionId}". Switch to another session first.`));
+                            tui.requestRender();
+                            updateTokenEstimate();
+                            return;
+                        }
+                        try {
+                            const fsPromises = await import('node:fs/promises');
+                            await fsPromises.access(dir);
+                            await fsPromises.rm(dir, { recursive: true, force: true });
+                            chatLog.addSystem(theme.success(`Session ${sessionId} deleted`));
+                        }
+                        catch {
+                            chatLog.addSystem(theme.warning(`Session ${sessionId} not found`));
+                        }
+                    }
+                    tui.requestRender();
+                    updateTokenEstimate();
+                    return;
+                }
+                if (sub === 'list') {
+                    const SessionManager = (await import('../memory/session.js')).SessionManager;
+                    const sm = new SessionManager(process.cwd());
+                    const sessions = await sm.list();
+                    const modeType = preciseModeActive ? 'precise' : 'normal';
+                    const filtered = sessions.filter(s => (s.type ?? 'normal') === modeType);
+                    if (filtered.length === 0) {
+                        chatLog.addSystem(theme.dim(`No ${modeType} sessions found`));
+                    }
+                    else {
+                        for (const s of filtered) {
+                            const isCurrent = s.id === path.basename(sessionDir);
+                            const marker = isCurrent ? theme.success(' ← current') : '';
+                            const typeLabel = s.type ? theme.dim(` [${s.type}]`) : '';
+                            chatLog.addSystem(theme.accent(s.id) +
+                                theme.dim(` | created: ${s.createdAt}`) +
+                                theme.dim(` | updated: ${s.updatedAt}`) +
+                                typeLabel + marker);
+                        }
+                        chatLog.addSystem(theme.dim('─'.repeat(60)));
+                        chatLog.addSystem(theme.dim('加载会话: /session <完整ID>/load   例如: /session ' + (filtered[0]?.id ?? '') + '/load'));
+                    }
+                }
+                else if (sub === 'new') {
+                    chatLog.addSystem(theme.warning('请使用 hyacinth start 启动新会话（当前会话需要退出）'));
+                }
+                else if (sub === 'load') {
+                    const id = restArgs?.trim();
+                    if (!id) {
+                        chatLog.addSystem(theme.warning('用法: /session load <sessionId>'));
+                    }
+                    else {
+                        chatLog.addSystem(theme.warning(`请使用 hyacinth start --session ${id} 加载会话`));
+                    }
+                }
+                else if (sub === 'delete') {
+                    const id = restArgs?.trim();
+                    if (!id) {
+                        chatLog.addSystem(theme.warning('用法: /session delete <sessionId>'));
+                    }
+                    else {
+                        const SessionManager = (await import('../memory/session.js')).SessionManager;
+                        const sm = new SessionManager(process.cwd());
+                        // 检查 session 类型是否匹配当前模式
+                        const sessions = await sm.list();
+                        const target = sessions.find(s => s.id === id);
+                        if (!target) {
+                            chatLog.addSystem(theme.warning(`Session ${id} not found`));
+                        }
+                        else if ((target.type ?? 'normal') !== (preciseModeActive ? 'precise' : 'normal')) {
+                            chatLog.addSystem(theme.warning(`Session ${id} 是 [${target.type ?? 'normal'}] 类型，当前为 [${preciseModeActive ? 'precise' : 'normal'}] 模式，无法跨模式操作`));
+                        }
+                        else {
+                            const dir = sm.getSessionDir(id);
+                            try {
+                                const fsPromises = await import('node:fs/promises');
+                                await fsPromises.access(dir);
+                                await fsPromises.rm(dir, { recursive: true, force: true });
+                                chatLog.addSystem(theme.success(`Session ${id} deleted`));
+                            }
+                            catch {
+                                chatLog.addSystem(theme.warning(`Session ${id} not found`));
+                            }
+                        }
+                    }
+                }
+                tui.requestRender();
+                return;
+            }
+            switch (cmdPath) {
+                case 'model/settings/switch':
+                case 'model/switch': {
+                    if (!restArgs) {
+                        chatLog.addSystem(theme.warning('Usage: /model switch <model-name>'));
+                        tui.requestRender();
+                        return;
+                    }
+                    const activeP = loop.getActiveProvider();
+                    const providerType = activeP.getProviderType();
+                    cfg.set(`provider.${providerType}.model`, restArgs);
+                    cfg.save().catch(() => { });
+                    chatLog.addSystem(theme.success('Model name set to ') + theme.fg(String(restArgs)) + theme.dim(` (provider: ${providerType})`));
+                    tui.requestRender();
+                    refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+                    return;
+                }
+                case 'model/settings/provider':
+                case 'model/provider': {
+                    if (!restArgs) {
+                        chatLog.addSystem(theme.warning('Usage: /model provider <anthropic|openai|deepseek|gemini|groq|xai|mistral|openrouter|moonshot|qwen|zhipu|minimax|mimo|local>'));
+                        tui.requestRender();
+                        return;
+                    }
+                    if (restArgs === 'local') {
+                        const lmList = localModel.list();
+                        // 无已注册模型 → 检查本地模型配置或直接切
+                        if (lmList.length === 0) {
+                            const { getLocalProviderConfigLoader } = await import('../provider/local-config.js');
+                            const localCfg = getLocalProviderConfigLoader();
+                            if (localCfg?.defaultModel) {
+                                // 本地模型已配置 → 直接切换
+                                try {
+                                    await loop.switchProvider('local');
+                                    // 显式持久化 provider 选择（switchProvider 不再负责持久化）
+                                    cfg.set('provider.active', 'local');
+                                    cfg.save().catch(() => { });
+                                    modelName = loop.getActiveProvider().getModel();
+                                    providerTypeStart = loop.getActiveProvider().getProviderType();
+                                    chatLog.addSystem(theme.success(`Switched to local (${localCfg.baseUrl}, ${localCfg.defaultModel})`));
+                                    chatLog.addSystem(theme.dim('Register models via /model local/register for process management.'));
+                                    refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+                                }
+                                catch (err) {
+                                    chatLog.addSystem(theme.error(`Switch failed: ${err.message}`));
+                                }
+                            }
+                            else {
+                                chatLog.addSystem(theme.warning('No local models configured.'));
+                                chatLog.addSystem(theme.dim('Set a local model in config or register models via /model local/register.'));
+                            }
+                            tui.requestRender();
+                            return;
+                        }
+                        const targetName = localModel.getActive() ?? lmList[0].name;
+                        localModel.switch(targetName).then(async (info) => {
+                            if (info) {
+                                cfg.set('provider.local', {
+                                    type: 'local',
+                                    model: info.modelFile ?? targetName,
+                                    baseUrl: info.baseUrl,
+                                });
+                                cfg.set('provider.local.modelKey', targetName);
+                                cfg.save().catch(() => { });
+                                try {
+                                    await loop.switchProvider('local');
+                                    // 显式持久化 provider 选择（switchProvider 不再负责持久化）
+                                    cfg.set('provider.active', 'local');
+                                    cfg.save().catch(() => { });
+                                    modelName = loop.getActiveProvider().getModel();
+                                    providerTypeStart = loop.getActiveProvider().getProviderType();
+                                    chatLog.addSystem(theme.success(`Switched to local model: ${targetName} (port ${info.port})`));
+                                    refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+                                }
+                                catch (swErr) {
+                                    chatLog.addSystem(theme.error(`Failed: ${swErr.message}`));
+                                }
+                            }
+                            else {
+                                chatLog.addSystem(theme.error(`Failed to start ${targetName}`));
+                            }
+                            tui.requestRender();
+                        }).catch((e) => {
+                            chatLog.addSystem(theme.error(`Failed: ${e.message}`));
+                            tui.requestRender();
+                        });
+                        return;
+                    }
+                    localModel.getBridge().stopAll().catch(() => { });
+                    try {
+                        await loop.switchProvider(restArgs);
+                        // 显式持久化 provider 选择（switchProvider 不再负责持久化）
+                        cfg.set('provider.active', restArgs);
+                        cfg.save().catch(() => { });
+                    }
+                    catch (e) {
+                        chatLog.addSystem(theme.error(`Failed: ${e.message}`));
+                        tui.requestRender();
+                        return;
+                    }
+                    modelName = loop.getActiveProvider().getModel();
+                    providerTypeStart = loop.getActiveProvider().getProviderType();
+                    chatLog.addSystem(theme.success('Provider switched to ') + theme.fg(String(restArgs)) + theme.dim(' (persisted)'));
+                    tui.requestRender();
+                    refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+                    return;
+                }
+                case 'model/settings/source':
+                case 'model/source': {
+                    if (!restArgs) {
+                        chatLog.addSystem(theme.warning('Usage: /model source <role> <main|local|channel-name>'));
+                        tui.requestRender();
+                        return;
+                    }
+                    const parts2 = restArgs.split(/\s+/).filter(Boolean);
+                    if (parts2.length < 2) {
+                        chatLog.addSystem(theme.warning('Usage: /model source <assessment|planning|compression|sub-agent|all> <main|local|channel-name>'));
+                        tui.requestRender();
+                        return;
+                    }
+                    const roleArg = parts2[0].toLowerCase();
+                    const sourceArg = parts2[1];
+                    const validRoles = ['assessment', 'planning', 'compression', 'sub-agent', 'all'];
+                    if (!validRoles.includes(roleArg)) {
+                        chatLog.addSystem(theme.warning('Role must be: assessment, planning, compression, sub-agent, or all'));
+                        tui.requestRender();
+                        return;
+                    }
+                    // 尝试用 ModelChannelRegistry 的 setRoleMapping（多通道模式）
+                    const modelRouter = loop.modelRouter;
+                    const registry = modelRouter?.getRegistry();
+                    const channelNames = registry ? registry.listChannelNames() : [];
+                    const isChannelName = channelNames.includes(sourceArg);
+                    try {
+                        if (isChannelName && registry) {
+                            // 映射到已注册的通道
+                            const roles = roleArg === 'all'
+                                ? ['assessment', 'planning', 'compression', 'sub-agent']
+                                : [roleArg];
+                            for (const r of roles) {
+                                registry.setRoleMapping(r, sourceArg);
+                            }
+                            chatLog.addSystem(theme.success(`Mapped ${roles.join(', ')} → channel "${sourceArg}"`));
+                        }
+                        else {
+                            chatLog.addSystem(theme.warning(`Channel "${sourceArg}" not found. Available: ${channelNames.join(', ') || '(none)'}. Use /channel add ${sourceArg} <provider> [model] to create it.`));
+                        }
+                    }
+                    catch (e) {
+                        chatLog.addSystem(theme.error(`Failed: ${e.message}`));
+                    }
+                    tui.requestRender();
+                    refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+                    return;
+                }
+                case 'model/settings/thinking':
+                case 'model/thinking': {
+                    applyThinking(restArgs);
+                    return;
+                }
+                // 四级菜单：/model thinking on|off|high|max 通过子面板选择
+                case 'model/settings/thinking/on':
+                case 'model/thinking/on':
+                    applyThinking('on');
+                    return;
+                case 'model/settings/thinking/off':
+                case 'model/thinking/off':
+                    applyThinking('off');
+                    return;
+                case 'model/settings/thinking/high':
+                case 'model/thinking/high':
+                    applyThinking('high');
+                    return;
+                case 'model/settings/thinking/max':
+                case 'model/thinking/max':
+                    applyThinking('max');
+                    return;
+                case 'model/settings/thinking/4k':
+                case 'model/thinking/4k':
+                    applyThinking('4k');
+                    return;
+                case 'model/settings/thinking/8k':
+                case 'model/thinking/8k':
+                    applyThinking('8k');
+                    return;
+                case 'model/settings/thinking/16k':
+                case 'model/thinking/16k':
+                    applyThinking('16k');
+                    return;
+                case 'model/settings/thinking/32k':
+                case 'model/thinking/32k':
+                    applyThinking('32k');
+                    return;
+                case 'model/settings/show-thinking':
+                case 'model/show-thinking': {
+                    showThinking = !showThinking;
+                    chatLog.addSystem(theme.success(showThinking ? 'Thinking content will be shown' : 'Thinking content hidden'));
+                    tui.requestRender();
+                    updateTokenEstimate();
+                    return;
+                }
+                case 'model/settings/info':
+                case 'model/info': {
+                    const providerName = String(cfg.get('provider.active') ?? 'unknown');
+                    const activeProvider = loop.getActiveProvider();
+                    const modelName = activeProvider ? activeProvider.getModel() : 'unknown';
+                    const lines = [];
+                    lines.push(theme.accent('=== Model Info ==='));
+                    lines.push('  Provider: ' + theme.fg(providerName));
+                    lines.push('  Model:    ' + theme.fg(modelName));
+                    const routing = loop.getProviderRoutingInfo();
+                    if (routing) {
+                        lines.push('  Route:    ' + theme.fg(routing.mode) + (routing.isLocal ? theme.success(' (local)') : theme.accent(' (online)')));
+                    }
+                    // 通道信息
+                    const modelRouter = loop.modelRouter;
+                    if (modelRouter) {
+                        const registry = modelRouter.getRegistry();
+                        const channels = registry.listChannels();
+                        const roles = registry.listRoles();
+                        if (channels.length > 1 || Object.keys(roles).some(r => roles[r] !== 'main')) {
+                            lines.push(theme.dim('  ── Channels ──'));
+                            for (const ch of channels) {
+                                const chRoles = Object.entries(roles)
+                                    .filter(([, cn]) => cn === ch.name)
+                                    .map(([r]) => r);
+                                const roleStr = chRoles.length > 0 ? ' ← ' + chRoles.join(', ') : '';
+                                lines.push(theme.dim(`    ${ch.name}: ${ch.provider}${ch.model ? '/' + ch.model : ''}`) + theme.fg(roleStr));
+                            }
+                        }
+                    }
+                    // 旧 source 信息
+                    const sources = loop.getModelSources();
+                    if (sources) {
+                        const labels = { assessment: '评估', planning: '规划', compression: '压缩' };
+                        for (const [role, src] of Object.entries(sources)) {
+                            const label = labels[role] ?? role;
+                            const srcColor = src === 'local' ? theme.success(String(src)) : theme.accent(String(src));
+                            lines.push('    ' + theme.fg(label) + theme.dim(': ') + srcColor);
+                        }
+                    }
+                    chatLog.addSystem(lines.join('\n'));
+                    tui.requestRender();
+                    updateTokenEstimate();
+                    return;
+                }
+                case 'model/settings/context': {
+                    if (!restArgs) {
+                        const activeP = loop.getActiveProvider();
+                        const modelCtxWindow = getModelContextWindow(activeP.getProviderType(), activeP.getModel());
+                        chatLog.addSystem(theme.warning('Usage: /model settings context <tokens>') + theme.dim(` (1-${modelCtxWindow.toLocaleString()})`));
+                        tui.requestRender();
+                        updateTokenEstimate();
+                        return;
+                    }
+                    const tokens = parseInt(restArgs.trim(), 10);
+                    const activeP = loop.getActiveProvider();
+                    const modelCtxWindow = getModelContextWindow(activeP.getProviderType(), activeP.getModel());
+                    const upper = modelCtxWindow;
+                    if (isNaN(tokens) || tokens < 1 || tokens > upper) {
+                        chatLog.addSystem(theme.warning(`Usage: /model settings context <1-${upper.toLocaleString()}>`) + theme.dim(` (model: ${activeP.getModel()})`));
+                        tui.requestRender();
+                        updateTokenEstimate();
+                        return;
+                    }
+                    cfg.set('session.maxContext', tokens);
+                    cfg.save().catch(() => { });
+                    chatLog.addSystem(theme.success('Max context set to ') + theme.fg(tokens.toLocaleString() + ' tokens'));
+                    refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+                    updateTokenEstimate();
+                    return;
+                }
+                // ── 本地模型 L2: model/local/start ──
+                case 'model/local/start': {
+                    const { detectLocalBackend } = await import('../provider/local-config.js');
+                    const detected = await detectLocalBackend();
+                    const ollamaBin = localModel.checkOllama();
+                    const llamacppBin = localModel.checkLlamacpp();
+                    const backend = restArgs?.toLowerCase();
+                    const validBackend = backend === 'ollama' || backend === 'llamacpp' || backend === 'llama.cpp';
+                    // 指定了 backend → 启动那个
+                    if (validBackend) {
+                        const target = (backend === 'llamacpp' || backend === 'llama.cpp') ? 'llamacpp' : 'ollama';
+                        if (target === 'ollama' && ollamaBin) {
+                            if (detected?.backend === 'ollama') {
+                                chatLog.addSystem(theme.success('Ollama 已在运行。使用 /model/local/switch 切换。'));
+                            }
+                            else {
+                                chatLog.addSystem(theme.accent('启动 Ollama...'));
+                                const info = await supervisor.startOllamaOnDemand(process.cwd());
+                                chatLog.addSystem(info ? theme.success('Ollama 已启动（框架管理进程）。') : theme.warning('启动失败，请手动运行 ollama serve。'));
+                            }
+                        }
+                        else if (target === 'llamacpp' && llamacppBin) {
+                            const regModels = localModel.list();
+                            if (regModels.length === 0) {
+                                chatLog.addSystem(theme.warning('无注册的 llama.cpp 模型。请先用 /model/local/register 注册。'));
+                            }
+                            else {
+                                localModel.start(regModels[0].name).then(async (info) => {
+                                    if (info) {
+                                        cfg.set('provider.local', { type: 'local', model: info.modelFile ?? regModels[0].name, baseUrl: info.baseUrl });
+                                        cfg.set('provider.local.modelKey', regModels[0].name);
+                                        cfg.save().catch(() => { });
+                                        try {
+                                            await loop.switchProvider('local');
+                                            cfg.set('provider.active', 'local');
+                                            cfg.save().catch(() => { });
+                                            chatLog.addSystem(theme.success(`llama.cpp ${regModels[0].name} started`));
+                                            refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+                                        }
+                                        catch (swErr) {
+                                            chatLog.addSystem(theme.error(`Switch failed: ${swErr.message}`));
+                                        }
+                                    }
+                                    tui.requestRender();
+                                }).catch((e) => { chatLog.addSystem(theme.error(`Failed: ${e.message}`)); tui.requestRender(); });
+                            }
+                        }
+                        else {
+                            chatLog.addSystem(theme.warning(`${backend} 未安装。`));
+                        }
+                        tui.requestRender();
+                        return;
+                    }
+                    // 指定了已注册模型名 → 按名启动
+                    if (restArgs) {
+                        const lm = localModel.list().find((m) => m.name === restArgs);
+                        if (lm) {
+                            localModel.start(restArgs).then(async (info) => {
+                                if (info) {
+                                    cfg.set('provider.local', { type: 'local', model: info.modelFile ?? restArgs, baseUrl: info.baseUrl });
+                                    cfg.set('provider.local.modelKey', restArgs);
+                                    cfg.save().catch(() => { });
+                                    try {
+                                        await loop.switchProvider('local');
+                                        cfg.set('provider.active', 'local');
+                                        cfg.save().catch(() => { });
+                                        chatLog.addSystem(theme.success(`${restArgs} started on port ${info.port}`));
+                                        refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+                                    }
+                                    catch (swErr) {
+                                        chatLog.addSystem(theme.error(`Switch failed: ${swErr.message}`));
+                                    }
+                                }
+                                else {
+                                    chatLog.addSystem(theme.error(`Failed to start ${restArgs}`));
+                                }
+                                tui.requestRender();
+                            }).catch((e) => { chatLog.addSystem(theme.error(`Failed: ${e.message}`)); tui.requestRender(); });
+                        }
+                        else {
+                            chatLog.addSystem(theme.warning(`Model "${restArgs}" not registered. Available: ${localModel.list().map((m) => m.name).join(', ') || 'none'}`));
+                            chatLog.addSystem(theme.dim('To start a backend: /model/local start ollama | /model/local start llamacpp'));
+                            tui.requestRender();
+                        }
+                        return;
+                    }
+                    // 无参 → 列出可用选项
+                    chatLog.addSystem(theme.fg('── 可用本地后端 ──'));
+                    if (detected)
+                        chatLog.addSystem(theme.success(`${detected.backend} 正在运行 — ${detected.baseUrl}`));
+                    if (ollamaBin)
+                        chatLog.addSystem(theme.dim(`Ollama ${detected?.backend === 'ollama' ? '(运行中)' : '— /model/local start ollama'}`));
+                    if (llamacppBin)
+                        chatLog.addSystem(theme.dim(`llama.cpp ${detected?.backend === 'llamacpp' ? '(运行中)' : '— /model/local start llamacpp'}`));
+                    if (!ollamaBin && !llamacppBin)
+                        chatLog.addSystem(theme.warning('本地模型服务未配置。请安装 Ollama 或 llama.cpp。'));
+                    const reg = localModel.list();
+                    if (reg.length > 0)
+                        chatLog.addSystem(theme.dim(`已注册模型: ${reg.map((m) => m.name).join(', ')}`));
+                    tui.requestRender();
+                    return;
+                }
+                // ── 本地模型 L2: model/local/stop ──
+                case 'model/local/stop': {
+                    const { detectLocalBackend } = await import('../provider/local-config.js');
+                    const detected = await detectLocalBackend();
+                    const backend = restArgs?.toLowerCase();
+                    if (backend === 'ollama') {
+                        if (detected?.backend === 'ollama') {
+                            try {
+                                await supervisor.stopModel('ollama');
+                                chatLog.addSystem(theme.success('Ollama 已停止。'));
+                            }
+                            catch {
+                                chatLog.addSystem(theme.warning('无法停止 Ollama。请手动执行 ollama stop。'));
+                            }
+                        }
+                        else {
+                            chatLog.addSystem(theme.dim('Ollama 未在运行。'));
+                        }
+                        tui.requestRender();
+                        return;
+                    }
+                    if (backend === 'llamacpp' || backend === 'llama.cpp') {
+                        const running = localModel.getBridge().getAllStatus().filter((s) => s.state === 'running');
+                        if (running.length > 0) {
+                            for (const m of running) {
+                                localModel.getBridge().stop(m.name).catch(() => { });
+                                chatLog.addSystem(theme.success(`Stopped: ${m.name}`));
+                            }
+                        }
+                        else {
+                            chatLog.addSystem(theme.dim('llama.cpp 未在运行。'));
+                        }
+                        tui.requestRender();
+                        return;
+                    }
+                    // 无参 → 停止所有
+                    let stopped = 0;
+                    if (detected?.backend === 'ollama') {
+                        try {
+                            await supervisor.stopModel('ollama');
+                            stopped++;
+                            chatLog.addSystem(theme.success('Ollama 已停止。'));
+                        }
+                        catch {
+                            chatLog.addSystem(theme.warning('无法停止 Ollama。'));
+                        }
+                    }
+                    const running = localModel.getBridge().getAllStatus().filter((s) => s.state === 'running');
+                    for (const m of running) {
+                        localModel.getBridge().stop(m.name).catch(() => { });
+                        stopped++;
+                        chatLog.addSystem(theme.success(`Stopped: ${m.name}`));
+                    }
+                    if (stopped === 0)
+                        chatLog.addSystem(theme.dim('没有运行中的本地服务。'));
+                    tui.requestRender();
+                    return;
+                }
+                // ── 本地模型 L2: model/local/status ──
+                case 'model/local/status': {
+                    const { detectLocalBackend } = await import('../provider/local-config.js');
+                    const detected = await detectLocalBackend();
+                    const ollamaBin = localModel.checkOllama();
+                    const llamacppBin = localModel.checkLlamacpp();
+                    chatLog.addSystem(theme.fg('── 本地模型状态 ──'));
+                    chatLog.addSystem(detected ? theme.success(`运行中: ${detected.backend} — ${detected.baseUrl}`) : theme.dim('运行中: 无'));
+                    chatLog.addSystem(theme.dim(`Ollama: ${ollamaBin ? '已安装' : '未安装'}  |  llama.cpp: ${llamacppBin ? '已安装' : '未安装'}`));
+                    const reg = localModel.list();
+                    if (reg.length > 0)
+                        chatLog.addSystem(theme.dim(`已注册模型: ${reg.map((m) => m.name).join(', ')}`));
+                    tui.requestRender();
+                    return;
+                }
+                // ── 本地模型 L2: model/local/switch ──
+                case 'model/local/switch': {
+                    try {
+                        await loop.switchProvider('local');
+                        // 显式持久化 provider 选择（switchProvider 不再负责持久化）
+                        cfg.set('provider.active', 'local');
+                        cfg.save().catch(() => { });
+                        modelName = loop.getActiveProvider().getModel();
+                        providerTypeStart = loop.getActiveProvider().getProviderType();
+                        chatLog.addSystem(theme.success(`Switched to local (${loop.getActiveProvider().getProviderType()})`));
+                        refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+                    }
+                    catch (err) {
+                        chatLog.addSystem(theme.error(`Switch failed: ${err.message}`));
+                    }
+                    tui.requestRender();
+                    return;
+                }
+                // ── 本地模型 L2: model/local/register ──
+                case 'model/local/register': {
+                    const found = await localModel.scanUnregistered();
+                    if (found.length === 0) {
+                        chatLog.addSystem(theme.dim('无新模型。已检查 models/ 目录 (GGUF) 和 ollama list。'));
+                    }
+                    else {
+                        for (const f of found) {
+                            localModel.registerModel({ name: f.name, modelFile: f.modelFile, backend: f.backend });
+                            chatLog.addSystem(theme.success(`Registered: ${f.name} (${f.backend ?? 'llama.cpp'})`));
+                        }
+                    }
+                    tui.requestRender();
+                    return;
+                }
+                // ── 本地模型 L2: model/local/unregister ──
+                case 'model/local/unregister': {
+                    if (!restArgs) {
+                        chatLog.addSystem(theme.warning('Usage: /model/local unregister <name>'));
+                        tui.requestRender();
+                        return;
+                    }
+                    chatLog.addSystem(theme.success(localModel.unregister(restArgs)));
+                    tui.requestRender();
+                    return;
+                }
+                // ── 本地模型 L2: model/local/detect ──
+                case 'model/local/detect': {
+                    const { detectLocalBackend } = await import('../provider/local-config.js');
+                    const detected = await detectLocalBackend();
+                    const ollamaBin = localModel.checkOllama();
+                    const llamacppBin = localModel.checkLlamacpp();
+                    chatLog.addSystem(theme.fg('── 本地模型检测 ──'));
+                    chatLog.addSystem(detected ? theme.success(`运行中: ${detected.backend} — ${detected.baseUrl}`) : theme.dim('运行中: 无'));
+                    chatLog.addSystem(theme.dim(`Ollama: ${ollamaBin ? '已安装 (' + ollamaBin + ')' : '未安装'}`));
+                    chatLog.addSystem(theme.dim(`llama.cpp: ${llamacppBin ? '已安装 (' + llamacppBin + ')' : '未安装'}`));
+                    const reg = localModel.list();
+                    if (reg.length > 0)
+                        chatLog.addSystem(theme.dim(`已注册模型: ${reg.map((m) => m.name).join(', ')}`));
+                    tui.requestRender();
+                    return;
+                }
+                default: {
+                    // 在线模型: model/online/<provider>/<modelName|config>
+                    if (cmdPath.startsWith('model/online/')) {
+                        const onlineParts = cmdPath.split('/');
+                        if (onlineParts.length >= 4) {
+                            const provider = onlineParts[2];
+                            const sub = onlineParts[3];
+                            if (sub === 'config') {
+                                chatLog.addSystem(theme.accent(`Configure ${provider}: Use /context <tokens> to adjust context window`));
+                                tui.requestRender();
+                                return;
+                            }
+                            localModel.getBridge().stopAll().catch(() => { });
+                            try {
+                                cfg.set(`provider.${provider}.model`, sub);
+                                cfg.save().catch(() => { });
+                                await loop.switchProvider(provider);
+                                // 显式持久化 provider 选择（switchProvider 不再负责持久化）
+                                cfg.set('provider.active', provider);
+                                cfg.save().catch(() => { });
+                                modelName = loop.getActiveProvider().getModel();
+                                providerTypeStart = loop.getActiveProvider().getProviderType();
+                                chatLog.addSystem(theme.success(`Switched to ${provider}/${sub}`));
+                                refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+                            }
+                            catch (err) {
+                                chatLog.addSystem(theme.error(`Switch failed: ${err.message}`));
+                            }
+                            tui.requestRender();
+                            return;
+                        }
+                    }
+                    // 本地模型 L1 直接切换: model/local_<modelName>
+                    if (cmdPath.startsWith('model/local_')) {
+                        const lmName = cmdPath.slice('model/local_'.length);
+                        const lm = localModel.list().find((m) => m.name === lmName);
+                        if (lm) {
+                            localModel.switch(lmName).then(async (info) => {
+                                if (info) {
+                                    chatLog.addSystem(theme.success(`Local model ${lmName} started on port ${info.port}`));
+                                    cfg.set('provider.local', {
+                                        type: 'local',
+                                        model: info.modelFile ?? lmName,
+                                        baseUrl: info.baseUrl,
+                                    });
+                                    cfg.set('provider.local.modelKey', lmName);
+                                    cfg.save().catch(() => { });
+                                    try {
+                                        await loop.switchProvider('local');
+                                        // 显式持久化 provider 选择（switchProvider 不再负责持久化）
+                                        cfg.set('provider.active', 'local');
+                                        cfg.save().catch(() => { });
+                                        modelName = loop.getActiveProvider().getModel();
+                                        providerTypeStart = loop.getActiveProvider().getProviderType();
+                                        refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+                                    }
+                                    catch (swErr) {
+                                        chatLog.addSystem(theme.warning(`Switch to local: ${swErr.message}`));
+                                    }
+                                }
+                                else {
+                                    chatLog.addSystem(theme.error(`Failed to start ${lmName}`));
+                                }
+                                tui.requestRender();
+                            }).catch((e) => {
+                                chatLog.addSystem(theme.error(`Failed: ${e.message}`));
+                                tui.requestRender();
+                            });
+                            tui.requestRender();
+                            return;
+                        }
+                    }
+                    // 在线模型 L1 直接切换: model/current_online
+                    if (cmdPath === 'model/current_online') {
+                        chatLog.addSystem(theme.dim('Already using current online model'));
+                        tui.requestRender();
+                        return;
+                    }
+                    // ── 压缩器控制: compress/* ──
+                    if (cmdPath === 'compress/threshold' || cmdPath.startsWith('compress/threshold ')) {
+                        const val = parseFloat((restArgs || '').trim());
+                        if (isNaN(val) || val < 0 || val > 1) {
+                            chatLog.addSystem(theme.warning('Usage: /compress threshold <0.0-1.0>'));
+                            tui.requestRender();
+                            return;
+                        }
+                        cfg.set('context.compressThreshold', val);
+                        cfg.save().catch(() => { });
+                        chatLog.addSystem(theme.success('Compress threshold: ') + theme.fg(String(val)));
+                        tui.requestRender();
+                        updateTokenEstimate();
+                        return;
+                    }
+                    if (cmdPath === 'compress/emergency' || cmdPath.startsWith('compress/emergency ')) {
+                        const val = parseFloat((restArgs || '').trim());
+                        if (isNaN(val) || val < 0 || val > 1) {
+                            chatLog.addSystem(theme.warning('Usage: /compress emergency <0.0-1.0>'));
+                            tui.requestRender();
+                            return;
+                        }
+                        cfg.set('context.emergencyThreshold', val);
+                        cfg.save().catch(() => { });
+                        chatLog.addSystem(theme.success('Emergency threshold: ') + theme.fg(String(val)));
+                        tui.requestRender();
+                        updateTokenEstimate();
+                        return;
+                    }
+                    if (cmdPath === 'compress/depth' || cmdPath.startsWith('compress/depth ')) {
+                        const val = parseFloat((restArgs || '').trim());
+                        if (isNaN(val) || val < 0 || val > 1) {
+                            chatLog.addSystem(theme.warning('Usage: /compress depth <0.0-1.0>'));
+                            tui.requestRender();
+                            return;
+                        }
+                        cfg.set('context.compressDepth', val);
+                        cfg.save().catch(() => { });
+                        chatLog.addSystem(theme.success('Compress depth: ') + theme.fg(String(val)));
+                        tui.requestRender();
+                        updateTokenEstimate();
+                        return;
+                    }
+                    // ── 通道管理: channel/* ──
+                    if (cmdPath.startsWith('channel/')) {
+                        const modelRouter = loop.modelRouter;
+                        if (!modelRouter) {
+                            chatLog.addSystem(theme.warning('ModelRouter not available'));
+                            tui.requestRender();
+                            return;
+                        }
+                        const registry = modelRouter.getRegistry();
+                        if (cmdPath === 'channel/list') {
+                            const channels = registry.listChannels();
+                            const roles = registry.listRoles();
+                            if (channels.length === 0) {
+                                chatLog.addSystem(theme.dim('No model channels configured. All roles use main provider.'));
+                            }
+                            else {
+                                const lines = [theme.accent('=== Model Channels ===')];
+                                for (const ch of channels) {
+                                    const chRoles = Object.entries(roles)
+                                        .filter(([, cn]) => cn === ch.name)
+                                        .map(([r]) => r);
+                                    const roleStr = chRoles.length > 0 ? theme.dim(' → ') + theme.fg(chRoles.join(', ')) : '';
+                                    lines.push(theme.fg(`  ${ch.name}`) + theme.dim(`: ${ch.provider}/${ch.model || 'default'}`) + roleStr);
+                                }
+                                lines.push('');
+                                lines.push(theme.accent('=== Role Mappings ==='));
+                                for (const [role, channel] of Object.entries(roles)) {
+                                    lines.push(theme.dim(`  ${role}`) + ' → ' + theme.fg(String(channel)));
+                                }
+                                chatLog.addSystem(lines.join('\n'));
+                            }
+                            tui.requestRender();
+                            return;
+                        }
+                        if (cmdPath === 'channel/add') {
+                            if (!restArgs) {
+                                chatLog.addSystem(theme.warning('Usage: /channel add <name> [provider] [model]'));
+                                tui.requestRender();
+                                return;
+                            }
+                            const parts = restArgs.split(/\s+/).filter(Boolean);
+                            const [name, provider, model] = parts;
+                            try {
+                                registry.upsertChannel(name, { provider, model });
+                                const info = registry.getChannelInfo(name);
+                                chatLog.addSystem(theme.success(`Channel "${name}" added (${info?.provider}${model ? '/' + model : ''})`));
+                            }
+                            catch (e) {
+                                chatLog.addSystem(theme.error(`Failed: ${e.message}`));
+                            }
+                            tui.requestRender();
+                            return;
+                        }
+                        if (cmdPath === 'channel/remove') {
+                            if (!restArgs) {
+                                chatLog.addSystem(theme.warning('Usage: /channel remove <name>'));
+                                tui.requestRender();
+                                return;
+                            }
+                            const name = restArgs.trim();
+                            try {
+                                registry.removeChannel(name);
+                                chatLog.addSystem(theme.success(`Channel "${name}" removed`));
+                            }
+                            catch (e) {
+                                chatLog.addSystem(theme.error(`Failed: ${e.message}`));
+                            }
+                            tui.requestRender();
+                            return;
+                        }
+                        if (cmdPath === 'channel/role') {
+                            if (!restArgs) {
+                                chatLog.addSystem(theme.warning('Usage: /channel role <role> <channel>'));
+                                tui.requestRender();
+                                return;
+                            }
+                            const parts = restArgs.split(/\s+/).filter(Boolean);
+                            if (parts.length < 2) {
+                                chatLog.addSystem(theme.warning('Usage: /channel role <role> <channel>'));
+                                tui.requestRender();
+                                return;
+                            }
+                            const [role, channel] = parts;
+                            try {
+                                registry.setRoleMapping(role, channel);
+                                chatLog.addSystem(theme.success(`Role "${role}" → channel "${channel}"`));
+                            }
+                            catch (e) {
+                                chatLog.addSystem(theme.error(`Failed: ${e.message}`));
+                            }
+                            tui.requestRender();
+                            return;
+                        }
+                        // ── 通道子命令: channel/<name>/info | /model | /reset ──
+                        const chMatch = cmdPath.match(/^channel\/([^/]+)\/(info|model|reset)$/);
+                        if (chMatch) {
+                            const chName = chMatch[1];
+                            const action = chMatch[2];
+                            if (action === 'info') {
+                                const info = registry.getChannelInfo(chName);
+                                if (!info) {
+                                    chatLog.addSystem(theme.warning(`Channel "${chName}" not found`));
+                                }
+                                else {
+                                    const lines = [theme.accent(`=== Channel: ${info.name}${info.isMain ? ' (main)' : ''} ===`)];
+                                    lines.push(theme.fg('  Provider: ') + info.provider);
+                                    lines.push(theme.fg('  Model:    ') + info.model);
+                                    lines.push(theme.fg('  Type:     ') + info.providerType);
+                                    if (info.description)
+                                        lines.push(theme.dim('  Desc:     ') + info.description);
+                                    if (info.roles.length > 0)
+                                        lines.push(theme.fg('  Roles:    ') + info.roles.join(', '));
+                                    chatLog.addSystem(lines.join('\n'));
+                                }
+                                tui.requestRender();
+                                return;
+                            }
+                            if (action === 'model') {
+                                const parts = (restArgs || '').split(/\s+/).filter(Boolean);
+                                if (parts.length < 1) {
+                                    chatLog.addSystem(theme.warning(`Usage: /channel/${chName}/model <provider> [model-name]`));
+                                    tui.requestRender();
+                                    return;
+                                }
+                                const provider = parts[0];
+                                const model = parts[1] || undefined;
+                                try {
+                                    registry.setChannelModel(chName, provider, model);
+                                    const updated = registry.getChannelInfo(chName);
+                                    chatLog.addSystem(theme.success(`Channel "${chName}" model set → ${updated?.provider}/${updated?.model} (runtime only, not persisted)`));
+                                }
+                                catch (e) {
+                                    chatLog.addSystem(theme.error(`Failed: ${e.message}`));
+                                }
+                                tui.requestRender();
+                                return;
+                            }
+                            if (action === 'reset') {
+                                try {
+                                    registry.resetChannelModel(chName);
+                                    const info = registry.getChannelInfo(chName);
+                                    chatLog.addSystem(theme.success(`Channel "${chName}" reset → ${info?.provider}/${info?.model}`));
+                                }
+                                catch (e) {
+                                    chatLog.addSystem(theme.error(`Failed: ${e.message}`));
+                                }
+                                tui.requestRender();
+                                return;
+                            }
+                        }
+                    }
+                    // 通用渠道 TUI 命令分发：cmdPath 如 "clawbot/login" → clawbot 渠道
+                    {
+                        const slashIdx = cmdPath.indexOf('/');
+                        if (slashIdx > 0) {
+                            const chId = cmdPath.slice(0, slashIdx);
+                            const chState = channelManager.get(chId);
+                            if (chState?.handler.handleTuiCommand) {
+                                const result = await chState.handler.handleTuiCommand(cmdPath, restArgs);
+                                if (result !== null) {
+                                    chatLog.addSystem(result);
+                                    tui.requestRender();
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                    // 通用 handler 路由：查找命令定义的 handler 字段
+                    const cmdDef = CommandRegistry.getInstance().find(cmdPath);
+                    if (cmdDef?.handler) {
+                        resolveHandler(cmdDef.handler, restArgs, localModel, chatLog, theme, tui);
+                        return;
+                    }
+                    chatLog.addSystem(theme.warning(`Unknown sub-command: /${cmdPath}`));
+                    tui.requestRender();
+                }
+            }
+        }
+        // Local slash commands
+        if (input === '/help') {
+            const grouped = getCommandsByCategory();
+            const BOX_H_L = '\u2500';
+            chatLog.addSystem(theme.fg('\u256d' + BOX_H_L.repeat(56) + '\u256e'));
+            chatLog.addSystem(theme.fg('\u2502  Available Commands'));
+            chatLog.addSystem(theme.fg('\u2570' + BOX_H_L.repeat(56) + '\u256f'));
+            chatLog.addSystem('');
+            for (const [category, cmds] of grouped) {
+                const catLabel = getCategoryLabel(category);
+                chatLog.addSystem(theme.accent('\u2500\u2500 ' + catLabel + ' \u2500\u2500'));
+                for (const c of cmds) {
+                    if (c.deprecated) {
+                        chatLog.addSystem('  ' + theme.dim(c.icon) + ' ' + theme.dim('/' + c.name) +
+                            theme.dim(' ' + c.description) + theme.warning(' [deprecated]'));
+                    }
+                    else {
+                        const args = c.args ? theme.dim(' ' + c.args) : '';
+                        const hasChildren = c.children ? theme.accent(' \u25B8') : '';
+                        chatLog.addSystem('  ' + theme.accent(c.icon) + ' ' + theme.fg('/' + c.name) +
+                            hasChildren + args + theme.dim(' ' + c.description));
+                    }
+                }
+                chatLog.addSystem('');
+            }
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        if (input === '/clear') {
+            chatLog.clearAll();
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        if (input === '/collapse') {
+            const expanded = chatLog.toggleToolsExpanded();
+            chatLog.addSystem(theme.dim('Tool outputs ') + theme.fg(expanded ? 'expanded' : 'collapsed'));
+            tui.requestRender();
+            return;
+        }
+        if (input === '/orchestrator on') {
+            if (loop.bypassManager) {
+                await loop.bypassManager.activateAgent('orchestrator');
+                const { RuntimeConfigCenter } = await import('../runtime/config-center.js');
+                RuntimeConfigCenter.getInstance().set('bypass.orchestratorEnabled', true);
+                chatLog.addSystem(theme.success('上下文编排旁路Agent 已开启'));
+            }
+            else {
+                chatLog.addSystem(theme.warning('旁路Agent 管理器未初始化'));
+            }
+            tui.requestRender();
+            return;
+        }
+        if (input === '/orchestrator off') {
+            if (loop.bypassManager) {
+                await loop.bypassManager.deactivateAgent('orchestrator');
+                const { RuntimeConfigCenter } = await import('../runtime/config-center.js');
+                RuntimeConfigCenter.getInstance().set('bypass.orchestratorEnabled', false);
+                chatLog.addSystem(theme.dim('上下文编排旁路Agent 已关闭'));
+            }
+            else {
+                chatLog.addSystem(theme.warning('旁路Agent 管理器未初始化'));
+            }
+            tui.requestRender();
+            return;
+        }
+        if (input === '/default-mode companion') {
+            const { RuntimeConfigCenter } = await import('../runtime/config-center.js');
+            const configCenter = RuntimeConfigCenter.getInstance();
+            configCenter.set('startup.defaultMode', 'companion');
+            await configCenter.save();
+            chatLog.addSystem(theme.success('启动默认模式已设为 陪伴模式 💫（下次启动生效）'));
+            tui.requestRender();
+            return;
+        }
+        if (input === '/default-mode normal') {
+            const { RuntimeConfigCenter } = await import('../runtime/config-center.js');
+            const configCenter = RuntimeConfigCenter.getInstance();
+            configCenter.set('startup.defaultMode', 'normal');
+            await configCenter.save();
+            chatLog.addSystem(theme.dim('启动默认模式已设为 普通模式 💻（下次启动生效）'));
+            tui.requestRender();
+            return;
+        }
+        if (input === '/zone4 on') {
+            knowledgeBase.setZone4Enabled(true);
+            contextComposer.activeConditions.add('zone4_enabled');
+            const { RuntimeConfigCenter: RCC } = await import('../runtime/config-center.js');
+            RCC.getInstance().set('kb.zone4', true);
+            chatLog.addSystem(theme.success('Zone 4 已开启'));
+            tui.requestRender();
+            return;
+        }
+        if (input === '/zone4 off') {
+            knowledgeBase.setZone4Enabled(false);
+            contextComposer.activeConditions.delete('zone4_enabled');
+            const { RuntimeConfigCenter: RCC1 } = await import('../runtime/config-center.js');
+            RCC1.getInstance().set('kb.zone4', false);
+            chatLog.addSystem(theme.dim('Zone 4 已关闭（知识库同步停用）'));
+            tui.requestRender();
+            return;
+        }
+        if (input === '/kb on') {
+            if (!knowledgeBase.zone4Enabled) {
+                knowledgeBase.setZone4Enabled(true);
+                contextComposer.activeConditions.add('zone4_enabled');
+                const { RuntimeConfigCenter: RCC2 } = await import('../runtime/config-center.js');
+                RCC2.getInstance().set('kb.zone4', true);
+                chatLog.addSystem(theme.dim('Zone 4 已同步开启'));
+            }
+            knowledgeBase.enable();
+            const { RuntimeConfigCenter: RCC3 } = await import('../runtime/config-center.js');
+            RCC3.getInstance().set('kb.enabled', true);
+            chatLog.addSystem(theme.success('知识库已开启 — Zone 4 将注入检索结果'));
+            tui.requestRender();
+            return;
+        }
+        if (input === '/kb off') {
+            knowledgeBase.disable();
+            const { RuntimeConfigCenter: RCC4 } = await import('../runtime/config-center.js');
+            RCC4.getInstance().set('kb.enabled', false);
+            chatLog.addSystem(theme.dim('知识库已关闭'));
+            tui.requestRender();
+            return;
+        }
+        if (input === '/precise on') {
+            const { PreciseStrategy } = await import('../context/precision/index.js');
+            if (!originalSessionDir)
+                originalSessionDir = sessionDir;
+            // 复用已有 precise session（保留积累的关键词和摘要）
+            const existingPrecise = (await sessionManager.list())
+                .find((s) => s.type === 'precise');
+            const newSession = existingPrecise ?? await sessionManager.create('precise');
+            const newSessionDir = sessionManager.getSessionDir(newSession.id);
+            const precise = new PreciseStrategy(newSessionDir);
+            loop.composeStrategy = precise;
+            await loop.switchSession(newSessionDir);
+            sessionDir = newSessionDir;
+            preciseModeActive = true;
+            const label = existingPrecise ? '恢复已有' : '新建';
+            chatLog.addSystem(theme.success(`精确模式已开启 — ${label} session: ${newSession.id}`));
+            chatLog.clearAll();
+            tui.requestRender();
+            return;
+        }
+        if (input === '/precise off') {
+            if (!preciseModeActive) {
+                chatLog.addSystem(theme.dim('精确模式未开启'));
+                tui.requestRender();
+                return;
+            }
+            const { DefaultStrategy } = await import('../context/precision/index.js');
+            loop.composeStrategy = new DefaultStrategy();
+            if (originalSessionDir) {
+                await loop.switchSession(originalSessionDir);
+                sessionDir = originalSessionDir;
+                originalSessionDir = null;
+                chatLog.clearAll();
+                replayEvents(chatLog, sessionDir);
+            }
+            preciseModeActive = false;
+            chatLog.addSystem(theme.dim('精确模式已关闭，已恢复原始 session'));
+            tui.requestRender();
+            return;
+        }
+        if (input === '/exit') {
+            chatLog.addSystem(theme.dim('Goodbye.'));
+            tui.requestRender();
+            await channelManager.stopAll();
+            await loop.shutdown();
+            await supervisor.shutdownAll();
+            tui.stop();
+            process.exit(0);
+        }
+        const cfg = RuntimeConfigCenter.getInstance();
+        if (input === '/status') {
+            const s = cfg.getAll();
+            const items = [
+                ['Provider', s.provider.active],
+                ['Model', s.provider[s.provider.active]],
+                ['Active Workflow', 'none'],
+                ['Max Context', `${s.session.maxContext.toLocaleString()} tokens`],
+                ['Max Turns', s.session.maxTurns],
+                ['Compress Threshold', s.context.compressThreshold.toFixed(2)],
+                ['Confirmation', s.safety.requireConfirmation ? 'on' : 'off'],
+                ['Scavenge', s.repair.scavenge.enabled ? 'on' : 'off'],
+                ['Storm', s.repair.storm.enabled ? 'on' : 'off'],
+                ['Storm Window', s.repair.storm.windowSize],
+                ['Storm Threshold', s.repair.storm.threshold],
+                ['Log Level', s.logging.level],
+            ];
+            chatLog.addSystem(theme.accent('\u2500\u2500 Status \u2500\u2500'));
+            for (const [label, value] of items) {
+                let display;
+                if (typeof value === 'object' && value !== null && 'model' in value) {
+                    display = String(value.model);
+                }
+                else {
+                    display = String(value ?? 'N/A');
+                }
+                chatLog.addSystem('  ' + theme.fg(label) + theme.dim(': ') + theme.fg(display));
+            }
+            const sources = loop.getModelSources();
+            if (sources) {
+                chatLog.addSystem('');
+                chatLog.addSystem(theme.accent('\u2500\u2500 Model Routing \u2500\u2500'));
+                const labels = {
+                    assessment: '评估',
+                    planning: '规划',
+                    compression: '压缩',
+                };
+                const sourceColor = (src) => src === 'local' ? theme.success(src) : theme.accent(src);
+                for (const [role, source] of Object.entries(sources)) {
+                    const label = labels[role] ?? role;
+                    chatLog.addSystem('  ' + theme.fg(label) + theme.dim(': ') + sourceColor(String(source)));
+                }
+            }
+            chatLog.addSystem('');
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        // ── /context <tokens> ──
+        if (input.startsWith('/context ')) {
+            const tokens = parseInt(input.slice(9).trim(), 10);
+            const activeP = loop.getActiveProvider();
+            const modelCtxWindow = getModelContextWindow(activeP.getProviderType(), activeP.getModel());
+            const upper = modelCtxWindow; // 当前模型支持的最大上下文
+            if (isNaN(tokens) || tokens < 1 || tokens > upper) {
+                chatLog.addSystem(theme.warning(`Usage: /context <1-${upper.toLocaleString()}>`) + theme.dim(` (model: ${activeP.getModel()})`));
+                tui.requestRender();
+                updateTokenEstimate();
+                return;
+            }
+            cfg.set('session.maxContext', tokens);
+            cfg.save().catch(() => { });
+            chatLog.addSystem(theme.success('Max context set to ') + theme.fg(tokens.toLocaleString() + ' tokens'));
+            refreshStatus(loop.getTurnInfo(lastTurnCount, lastTokensUsed));
+            updateTokenEstimate();
+            return;
+        }
+        // ── /turns <n> ──
+        if (input.startsWith('/turns ')) {
+            const n = parseInt(input.slice(7).trim(), 10);
+            if (isNaN(n) || n < 1 || n > 100) {
+                chatLog.addSystem(theme.warning('Usage: /turns <1-100>'));
+                tui.requestRender();
+                updateTokenEstimate();
+                return;
+            }
+            cfg.set('session.maxTurns', n);
+            cfg.save().catch(() => { });
+            chatLog.addSystem(theme.success('Max turns set to ') + theme.fg(String(n)));
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        // ── /threshold <0.0-1.0> ──
+        // ── /compress sub-commands (handled via handleSlashSubCommand) ──
+        // ── /threshold <0.0-1.0> (deprecated: use /compress threshold) ──
+        if (input.startsWith('/threshold ')) {
+            const val = parseFloat(input.slice(11).trim());
+            if (isNaN(val) || val < 0 || val > 1) {
+                chatLog.addSystem(theme.warning('Usage: /threshold <0.0-1.0>'));
+                tui.requestRender();
+                updateTokenEstimate();
+                return;
+            }
+            cfg.set('context.compressThreshold', val);
+            cfg.save().catch(() => { });
+            chatLog.addSystem(theme.success('Compression threshold set to ') + theme.fg(val.toFixed(2)));
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        // ── /confirm on|off ──
+        if (input.startsWith('/confirm ')) {
+            const arg = input.slice(9).trim();
+            if (arg === 'on') {
+                cfg.set('safety.requireConfirmation', true);
+                cfg.save().catch(() => { });
+                chatLog.addSystem(theme.success('Tool confirmation ') + theme.fg('enabled'));
+            }
+            else if (arg === 'off') {
+                cfg.set('safety.requireConfirmation', false);
+                cfg.save().catch(() => { });
+                chatLog.addSystem(theme.warning('Tool confirmation ') + theme.fg('disabled'));
+            }
+            else {
+                chatLog.addSystem(theme.warning('Usage: /confirm <on|off>'));
+            }
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        // ── /log <level> ──
+        if (input.startsWith('/log ')) {
+            const arg = input.slice(5).trim();
+            const validLevels = ['debug', 'info', 'warn', 'error', 'off'];
+            if (validLevels.includes(arg)) {
+                cfg.set('logging.level', arg);
+                cfg.save().catch(() => { });
+                chatLog.addSystem(theme.success('Log level set to ') + theme.fg(arg));
+            }
+            else {
+                chatLog.addSystem(theme.warning('Usage: /log <debug|info|warn|error|off>'));
+            }
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        // ── /scavenge on|off ──
+        if (input.startsWith('/scavenge ')) {
+            const arg = input.slice(10).trim();
+            if (arg === 'on') {
+                cfg.set('repair.scavenge.enabled', true);
+                cfg.save().catch(() => { });
+                chatLog.addSystem(theme.success('Scavenge repair ') + theme.fg('enabled'));
+            }
+            else if (arg === 'off') {
+                cfg.set('repair.scavenge.enabled', false);
+                cfg.save().catch(() => { });
+                chatLog.addSystem(theme.warning('Scavenge repair ') + theme.fg('disabled'));
+            }
+            else {
+                chatLog.addSystem(theme.warning('Usage: /scavenge <on|off>'));
+            }
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        // ── /storm on|off ──
+        if (input.startsWith('/storm ')) {
+            const arg = input.slice(7).trim();
+            if (arg === 'on') {
+                cfg.set('repair.storm.enabled', true);
+                cfg.save().catch(() => { });
+                chatLog.addSystem(theme.success('Storm protection ') + theme.fg('enabled'));
+            }
+            else if (arg === 'off') {
+                cfg.set('repair.storm.enabled', false);
+                cfg.save().catch(() => { });
+                chatLog.addSystem(theme.warning('Storm protection ') + theme.fg('disabled'));
+            }
+            else {
+                chatLog.addSystem(theme.warning('Usage: /storm <on|off>'));
+            }
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        // ── /storm-win <2-20> ──
+        if (input.startsWith('/storm-win ')) {
+            const n = parseInt(input.slice(11).trim(), 10);
+            if (isNaN(n) || n < 2 || n > 20) {
+                chatLog.addSystem(theme.warning('Usage: /storm-win <2-20>'));
+                tui.requestRender();
+                updateTokenEstimate();
+                return;
+            }
+            cfg.set('repair.storm.windowSize', n);
+            cfg.save().catch(() => { });
+            chatLog.addSystem(theme.success('Storm window size set to ') + theme.fg(String(n)));
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        // ── /storm-th <1-10> ──
+        if (input.startsWith('/storm-th ')) {
+            const n = parseInt(input.slice(10).trim(), 10);
+            if (isNaN(n) || n < 1 || n > 10) {
+                chatLog.addSystem(theme.warning('Usage: /storm-th <1-10>'));
+                tui.requestRender();
+                updateTokenEstimate();
+                return;
+            }
+            cfg.set('repair.storm.threshold', n);
+            cfg.save().catch(() => { });
+            chatLog.addSystem(theme.success('Storm threshold set to ') + theme.fg(String(n)));
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        // ── /schedule ──
+        if (input === '/schedule') {
+            const scheduler = loop.getScheduler();
+            if (!scheduler) {
+                chatLog.addSystem(theme.dim('No scheduler configured'));
+            }
+            else {
+                const allTasks = scheduler.getTasks();
+                const activeTasks = allTasks.filter((t) => t.enabled && t.nextRunAt !== null);
+                const disabledCount = allTasks.length - activeTasks.length;
+                if (activeTasks.length === 0) {
+                    chatLog.addSystem(theme.dim('No active scheduled tasks'));
+                    if (disabledCount > 0) {
+                        chatLog.addSystem(theme.dim(`(+${disabledCount} disabled/expired tasks)`));
+                    }
+                }
+                else {
+                    chatLog.addSystem(theme.accent(`Scheduled Tasks (${activeTasks.length} active)`));
+                    for (const task of activeTasks) {
+                        const nextRun = task.nextRunAt
+                            ? new Date(task.nextRunAt).toLocaleString()
+                            : 'N/A';
+                        const typeLabel = theme.dim(`[${task.scheduleType}]`);
+                        const runInfo = theme.dim(` | runs: ${task.runCount}`);
+                        chatLog.addSystem('  ' +
+                            theme.fg(task.name) +
+                            ' ' +
+                            typeLabel +
+                            theme.dim(' | next: ') +
+                            theme.fg(nextRun) +
+                            runInfo);
+                    }
+                    if (disabledCount > 0) {
+                        chatLog.addSystem(theme.dim(`(+${disabledCount} disabled/expired tasks not shown)`));
+                    }
+                }
+            }
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        // ── /schedule-add <name> <time> ──
+        if (input.startsWith('/schedule-add ')) {
+            const args = input.slice(14).trim();
+            const spaceIdx = args.lastIndexOf(' ');
+            if (spaceIdx < 0) {
+                chatLog.addSystem(theme.warning('Usage: /schedule-add <name> <HH:mm>'));
+                tui.requestRender();
+                updateTokenEstimate();
+                return;
+            }
+            const name = args.slice(0, spaceIdx).trim();
+            const time = args.slice(spaceIdx + 1).trim();
+            if (!/^\d{2}:\d{2}$/.test(time)) {
+                chatLog.addSystem(theme.warning('Time must be in HH:mm format (e.g., 02:00)'));
+                tui.requestRender();
+                updateTokenEstimate();
+                return;
+            }
+            await loop.addScheduledTask(name, 'daily', time);
+            chatLog.addSystem(theme.success('Task added: ') +
+                theme.fg(name) +
+                theme.dim(' at ') +
+                theme.fg(time) +
+                theme.dim(' daily'));
+            tui.requestRender();
+            updateTokenEstimate();
+            return;
+        }
+        // ── /restart ──
+        if (input === '/restart') {
+            chatLog.addSystem(theme.accent('Restarting...'));
+            tui.requestRender();
+            const fsSync = (await import('node:fs')).default;
+            const restartFile = path.join(os.homedir(), '.agent', '.restart-session');
+            fsSync.mkdirSync(path.dirname(restartFile), { recursive: true });
+            fsSync.writeFileSync(restartFile, path.basename(sessionDir), 'utf-8');
+            setTimeout(() => process.exit(42), 200);
+            return;
+        }
+        // ── /new ──
+        if (input === '/new') {
+            chatLog.addSystem(theme.accent('Starting new session...'));
+            tui.requestRender();
+            const fsSync = (await import('node:fs')).default;
+            const newFlag = path.join(os.homedir(), '.agent', '.new-session');
+            fsSync.mkdirSync(path.dirname(newFlag), { recursive: true });
+            fsSync.writeFileSync(newFlag, 'true', 'utf-8');
+            setTimeout(() => process.exit(42), 200);
+            return;
+        }
+        // \u2500\u2500 Message Queue Integration \u2500\u2500
+        const mode = MessageQueue.detectMode(input);
+        const cleanText = MessageQueue.stripMarkers(input);
+        if (isProcessing || loop.pendingTaskName) {
+            messageQueue.enqueue(cleanText, mode);
+            if (mode === QueueMessageMode.Insert) {
+                chatLog.addSystem(theme.warning(`\u23e9 Inserting: ${truncateMsg(cleanText)}`));
+                loop.interrupt();
+            }
+            else {
+                chatLog.addSystem(theme.dim(`\u23f3 Queued (#${messageQueue.size}): ${truncateMsg(cleanText)}`));
+            }
+            updateTokenEstimate();
+            tui.requestRender();
+            return;
+        }
+        await processBatch(cleanText);
+    }
+    // ── Editor callbacks ──
+    editor.onSubmit = (text) => {
+        void handleInput(text);
+    };
+    editor.onCtrlC = () => {
+        editor.setText('');
+        if (isProcessing) {
+            loop.interrupt();
+        }
+        else {
+            chatLog.addSystem(theme.warning('Ctrl+C \u2014 press again to exit'));
+        }
+        tui.requestRender();
+    };
+    editor.onEscape = () => {
+        if (searchMode) {
+            closeSearch();
+        }
+        tui.requestRender();
+    };
+    editor.onCtrlL = () => {
+        chatLog.clearAll();
+        tui.requestRender();
+    };
+    editor.onCtrlP = () => {
+        loop.toggleProvider();
+        modelName = loop.getActiveProvider().getModel();
+        providerTypeStart = loop.getActiveProvider().getProviderType();
+        const providerInfo = loop.getProviderRoutingInfo();
+        if (providerInfo) {
+            chatLog.addSystem(theme.accent('Provider toggled to ') +
+                theme.fg(providerInfo.providerLabel) +
+                theme.dim(` (${providerInfo.mode})`));
+        }
+        else {
+            chatLog.addSystem(theme.dim('No ProviderRouter configured.'));
+        }
+        const statsP = statsManager.get(sessionDir);
+        statsP.then((st) => {
+            const tc = st.turn_count ?? 0;
+            refreshStatus(loop.getTurnInfo(tc, st.current_context_tokens ?? 0));
+        }).catch(() => { });
+        tui.requestRender();
+    };
+    // ── Queue cancellation: Backspace on empty input pops last queued message ──
+    editor.onBackspaceOnEmpty = () => {
+        if (messageQueue.isEmpty())
+            return;
+        const removed = messageQueue.pop();
+        if (removed) {
+            chatLog.addSystem(theme.dim(`[queue] removed: "${truncateMsg(removed.text)}" (${messageQueue.size} remaining)`));
+            updateTokenEstimate();
+            tui.requestRender();
+        }
+    };
+    // ── Slash command autocomplete ──
+    const slashCommands = filterCommands('').map((cmd) => ({
+        name: cmd.name,
+        description: cmd.description,
+        argumentHint: cmd.args,
+    }));
+    const autocomplete = new CombinedAutocompleteProvider(slashCommands, process.cwd());
+    editor.setAutocompleteProvider(autocomplete);
+    // ── Global input listeners (for shortcuts not caught by the editor) ──
+    let ctrlCCount = 0;
+    let lastCtrlCTime = 0;
+    let searchMode = false;
+    let searchQuery = '';
+    let searchMatches = [];
+    let searchMatchIndex = 0;
+    tui.addInputListener((data) => {
+        // ── Slash autocomplete: Space → accept completion + insert space (never submit) ──
+        // 只有回车键才发送消息，空格键仅用于接受补全并插入空格
+        if (matchesKey(data, Key.space)) {
+            const text = editor.getText().trimStart();
+            if (text.startsWith('/') && !text.includes(' ') && editor.isShowingAutocomplete()) {
+                // 接受补全并插入空格，让用户继续输入参数
+                editor.handleInput('\t');
+                editor.handleInput(' ');
+                return { consume: true };
+            }
+        }
+        // ── Ask User form: full keyboard navigation ──
+        if (askUserState) {
+            const st = askUserState;
+            const suppIdx = st.questions.length;
+            const totalTabs = suppIdx + 1;
+            const currentQ = st.activeQuestion < suppIdx ? st.questions[st.activeQuestion] : null;
+            const opts = currentQ?.options ?? [];
+            const isMulti = currentQ?.multiSelect ?? false;
+            // Enter: submit (on "补充" tab or when focused on custom input)
+            if (matchesKey(data, Key.enter)) {
+                // 收集当前活动的自定义输入
+                const editIdx = st.activeQuestion;
+                const currentCustom = st.customTexts.get(editIdx) ?? '';
+                if (currentCustom.trim()) {
+                    st.customTexts.set(editIdx, currentCustom.trim());
+                }
+                resolveAskUser();
+                return { consume: true };
+            }
+            // Escape: cancel (discard form)
+            if (matchesKey(data, Key.escape)) {
+                askUserContent.setText('');
+                askUserBar.setText('');
+                askUserState = null;
+                st.resolve('{}');
+                tui.requestRender();
+                return { consume: true };
+            }
+            // Left/Right: switch tabs
+            if (matchesKey(data, Key.left)) {
+                st.activeQuestion = (st.activeQuestion + totalTabs - 1) % totalTabs;
+                st.activeOption = 0;
+                renderAskUserForm();
+                tui.requestRender();
+                return { consume: true };
+            }
+            if (matchesKey(data, Key.right)) {
+                st.activeQuestion = (st.activeQuestion + 1) % totalTabs;
+                st.activeOption = 0;
+                renderAskUserForm();
+                tui.requestRender();
+                return { consume: true };
+            }
+            // Up/Down: navigate options (only on question tabs)
+            if (st.activeQuestion < suppIdx && opts.length > 0) {
+                if (matchesKey(data, Key.up)) {
+                    st.activeOption = (st.activeOption + opts.length - 1) % opts.length;
+                    renderAskUserForm();
+                    tui.requestRender();
+                    return { consume: true };
+                }
+                if (matchesKey(data, Key.down)) {
+                    st.activeOption = (st.activeOption + 1) % opts.length;
+                    renderAskUserForm();
+                    tui.requestRender();
+                    return { consume: true };
+                }
+            }
+            // Space: toggle checkbox (works for both multiSelect and single-select)
+            if (matchesKey(data, Key.space)) {
+                if (st.activeQuestion < suppIdx && opts.length > 0) {
+                    const sel = st.selectedOptions.get(st.activeQuestion) ?? new Set();
+                    if (sel.has(st.activeOption)) {
+                        sel.delete(st.activeOption); // 取消选中
+                    }
+                    else {
+                        if (isMulti) {
+                            sel.add(st.activeOption);
+                        }
+                        else {
+                            // 单选：清除其它，只选中当前
+                            sel.clear();
+                            sel.add(st.activeOption);
+                        }
+                    }
+                    st.selectedOptions.set(st.activeQuestion, sel);
+                }
+                renderAskUserForm();
+                tui.requestRender();
+                return { consume: true };
+            }
+            // Backspace: delete last char in custom text
+            if (matchesKey(data, Key.backspace)) {
+                const editIdx = st.activeQuestion;
+                const current = st.customTexts.get(editIdx) ?? '';
+                st.customTexts.set(editIdx, current.slice(0, -1));
+                renderAskUserForm();
+                tui.requestRender();
+                return { consume: true };
+            }
+            // Typing characters → add to current tab's custom text buffer
+            // data is a string; printable chars have length 1 and are not control chars
+            if (typeof data === 'string' && data.length === 1 && data.charCodeAt(0) >= 32) {
+                const editIdx = st.activeQuestion;
+                const current = st.customTexts.get(editIdx) ?? '';
+                st.customTexts.set(editIdx, current + data);
+                renderAskUserForm();
+                tui.requestRender();
+                return { consume: true };
+            }
+            // Consume all other keys during ask_user
+            return { consume: true };
+        }
+        // ── Permission bar: Left/Right arrows + Enter ──
+        if (permissionQueue.length > 0) {
+            if (matchesKey(data, Key.left)) {
+                permissionSelection = (permissionSelection + 3) % 4;
+                updatePermissionBar();
+                tui.requestRender();
+                return { consume: true };
+            }
+            if (matchesKey(data, Key.right)) {
+                permissionSelection = (permissionSelection + 1) % 4;
+                updatePermissionBar();
+                tui.requestRender();
+                return { consume: true };
+            }
+            if (matchesKey(data, Key.enter)) {
+                const options = ['yes', 'aor', 'always', 'no'];
+                resolvePermission(options[permissionSelection]);
+                return { consume: true };
+            }
+            return { consume: true }; // consume all other keys during permission
+        }
+        // Ctrl+C double-tap exit (global, catches the case when editor is not the source)
+        if (matchesKey(data, Key.ctrl('c'))) {
+            const now = Date.now();
+            if (now - lastCtrlCTime < 1000) {
+                ctrlCCount++;
+            }
+            else {
+                ctrlCCount = 1;
+            }
+            lastCtrlCTime = now;
+            // Note: editor.onCtrlC handles the first press; this handles the second
+            return undefined; // let editor handle Ctrl+C
+        }
+        // Ctrl+T: toggle tools expanded/collapsed
+        if (matchesKey(data, Key.ctrl('t'))) {
+            const expanded = chatLog.toggleToolsExpanded();
+            chatLog.addSystem(theme.dim('Tools ') + theme.fg(expanded ? 'expanded' : 'collapsed'));
+            tui.requestRender();
+            return { consume: true };
+        }
+        // Ctrl+F: toggle search overlay
+        if (matchesKey(data, Key.ctrl('f'))) {
+            if (searchMode) {
+                closeSearch();
+            }
+            else {
+                openSearch();
+            }
+            return { consume: true };
+        }
+        // PgUp: scroll chat up
+        if (matchesKey(data, Key.pageUp)) {
+            chatLog.scrollToLine(-10);
+            tui.requestRender();
+            return { consume: true };
+        }
+        // PgDn: scroll chat down
+        if (matchesKey(data, Key.pageDown)) {
+            chatLog.scrollToLine(10);
+            tui.requestRender();
+            return { consume: true };
+        }
+        // Home: jump to top
+        if (matchesKey(data, Key.home)) {
+            chatLog.scrollToLine(0);
+            tui.requestRender();
+            return { consume: true };
+        }
+        // End: jump to bottom
+        if (matchesKey(data, Key.end)) {
+            chatLog.pinToBottom();
+            tui.requestRender();
+            return { consume: true };
+        }
+        // Arrow Up: history browse (when editor text is empty)
+        if (matchesKey(data, Key.up)) {
+            if (slashSubPanelActive)
+                return undefined;
+            const currentText = editor.getText();
+            if (currentText === '' && inputHistory.length > 0) {
+                if (historyIndex === -1) {
+                    historyIndex = inputHistory.length - 1;
+                }
+                else if (historyIndex > 0) {
+                    historyIndex--;
+                }
+                editor.setText(inputHistory[historyIndex]);
+                tui.requestRender();
+                return { consume: true };
+            }
+        }
+        // Arrow Down: history browse
+        if (matchesKey(data, Key.down)) {
+            if (slashSubPanelActive)
+                return undefined;
+            if (historyIndex >= 0) {
+                if (historyIndex < inputHistory.length - 1) {
+                    historyIndex++;
+                    editor.setText(inputHistory[historyIndex]);
+                }
+                else {
+                    historyIndex = -1;
+                    editor.setText('');
+                }
+                tui.requestRender();
+                return { consume: true };
+            }
+        }
+        return undefined;
+    });
+    // ── Search helpers ──
+    let searchOverlayContainer = null;
+    let searchOverlayText = null;
+    /** Highlight occurrences of `query` in `text` (case-insensitive) using accent color */
+    function highlightMatch(text, query, maxLen = 80) {
+        if (!query)
+            return theme.dim(text.slice(0, maxLen));
+        const truncated = text.slice(0, maxLen);
+        const lower = truncated.toLowerCase();
+        const q = query.toLowerCase();
+        let result = '';
+        let idx = 0;
+        while (idx < truncated.length) {
+            const found = lower.indexOf(q, idx);
+            if (found === -1) {
+                result += theme.dim(truncated.slice(idx));
+                break;
+            }
+            if (found > idx) {
+                result += theme.dim(truncated.slice(idx, found));
+            }
+            result += theme.accent(truncated.slice(found, found + q.length));
+            idx = found + q.length;
+        }
+        return result;
+    }
+    function performSearch(query) {
+        searchQuery = query;
+        const contentLines = chatLog.getContentLines();
+        const cleanLines = contentLines.map((l) => 
+        // eslint-disable-next-line no-control-regex
+        l.replace(/\x1b\[[0-9;]*m/g, ''));
+        searchMatches = [];
+        const lowerQuery = query.toLowerCase();
+        for (let i = 0; i < cleanLines.length; i++) {
+            if (cleanLines[i].toLowerCase().includes(lowerQuery)) {
+                searchMatches.push(i);
+            }
+        }
+        searchMatchIndex = 0;
+        if (searchOverlayText) {
+            if (searchMatches.length > 0) {
+                const preview = highlightMatch(cleanLines[searchMatches[0]], query);
+                searchOverlayText.setText(theme.accent('Search: ') +
+                    theme.fg(query) +
+                    theme.dim(` [${searchMatchIndex + 1}/${searchMatches.length}]`) +
+                    '\n' +
+                    preview);
+            }
+            else {
+                searchOverlayText.setText(theme.accent('Search: ') + theme.fg(query) + theme.dim(' [0/0]'));
+            }
+        }
+        tui.requestRender();
+    }
+    function nextSearchMatch() {
+        if (searchMatches.length === 0)
+            return;
+        searchMatchIndex = (searchMatchIndex + 1) % searchMatches.length;
+        chatLog.scrollToLine(searchMatches[searchMatchIndex]);
+        if (searchOverlayText) {
+            const contentLines = chatLog.getContentLines();
+            const cleanLines = contentLines.map((l) => 
+            // eslint-disable-next-line no-control-regex
+            l.replace(/\x1b\[[0-9;]*m/g, ''));
+            const preview = highlightMatch(cleanLines[searchMatches[searchMatchIndex]] ?? '', searchQuery);
+            searchOverlayText.setText(theme.accent('Search: ') +
+                theme.fg(searchQuery) +
+                theme.dim(` [${searchMatchIndex + 1}/${searchMatches.length}]`) +
+                '\n' +
+                preview);
+        }
+        tui.requestRender();
+    }
+    function openSearch() {
+        searchMode = true;
+        searchQuery = '';
+        searchMatches = [];
+        searchMatchIndex = 0;
+        searchOverlayContainer = new Container();
+        searchOverlayText = new Text(theme.accent('Search: ') + theme.dim('type to search, Enter for next, Esc to close'), 0, 0);
+        searchOverlayContainer.addChild(searchOverlayText);
+        tui.showOverlay(searchOverlayContainer);
+        tui.requestRender();
+        // Add a temporary input listener for search typing
+        const searchListenerId = `search_${Date.now()}`;
+        tui.addInputListener((data) => {
+            if (!searchMode)
+                return undefined;
+            if (matchesKey(data, Key.escape)) {
+                closeSearch();
+                return { consume: true };
+            }
+            if (matchesKey(data, Key.enter)) {
+                nextSearchMatch();
+                return { consume: true };
+            }
+            if (matchesKey(data, Key.backspace)) {
+                if (searchQuery.length > 0) {
+                    searchQuery = searchQuery.slice(0, -1);
+                    performSearch(searchQuery);
+                }
+                return { consume: true };
+            }
+            // Regular character input
+            if (typeof data === 'string' && data.length === 1 && !data.startsWith('\x1b')) {
+                searchQuery += data;
+                performSearch(searchQuery);
+                return { consume: true };
+            }
+            // Consume all other input while searching
+            return { consume: true };
+        });
+    }
+    function closeSearch() {
+        searchMode = false;
+        searchQuery = '';
+        searchMatches = [];
+        searchMatchIndex = 0;
+        searchOverlayText = null;
+        if (searchOverlayContainer) {
+            tui.hideOverlay();
+            searchOverlayContainer = null;
+        }
+        tui.requestRender();
+    }
+    // ── Initial render ──
+    const stats = await statsManager.get(sessionDir);
+    const initialInfo = loop.getTurnInfo(0, stats.current_context_tokens ?? 0);
+    refreshStatus(initialInfo);
+    updateTokenEstimate();
+    // ── Start TUI ──
+    tui.start();
+    // ── Auto-send continuation message after restart ──
+    if (continuationMessage) {
+        // Use setImmediate to let the TUI render its initial frame first
+        setImmediate(() => {
+            handleInput(continuationMessage);
+        });
+    }
+    // ── Wait for exit (Ctrl+C double-tap or Ctrl+D) ──
+    const exitPromise = new Promise((resolve) => {
+        const checkExitInterval = setInterval(() => {
+            if (ctrlCCount >= 2) {
+                clearInterval(checkExitInterval);
+                resolve();
+            }
+        }, 200);
+    });
+    await exitPromise;
+    // ── Cleanup ──
+    tui.stop();
+    await channelManager.stopAll();
+    await loop.shutdown();
+    // 清理插件钩子
+    for (const cleanup of cleanupFns)
+        cleanup();
+    await supervisor.shutdownAll();
+    process.stderr.write = origStderrWrite;
+    logStream.end();
+}
+//# sourceMappingURL=tui.js.map