kiku-agent 1.0.0

package/server/agent/cli.js

@@ -0,0 +1,1111 @@
+#!/usr/bin/env node
+
+import readline from 'node:readline';
+import { stdin as input } from 'node:process';
+import { existsSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { KikuAgent } from './agentCore.js';
+import { LMStudioClient } from './llmClient.js';
+import { toolsSchema, toolHandlers, executeTool } from './tools.js';
+import { config } from './config.js';
+import { audioPlayer } from './audioPlayer.js';
+import { routeCommand } from './commands.js';
+import { eventBus, Events } from './eventBus.js';
+import { AgentStates } from './agentState.js';
+import { sanitizeQuery } from './sanitizer.js';
+import { isAbortError } from './errors.js';
+import { COMMAND_DEFINITIONS, SUB_COMMANDS, findCommandDefinition } from './commandRegistry.js';
+
+import {
+  C, getStringDisplayWidth, getFullWidth, wrapText, stripAnsi, fitStyledText,
+  previousGraphemeBoundary, nextGraphemeBoundary, sliceLineForDisplay,
+  printSolidBannerRow, printSolidPanel, formatTerminalMarkdown,
+  parseMarkdownTableRow, isMarkdownTableSeparator, expandMarkdownLinks,
+  printWelcomeHero, randomFanName, setupOutputInterception,
+  rawWrite, INPUT_PLACEHOLDER, UI_ICONS,
+  spinnerFrames, thinkingFrames,
+} from './ui.js';
+
+let activeAbortController = null;
+let isProcessing = false;
+let lastQuery = null;
+let queryCount = 0;
+let nextQueryNumber = 1;
+let activeQueryNumber = null;
+const queryQueue = [];
+const deferredCommands = [];
+let globalTuiPrompt = null;
+let lastQueryDetails = null;
+const queryDetails = new Map();
+
+function parseCliArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    query: null,
+    model: 'google/gemma-4-e4b',
+    url: null,
+    showTools: false,
+    showStats: false,
+    thinking: 'show',
+    verbose: false,
+    help: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') options.help = true;
+    else if (arg === '--tools' || arg === '-t') options.showTools = true;
+    else if (arg === '--stats' || arg === '-s') options.showStats = true;
+    else if (arg === '--verbose' || arg === '-v') { options.verbose = true; options.thinking = 'show'; }
+    else if (arg === '--thinking') options.thinking = args[++i] || 'show';
+    else if (arg === '--model' || arg === '-m') options.model = args[++i] || options.model;
+    else if (arg === '--url' || arg === '-u') options.url = args[++i];
+    else if (arg === '--query' || arg === '-q') options.query = args[++i];
+    else if (!arg.startsWith('-') && !options.query) { options.query = args.slice(i).join(' '); break; }
+  }
+  return options;
+}
+
+async function waitForLMStudio(baseUrl, timeoutMs = 30000) {
+  const client = new LMStudioClient({ baseUrl });
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const health = await client.checkConnection();
+    if (health.connected) return health;
+    await new Promise(r => setTimeout(r, 1000));
+  }
+  return null;
+}
+
+async function attemptAutoStartLMStudio(baseUrl, model) {
+  const isWin = process.platform === 'win32';
+  const isMac = process.platform === 'darwin';
+
+  const candidates = isWin
+    ? [
+        `${process.env.LOCALAPPDATA}\\LM Studio\\LM Studio.exe`,
+        `${process.env.LOCALAPPDATA}\\Programs\\LM Studio\\LM Studio.exe`,
+        'C:\\Program Files\\LM Studio\\LM Studio.exe'
+      ]
+    : isMac
+      ? ['/Applications/LM Studio.app/Contents/MacOS/LM Studio']
+      : ['lmstudio', '/usr/local/bin/lmstudio', '/opt/lmstudio/bin/lmstudio'];
+
+  const exe = candidates.find(p => {
+    if (p.includes('/') || p.includes('\\')) {
+      try { return existsSync(p); } catch { return false; }
+    }
+    return true;
+  });
+
+  if (!exe) return null;
+  console.log(`  ${C.cyberCyan}attempting to auto-start LM Studio...${C.reset}`);
+
+  try {
+    let port = '1234';
+    try { const parsedUrl = new URL(baseUrl); if (parsedUrl.port) port = parsedUrl.port; } catch {}
+
+    const child = spawn(exe, isWin
+      ? ['--model', model, '--serve', '--port', port]
+      : ['serve', '--model', model, '--port', port],
+      { detached: true, stdio: 'ignore', windowsHide: true }
+    );
+    child.unref();
+
+    return await waitForLMStudio(baseUrl, 45000);
+  } catch { return null; }
+}
+
+function extractPreview(result, toolName) {
+  const MAX = 80;
+  let raw = '';
+  if (result.content) raw = result.content;
+  else if (result.results && Array.isArray(result.results) && result.results.length > 0) {
+    const first = result.results[0];
+    raw = first.title || first.snippet || first.url || '';
+  } else if (result.works) raw = result.works.map(w => w.titleTh || w.titleCn).filter(Boolean).join(', ');
+  else if (result.songs) raw = result.songs.map(s => s.title).filter(Boolean).join(', ');
+  else if (result.brands) raw = result.brands.map(b => b.brand).filter(Boolean).join(', ');
+  else if (result.profile) raw = `${result.profile.nameTh || ''} ${result.profile.nameCn || ''}`.trim();
+  else if (result.stats) raw = `${result.stats.totalWorks || 0} works`;
+
+  if (!raw) return '';
+  raw = raw.replace(/\s+/g, ' ').trim();
+  return raw.length > MAX ? raw.slice(0, MAX) + '…' : raw;
+}
+
+function cleanThinkingLine(line) {
+  if (!line) return '';
+  return line
+    .replace(/\*\*\*?([^*]+)\*\*\*/g, '$1')
+    .replace(/\*([^\*\n]+)\*/g, '$1')
+    .replace(/^(\s*)[-*]\s+/gm, '$1• ')
+    .replace(/\*/g, '')
+    .trim();
+}
+
+function printQueryDetails(reference = '') {
+  const normalized = String(reference || '').trim().replace(/^q/i, '');
+  const requestedNumber = normalized ? Number.parseInt(normalized, 10) : lastQueryDetails?.number;
+  const details = normalized
+    ? (Number.isInteger(requestedNumber) ? queryDetails.get(requestedNumber) : null)
+    : lastQueryDetails;
+
+  if (!details) {
+    console.log(`\n  ${C.amber}[NOT FOUND] No completed query details. Use ${C.cyberCyan}/details Q1${C.reset}${C.amber}.${C.reset}\n`);
+    return;
+  }
+
+  const width = Math.max(16, getFullWidth() - 8);
+  const safeLines = (label, value) => {
+    const text = `${label}: ${String(value || '—')}`;
+    return wrapText(expandMarkdownLinks(text), width)
+      .map(line => `${C.white}${formatTerminalMarkdown(line)}${C.reset}`);
+  };
+
+  printSolidPanel({
+    title: `Details • Q${details.number}`,
+    lines: safeLines('Question', details.prompt),
+  });
+
+  const thinking = String(details.thinking || '').trim();
+  printSolidPanel({
+    title: `Thinking • Q${details.number}`,
+    lines: thinking
+      ? thinking.split('\n').flatMap(line => wrapText(cleanThinkingLine(line), width)).map(line => `${C.dim}${C.slate}${line}${C.reset}`)
+      : [`${C.dim}${C.slate}No thinking trace was recorded.${C.reset}`],
+  });
+
+  if (!details.tools.length) {
+    printSolidPanel({
+      title: `Tools • Q${details.number}`,
+      lines: [`${C.dim}${C.slate}No tools were used.${C.reset}`],
+    });
+    return;
+  }
+
+  for (const [index, tool] of details.tools.entries()) {
+    const args = JSON.stringify(tool.args ?? {}, null, 2);
+    const serializedResult = JSON.stringify(tool.result ?? {}, null, 2);
+    const result = serializedResult.length > 6000
+      ? serializedResult.slice(0, 6000) + '\n… result truncated'
+      : serializedResult;
+    const lines = [
+      ...safeLines('Duration', tool.duration == null ? 'n/a' : `${(tool.duration / 1000).toFixed(2)}s`),
+      ...safeLines('Arguments', args),
+      ...safeLines('Result', result),
+    ];
+    printSolidPanel({ title: `Tool ${index + 1} • ${tool.name} • Q${details.number}`, lines });
+  }
+}
+
+function printHelp(specificCmd = null) {
+  if (specificCmd) {
+    const definition = findCommandDefinition(specificCmd);
+    if (!definition) {
+      console.log(`\n  ${C.amber}Unknown command: ${specificCmd}${C.reset}`);
+      console.log(`  ${C.dim}Type /help to see all commands.${C.reset}\n`);
+      return;
+    }
+    printSolidPanel({
+      title: `${UI_ICONS.help} ${definition.name}`,
+      lines: [`${C.white}${definition.desc}${C.reset}`, `${C.dim}Usage: ${definition.usage}${C.reset}`],
+    });
+    return;
+  }
+
+  printSolidPanel({
+    title: `${UI_ICONS.help} Kiku AI Agent — ${COMMAND_DEFINITIONS.length} Commands`,
+    lines: [
+      ...COMMAND_DEFINITIONS.map(command => `${C.emerald}${command.usage.padEnd(30)}${C.reset} ${C.white}${command.desc}${C.reset}`),
+      `${C.dim}Tip: Press Tab for auto-completion.${C.reset}`,
+    ],
+  });
+}
+
+const ads = [
+  {
+    title: 'DashSecurity', subtitle: 'Cybersecurity Knowledge Cloud',
+    url: 'https://dashsecurity.kpltgroup.com/',
+    features: ['AI-Powered SAST Scanner', 'OWASP Top 10 Detection', 'Certification Prep Labs'],
+  },
+  {
+    title: 'Ju Jingyi Kikuuu', subtitle: 'Official Portfolio',
+    url: 'https://jujingyi-kikuuu.vercel.app/',
+    features: ['45+ Music Releases', 'Complete Filmography', 'REST API v1'],
+  },
+  {
+    title: 'ThemeHackers', subtitle: 'Security Research',
+    url: 'https://github.com/Themehackers/',
+    features: ['Penetration Testing', 'Open-Source Tools', '10+ Certifications'],
+  },
+];
+
+let adIndex = 0;
+function printAd() {
+  const ad = ads[adIndex % ads.length];
+  adIndex++;
+  const w = getFullWidth();
+  console.log('');
+  printSolidBannerRow(`  ${C.gold}${C.bold}${UI_ICONS.sponsor} SPONSOR${C.reset}  ${C.bold}${C.white}${ad.title}${C.reset} — ${C.roseGlow}${ad.subtitle}${C.reset}`, w, C.bgPanelHeader);
+  printSolidBannerRow(`   ${ad.features.map(f => `${C.white}${f}${C.reset}`).join(' • ')}`, w, C.bgPanel);
+  printSolidBannerRow(`   ${C.cyberCyan}${C.underline}${ad.url}${C.reset}`, w, C.bgPanel);
+  console.log('');
+}
+
+class InteractiveTuiPrompt {
+  constructor(options = {}) {
+    this.promptText = options.prompt || 'Kiku ❯ ';
+    this.agent = options.agent || null;
+    this.history = [];
+    this.historyIndex = -1;
+    this.line = '';
+    this.cursor = 0;
+    this.popoverIndex = 0;
+    this.popoverActive = false;
+    this.popoverItems = [];
+    this.ghostText = '';
+    this.lastRenderedLines = 0;
+    this.hasTopPadding = false;
+    this.isResolving = false;
+    this.activeResolve = null;
+    this.activeReject = null;
+    this.onSigInt = options.onSigInt || null;
+    this._keyHandler = null;
+    this._renderTimer = null;
+    this.agentState = '';
+    this.agentStateTime = 0;
+    this._lastCtrlCTime = 0;
+  }
+
+  _scheduleRender() {
+    if (this._renderTimer) return;
+    this._renderTimer = setTimeout(() => {
+      this._renderTimer = null;
+      try { this.render(); } catch (error) { this.fail(error); }
+    }, 0);
+  }
+
+  _cleanupInput() {
+    if (this._renderTimer) { clearTimeout(this._renderTimer); this._renderTimer = null; }
+    if (this._keyHandler) { input.removeListener('keypress', this._keyHandler); this._keyHandler = null; }
+    try { if (input.isTTY) input.setRawMode(false); } catch {}
+  }
+
+  async readLine() {
+    return new Promise((resolve, reject) => {
+      this._cleanupInput();
+      try { this.clearPrompt(); } catch {}
+      this.line = '';
+      this.cursor = 0;
+      this.historyIndex = -1;
+      this.popoverIndex = 0;
+      this.popoverActive = false;
+      this.popoverItems = [];
+      this.ghostText = '';
+      this.lastRenderedLines = 0;
+      this.hasTopPadding = false;
+      this.isResolving = false;
+      this.activeResolve = resolve;
+      this.activeReject = reject;
+
+      try {
+        this.updateState();
+        readline.emitKeypressEvents(input);
+        if (input.isTTY) input.setRawMode(true);
+        this._keyHandler = (str, key) => {
+          try { this.handleKeypress(str, key); } catch (error) { this.fail(error); }
+        };
+        input.on('keypress', this._keyHandler);
+        this.render();
+      } catch (error) {
+        this.fail(error);
+      }
+    });
+  }
+
+  finish(result) {
+    if (this.isResolving) return;
+    this.isResolving = true;
+    try { this.clearPrompt(); } catch {}
+    this._cleanupInput();
+    this.line = '';
+    this.cursor = 0;
+    if (result && result.trim()) this.history.push(result);
+    const resolve = this.activeResolve;
+    this.activeResolve = null;
+    this.activeReject = null;
+    if (resolve) resolve(result);
+  }
+
+  fail(error) {
+    if (this.isResolving) return;
+    this.isResolving = true;
+    try { this.clearPrompt(); } catch {}
+    this._cleanupInput();
+    const reject = this.activeReject;
+    this.activeResolve = null;
+    this.activeReject = null;
+    if (reject) reject(error);
+  }
+
+  dispose() {
+    this._cleanupInput();
+    this.activeResolve = null;
+    this.activeReject = null;
+    this.isResolving = true;
+  }
+
+  clearPrompt() {
+    this.clearPopover();
+    rawWrite('\r\x1b[2K');
+    if (this.hasTopPadding) {
+      rawWrite('\x1b[1A\r\x1b[2K');
+      this.hasTopPadding = false;
+    }
+  }
+
+  clearPopover() {
+    if (this.lastRenderedLines > 0) {
+      let clearStr = '';
+      for (let i = 0; i < this.lastRenderedLines; i++) clearStr += '\x1b[1B\r\x1b[2K';
+      clearStr += `\x1b[${this.lastRenderedLines}A\r`;
+      rawWrite(clearStr);
+      this.lastRenderedLines = 0;
+    }
+  }
+
+  updateState() {
+    if (this.line.startsWith('/')) {
+      const items = getSuggestionsForLine(this.line);
+      this.popoverItems = items;
+      this.popoverActive = items.length > 0;
+      if (this.popoverIndex >= items.length) this.popoverIndex = Math.max(0, items.length - 1);
+
+      if (items.length > 0 && this.cursor === this.line.length) {
+        const topItem = items[this.popoverIndex] || items[0];
+        const targetStr = topItem.insert || topItem.name;
+        if (targetStr.toLowerCase().startsWith(this.line.toLowerCase()) && targetStr.length > this.line.length) {
+          this.ghostText = targetStr.slice(this.line.length);
+        } else { this.ghostText = ''; }
+      } else { this.ghostText = ''; }
+    } else {
+      this.popoverActive = false;
+      this.popoverItems = [];
+      this.popoverIndex = 0;
+      this.ghostText = '';
+    }
+  }
+
+  render() {
+    this.clearPopover();
+    const termCols = Math.max(10, process.stdout.columns || 80);
+    const inputRowWidth = Math.max(1, termCols - 1);
+
+    const musicStatus = audioPlayer.getStatus();
+    let statusStyled = '';
+    if (isProcessing) {
+      const frame = spinnerFrames[Math.floor(Date.now() / 70) % spinnerFrames.length];
+      const stateLabel = stripAnsi(this.agentState || 'Processing...');
+      const elapsed = this.agentState
+        ? ` ${((Date.now() - (this.agentStateTime || Date.now())) / 1000).toFixed(1)}s`
+        : '';
+      const queueLabel = queryQueue.length > 0 ? `  Queue: ${queryQueue.length}` : '';
+      const activeLabel = activeQueryNumber == null ? '' : `${C.bold}Q${activeQueryNumber}${C.reset}${C.cyberCyan} • `;
+      statusStyled = `${C.cyberCyan}${frame} ${activeLabel}${stateLabel}${elapsed}${C.reset}${C.slate}${queueLabel}${C.reset}`;
+    } else if (musicStatus) {
+      statusStyled = `${C.cyberCyan}${musicStatus}${C.reset}`;
+    }
+
+    if (this.hasTopPadding) rawWrite('\x1b[1A\r\x1b[2K');
+    const statusBackground = isProcessing ? C.bgPanelHeader : C.bgPanel;
+    const statusLine = fitStyledText(statusStyled ? `  ${statusStyled}` : '', inputRowWidth);
+    const themedStatus = statusLine.replace(/\x1b\[0m/g, C.reset + statusBackground + C.white);
+    const statusPadding = Math.max(0, inputRowWidth - getStringDisplayWidth(statusLine));
+    rawWrite(`${statusBackground}${C.white}${themedStatus}${' '.repeat(statusPadding)}${C.reset}\n\r\x1b[2K`);
+    this.hasTopPadding = true;
+
+    let promptStyled = `${C.bold}${C.sakura}${this.promptText}${C.reset}`;
+    let currentPrompt = this.promptText;
+
+    if (getStringDisplayWidth(currentPrompt) >= termCols - 2) {
+      currentPrompt = this.promptText;
+      promptStyled = `${C.bold}${C.sakura}${this.promptText}${C.reset}`;
+    }
+    const promptVisualWidth = getStringDisplayWidth(currentPrompt);
+    const maxLineWidth = Math.max(1, termCols - promptVisualWidth - 1);
+
+    const lineVisualWidth = getStringDisplayWidth(this.line);
+    const { displayLine, cursorVisualOffset } = sliceLineForDisplay(this.line, this.cursor, maxLineWidth);
+
+    let trailingStyled = '';
+    let trailingVisualWidth = 0;
+    if (this.ghostText && this.cursor === this.line.length && lineVisualWidth <= maxLineWidth) {
+      const remainingWidth = Math.max(0, maxLineWidth - lineVisualWidth);
+      const ghostDisplay = remainingWidth > 0
+        ? sliceLineForDisplay(this.ghostText, 0, remainingWidth).displayLine.replace(/…$/, '')
+        : '';
+      if (ghostDisplay) {
+        trailingStyled = `${C.dim}${C.slate}${ghostDisplay}${C.reset}`;
+        trailingVisualWidth = getStringDisplayWidth(ghostDisplay);
+      }
+    } else if (!this.line) {
+      const placeholder = sliceLineForDisplay(INPUT_PLACEHOLDER, 0, maxLineWidth).displayLine;
+      trailingStyled = `${C.dim}${C.slate}${placeholder}${C.reset}`;
+      trailingVisualWidth = getStringDisplayWidth(placeholder);
+    }
+
+    const rowStyled = `${promptStyled}${C.white}${displayLine}${trailingStyled}`
+      .replace(/\x1b\[0m/g, C.reset + C.bgPanel + C.white);
+    const rowVisualWidth = promptVisualWidth + getStringDisplayWidth(displayLine) + trailingVisualWidth;
+    const rowPadding = Math.max(0, inputRowWidth - rowVisualWidth);
+    rawWrite(`${C.bgPanel}${rowStyled}${' '.repeat(rowPadding)}${C.reset}`);
+
+    rawWrite(`\n\r\x1b[2K${C.bgPanel}${' '.repeat(inputRowWidth)}${C.reset}`);
+    let renderedLinesBelow = 1;
+
+    if (this.popoverActive && this.popoverItems.length > 0) {
+      const maxItems = 5;
+      const startIdx = Math.max(0, Math.min(this.popoverIndex - 2, this.popoverItems.length - maxItems));
+      const visibleItems = this.popoverItems.slice(startIdx, startIdx + maxItems);
+      const boxWidth = Math.max(1, termCols - 1);
+      const writeSurfaceRow = (styledText) => {
+        const fitted = fitStyledText(styledText, boxWidth);
+        const pad = Math.max(0, boxWidth - getStringDisplayWidth(fitted));
+        const themed = fitted.replace(/\x1b\[0m/g, C.reset + C.bgPanel + C.white);
+        rawWrite(`\n\r\x1b[2K${C.bgPanel}${C.white}${themed}${' '.repeat(pad)}${C.reset}`);
+      };
+
+      writeSurfaceRow(`  ${C.bold}${C.roseGlow}Suggestions${C.reset} ${C.slate}— ↑/↓ navigate, Tab/Enter select, Esc close${C.reset}`);
+
+      for (let i = 0; i < visibleItems.length; i++) {
+        const actualIdx = startIdx + i;
+        const item = visibleItems[i];
+        const isSelected = actualIdx === this.popoverIndex;
+        const pointer = isSelected ? '❯' : ' ';
+        const pointerColor = isSelected ? C.gold : C.darkGray;
+        const nameColor = isSelected ? `${C.bold}${C.white}` : C.cyberCyan;
+        writeSurfaceRow(` ${pointerColor}${pointer}${C.reset} ${nameColor}${item.name.padEnd(22)}${C.reset} ${C.slate}${stripAnsi(item.desc)}${C.reset}`);
+      }
+      renderedLinesBelow += visibleItems.length + 1;
+    }
+
+    this.lastRenderedLines = renderedLinesBelow;
+    rawWrite(`\x1b[${this.lastRenderedLines}A\r`);
+
+    const cursorColumn = promptVisualWidth + cursorVisualOffset;
+    rawWrite(`\r${cursorColumn > 0 ? `\x1b[${cursorColumn}C` : ''}`);
+  }
+
+  handleKeypress(str, key) {
+    if (!key) return;
+
+    if (key.ctrl && key.name === 'c') {
+      if (this.line.length > 0) { this.line = ''; this.cursor = 0; this.updateState(); this.render(); return; }
+      if (isProcessing) { if (this.onSigInt) this.onSigInt(); return; }
+      const now = Date.now();
+      if (!this._lastCtrlCTime || now - this._lastCtrlCTime > 2000) {
+        this._lastCtrlCTime = now;
+        rawWrite(`\n  ${C.dim}(Press Ctrl+C again or type /exit to quit)${C.reset}\n`);
+        this.render(); return;
+      }
+      if (this.onSigInt) this.onSigInt(); else process.exit(0);
+      return;
+    }
+
+    if (key.ctrl && key.name === 'l') { console.clear(); printWelcomeHero(); this.updateState(); this.render(); return; }
+    if (key.name === 'escape') { if (this.popoverActive) { this.popoverActive = false; this.popoverItems = []; this.ghostText = ''; this.render(); } return; }
+    if (key.name === 'f2') { this.finish('/details'); return; }
+
+    if (key.name === 'tab') {
+      if (this.popoverActive && this.popoverItems.length > 0) {
+        const item = this.popoverItems[this.popoverIndex];
+        if (item) { this.line = item.insert || item.name; this.cursor = this.line.length; this.updateState(); this.render(); return; }
+      } else if (this.ghostText) {
+        this.line += this.ghostText; this.cursor = this.line.length; this.updateState(); this.render(); return;
+      }
+      return;
+    }
+
+    if (key.name === 'return' || key.name === 'enter') {
+      if (this.popoverActive && this.popoverItems.length > 0) {
+        const item = this.popoverItems[this.popoverIndex];
+        if (item) {
+          const insertVal = item.insert || item.name;
+          if (insertVal.endsWith(' ')) { this.line = insertVal; this.cursor = this.line.length; this.updateState(); this.render(); return; }
+          this.line = insertVal; this.finish(this.line); return;
+        }
+      }
+      this.finish(this.line); return;
+    }
+
+    if (key.name === 'up') {
+      if (this.popoverActive && this.popoverItems.length > 0) {
+        this.popoverIndex = (this.popoverIndex - 1 + this.popoverItems.length) % this.popoverItems.length;
+        this.updateState(); this.render(); return;
+      }
+      if (this.history.length > 0) {
+        if (this.historyIndex === -1) this.historyIndex = this.history.length - 1;
+        else if (this.historyIndex > 0) this.historyIndex--;
+        this.line = this.history[this.historyIndex] || ''; this.cursor = this.line.length;
+        this.updateState(); this.render();
+      }
+      return;
+    }
+
+    if (key.name === 'down') {
+      if (this.popoverActive && this.popoverItems.length > 0) {
+        this.popoverIndex = (this.popoverIndex + 1) % this.popoverItems.length;
+        this.updateState(); this.render(); return;
+      }
+      if (this.history.length > 0 && this.historyIndex !== -1) {
+        if (this.historyIndex < this.history.length - 1) { this.historyIndex++; this.line = this.history[this.historyIndex] || ''; }
+        else { this.historyIndex = -1; this.line = ''; }
+        this.cursor = this.line.length; this.updateState(); this.render();
+      }
+      return;
+    }
+
+    if (key.name === 'right') { if (this.cursor < this.line.length) { this.cursor = nextGraphemeBoundary(this.line, this.cursor); this.render(); } return; }
+    if (key.name === 'left') { if (this.cursor > 0) { this.cursor = previousGraphemeBoundary(this.line, this.cursor); this.render(); } return; }
+    if (key.name === 'home' || (key.ctrl && key.name === 'a')) { this.cursor = 0; this.render(); return; }
+    if (key.name === 'end' || (key.ctrl && key.name === 'e')) { this.cursor = this.line.length; this.render(); return; }
+
+    if (key.name === 'backspace') { if (this.cursor > 0) { const previous = previousGraphemeBoundary(this.line, this.cursor); this.line = this.line.slice(0, previous) + this.line.slice(this.cursor); this.cursor = previous; this.updateState(); this.render(); } return; }
+    if (key.name === 'delete') { if (this.cursor < this.line.length) { const next = nextGraphemeBoundary(this.line, this.cursor); this.line = this.line.slice(0, this.cursor) + this.line.slice(next); this.updateState(); this.render(); } return; }
+
+    if (str && !key.ctrl && !key.meta) {
+      if (str.startsWith('\x1b') || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(str)) return;
+      this.line = this.line.slice(0, this.cursor) + str + this.line.slice(this.cursor);
+      this.cursor += str.length;
+      this.updateState(); this.render();
+    }
+  }
+}
+
+function getSuggestionsForLine(line) {
+  const trimmed = line.trimStart();
+  if (!trimmed.startsWith('/')) return [];
+  const parts = trimmed.split(/\s+/);
+  const baseCmd = parts[0].toLowerCase();
+  const allCmds = COMMAND_DEFINITIONS;
+
+  if (baseCmd === '/tool' && (parts.length > 1 || line.includes(' '))) {
+    const q = parts.slice(1).join(' ').toLowerCase();
+    if (!q) return toolsSchema.map(t => ({ name: `/tool ${t.function.name}`, desc: t.function.description.slice(0, 50), insert: `/tool ${t.function.name} ` }));
+    return toolsSchema
+      .filter(t => t.function.name.toLowerCase().includes(q))
+      .slice(0, 8)
+      .map(t => ({ name: `/tool ${t.function.name}`, desc: t.function.description.slice(0, 50), insert: `/tool ${t.function.name} ` }));
+  }
+
+  if (parts.length > 1 || (parts.length === 1 && line.includes(' '))) {
+    const subs = SUB_COMMANDS[baseCmd] || [];
+    const query = parts.slice(1).join(' ').toLowerCase();
+    return subs
+      .filter(s => s.toLowerCase().includes(query))
+      .map(s => ({ name: `${baseCmd} ${s}`, desc: '', insert: `${baseCmd} ${s} ` }));
+  }
+
+  return allCmds
+    .map(c => ({ ...c, score: c.name === baseCmd ? 200 : c.name.startsWith(baseCmd) ? 100 : c.name.includes(baseCmd) ? 70 : 0 }))
+    .filter(c => c.score > 0)
+    .sort((a, b) => b.score - a.score);
+}
+
+async function executeQueryWithUI(agent, prompt, isThinkingVisible = false, signal = null, queryNumber = null) {
+  let spinnerInterval = null;
+  let hasPrintedResponseHeader = false;
+  let responsePanelStarted = false;
+  let toolSectionStarted = false;
+  let responseLineBuffer = '';
+  let pendingTableHeader = null;
+  let activeTableHeaders = null;
+  let tableRowNumber = 0;
+  const boxWidth = getFullWidth();
+  const bg = '\x1b[48;2;34;37;48m';
+  const bgHeader = '\x1b[48;2;48;52;68m';
+  const colorizeResponseText = (formatted) => (
+    `${C.white}${formatted.replace(/\x1b\[0m/g, C.reset + C.white)}${C.reset}`
+  );
+  const queryTag = queryNumber == null ? '' : `Q${queryNumber}`;
+  const answerTitle = queryTag
+    ? `Answer • ${queryTag} — ${prompt.length > 52 ? prompt.slice(0, 52) + '…' : prompt}`
+    : 'Answer';
+
+  const ensureResponsePanel = () => {
+    if (responsePanelStarted) return;
+    console.log('');
+    printSolidBannerRow(`  ${C.bold}${C.roseGlow}${answerTitle}${C.reset}`, boxWidth, C.bgPanelHeader);
+    responsePanelStarted = true;
+  };
+
+  const printPlainResponseLine = (line) => {
+    ensureResponsePanel();
+    const wrapSafeLine = expandMarkdownLinks(line);
+    const formatted = formatTerminalMarkdown(wrapSafeLine);
+    const maxWidth = getFullWidth() - 4;
+    const visualLen = getStringDisplayWidth(formatted);
+    if (visualLen > maxWidth) {
+      for (const wl of wrapText(wrapSafeLine, maxWidth)) {
+        printSolidBannerRow(`  ${colorizeResponseText(formatTerminalMarkdown(wl))}`, boxWidth, C.bgPanel);
+      }
+    } else {
+      printSolidBannerRow(`  ${colorizeResponseText(formatted)}`, boxWidth, C.bgPanel);
+    }
+  };
+
+  const printTableRecord = (cells) => {
+    ensureResponsePanel();
+    tableRowNumber++;
+    printSolidBannerRow(`  ${C.bold}${C.cyberCyan}Item ${tableRowNumber}${C.reset}`, boxWidth, C.bgPanelHeader);
+
+    const maxWidth = Math.max(16, getFullWidth() - 8);
+    for (let index = 0; index < activeTableHeaders.length; index++) {
+      const header = activeTableHeaders[index] || `Column ${index + 1}`;
+      const value = expandMarkdownLinks(cells[index] || '—');
+      const prefix = `${header}: `;
+      const wrapped = wrapText(prefix + value, maxWidth);
+      for (const line of wrapped) {
+        printSolidBannerRow(`    ${colorizeResponseText(formatTerminalMarkdown(line))}`, boxWidth, C.bgPanel);
+      }
+    }
+  };
+
+  const flushPendingTableHeader = () => {
+    if (!pendingTableHeader) return;
+    printPlainResponseLine(`| ${pendingTableHeader.join(' | ')} |`);
+    pendingTableHeader = null;
+  };
+
+  const printResponseLine = (line) => {
+    const cells = parseMarkdownTableRow(line);
+
+    if (pendingTableHeader) {
+      if (cells && cells.length === pendingTableHeader.length && isMarkdownTableSeparator(cells)) {
+        activeTableHeaders = pendingTableHeader;
+        pendingTableHeader = null;
+        tableRowNumber = 0;
+        return;
+      }
+      flushPendingTableHeader();
+    }
+
+    if (activeTableHeaders) {
+      if (cells && cells.length === activeTableHeaders.length && !isMarkdownTableSeparator(cells)) {
+        printTableRecord(cells);
+        return;
+      }
+      activeTableHeaders = null;
+      tableRowNumber = 0;
+    }
+
+    if (cells && !isMarkdownTableSeparator(cells)) {
+      pendingTableHeader = cells;
+      return;
+    }
+
+    printPlainResponseLine(line);
+  };
+
+  const flushResponseBuffer = (isFinal = false) => {
+    if (responseLineBuffer.length > 0) {
+      if (isFinal) {
+        for (const line of responseLineBuffer.split('\n')) { if (line.length > 0) printResponseLine(line); }
+        responseLineBuffer = '';
+      } else if (responseLineBuffer.includes('\n')) {
+        const lines = responseLineBuffer.split('\n');
+        responseLineBuffer = lines.pop();
+        for (const line of lines) printResponseLine(line);
+      }
+    }
+    if (isFinal) flushPendingTableHeader();
+  };
+
+  const startSpinner = (label) => {
+    if (globalTuiPrompt) { globalTuiPrompt.agentState = label; globalTuiPrompt.agentStateTime = Date.now(); }
+    if (!spinnerInterval) {
+      spinnerInterval = setInterval(() => { if (globalTuiPrompt && isProcessing) globalTuiPrompt.render(); }, 80);
+    }
+  };
+
+  const stopSpinner = () => {
+    if (spinnerInterval) { clearInterval(spinnerInterval); spinnerInterval = null; }
+    if (globalTuiPrompt) { globalTuiPrompt.agentState = ''; globalTuiPrompt.render(); }
+  };
+
+  let thinkingShown = false;
+  let thinkingBuffer = '';
+  let thinkingStartTime = 0;
+  let accumulatedThinking = '';
+  let recordedTools = [];
+  let currentToolArgs = {};
+
+  startSpinner(`${C.slate}Thinking…${C.reset}`);
+
+  try {
+    await agent.ask(prompt, {
+      signal,
+      onStepStart: () => {},
+      onReasoningStart: () => {
+        stopSpinner();
+        thinkingStartTime = Date.now();
+        thinkingBuffer = '';
+        if (!thinkingShown) {
+          console.log('');
+          const icon = thinkingFrames[Math.floor(Date.now() / 200) % thinkingFrames.length];
+          printSolidBannerRow(`  ${C.lavender}${C.bold}${icon}  Thinking${queryTag ? ` • ${queryTag}` : ''}${C.reset}`, boxWidth, bgHeader);
+        }
+      },
+      onReasoningDelta: (chunk) => {
+        accumulatedThinking += chunk;
+        thinkingBuffer += chunk;
+        if (!thinkingShown) {
+          const lines = thinkingBuffer.split('\n');
+          thinkingBuffer = lines.pop();
+          for (const line of lines) {
+            if (line.trim()) {
+              for (const w of wrapText(cleanThinkingLine(line), boxWidth - 6)) {
+                printSolidBannerRow(`   ${C.dim}${C.slate}${w}${C.reset}`, boxWidth, bg);
+              }
+            }
+          }
+        }
+      },
+      onReasoningEnd: () => {
+        const elapsed = ((Date.now() - thinkingStartTime) / 1000).toFixed(1);
+        if (!thinkingShown) {
+          if (thinkingBuffer.trim()) {
+            for (const w of wrapText(cleanThinkingLine(thinkingBuffer), boxWidth - 6)) {
+              printSolidBannerRow(`   ${C.dim}${C.slate}${w}${C.reset}`, boxWidth, bg);
+            }
+          }
+          printSolidBannerRow(`   ${C.emerald}[DONE] Thought for ${elapsed}s${C.reset}`, boxWidth, bg);
+          console.log('');
+        } else {
+          stopSpinner();
+          const detailHint = queryTag ? ` — F2 or /details ${queryTag}` : '';
+          console.log(`\n  ${C.dim}${C.slate}Thinking${queryTag ? ` • ${queryTag}` : ''} (${elapsed}s)${detailHint}${C.reset}`);
+        }
+        thinkingShown = true;
+      },
+
+      onToolStart: (toolName, args) => {
+        stopSpinner();
+        if (!toolSectionStarted) {
+          console.log('');
+          const detailHint = queryTag ? `  ${C.dim}Details: F2 or /details ${queryTag}${C.reset}` : '';
+          printSolidBannerRow(`  ${C.bold}${C.cyberCyan}Tools${queryTag ? ` • ${queryTag}` : ''}${C.reset}${detailHint}`, boxWidth, C.bgPanelHeader);
+          toolSectionStarted = true;
+        }
+        currentToolArgs = args || {};
+        const queryVal = args?.query || args?.url || Object.values(args || {})[0] || '';
+        const displayQuery = typeof queryVal === 'string' && queryVal.length > 30 ? queryVal.slice(0, 30) + '…' : queryVal;
+        startSpinner(`${C.cyberCyan}• ${C.bold}${C.white}${toolName}${C.reset}${displayQuery ? ` ${C.slate}"${displayQuery}"${C.reset}` : ''}`);
+      },
+
+      onToolResult: (toolName, result, durationMs) => {
+        stopSpinner();
+        recordedTools.push({ name: toolName, args: currentToolArgs, result, duration: durationMs });
+
+        const count = result.count ?? result.returnedCount;
+        const isError = result.status === 'error';
+        const isNotFound = result.status === 'not_found' || count === 0;
+        const statusLabel = isError
+          ? `${C.red}[ERROR]`
+          : isNotFound
+            ? `${C.amber}[NOT FOUND]`
+            : `${C.emerald}[OK]`;
+        const countTag = count != null && !isError ? ` • ${C.cyberCyan}${count} results${C.reset}` : '';
+        const timerTag = durationMs !== undefined ? ` • ${C.dim}${(durationMs / 1000).toFixed(2)}s${C.reset}` : '';
+
+        printSolidBannerRow(`  ${C.slate}• ${C.bold}${C.cyberCyan}${toolName}${C.reset} ${statusLabel} ${(isError ? C.red + 'Failed' : isNotFound ? C.amber + 'No matching data' : C.white + 'OK') + C.reset}${countTag}${timerTag}`, boxWidth, C.bgPanel);
+
+        if (!isError && !isNotFound) {
+          const preview = extractPreview(result, toolName);
+          if (preview) {
+            for (const pLine of wrapText('• ' + preview, boxWidth - 6)) {
+              printSolidBannerRow(`   ${C.dim}${C.slate}${pLine}${C.reset}`, boxWidth, bg);
+            }
+          }
+        }
+      },
+
+      onTokenStart: () => { stopSpinner(); },
+
+      onTokenDelta: (token) => {
+        if (!hasPrintedResponseHeader) { stopSpinner(); hasPrintedResponseHeader = true; }
+        responseLineBuffer += token;
+        flushResponseBuffer(false);
+      },
+
+      onFinalAnswer: (answer) => {
+        stopSpinner();
+        if (!hasPrintedResponseHeader) {
+          for (const line of (answer || '').split('\n')) { if (line.length > 0) printResponseLine(line); }
+          flushPendingTableHeader();
+        } else {
+          flushResponseBuffer(true);
+        }
+      },
+
+      onError: (err) => {
+        stopSpinner();
+        console.log(`\n  ${C.red}[ERROR] ${err.message}${C.reset}\n`);
+      },
+    });
+
+    lastQueryDetails = { number: queryNumber, prompt, thinking: accumulatedThinking, tools: recordedTools, timestamp: Date.now() };
+    if (queryNumber != null) {
+      queryDetails.set(queryNumber, lastQueryDetails);
+      if (queryDetails.size > 50) queryDetails.delete(queryDetails.keys().next().value);
+    }
+    if (responsePanelStarted) console.log('');
+  } catch (err) {
+    stopSpinner();
+    if (!isAbortError(err)) {
+      console.log(`\n  ${C.red}[ERROR] ${err.message}${C.reset}\n`);
+    } else {
+      console.log(`\n  ${C.amber}[INTERRUPTED] Query cancelled.${C.reset}\n`);
+    }
+  }
+}
+
+async function main() {
+  try { process.stdout.write('\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1005l\x1b[?1006l\x1b[?1015l'); } catch {}
+
+  const opts = parseCliArgs();
+
+  if (opts.help) { printWelcomeHero(); printHelp(); process.exit(0); }
+  if (opts.showTools) {
+    printWelcomeHero();
+    console.log(`\n  ${C.bold}${C.sakura}Tools (${toolsSchema.length})${C.reset}\n`);
+    for (const [i, t] of toolsSchema.entries()) {
+      console.log(`  ${C.gold}${String(i + 1).padStart(2)}${C.reset} ${C.cyberCyan}${t.function.name}${C.reset} — ${C.dim}${t.function.description.slice(0, 60)}${C.reset}`);
+    }
+    console.log('');
+    process.exit(0);
+  }
+
+  if (opts.showStats) { printWelcomeHero(); const r = await executeTool('get_system_stats', {}); console.log(JSON.stringify(r, null, 2)); process.exit(0); }
+
+  const baseUrl = opts.url || config.lmStudio.baseUrl;
+  const client = new LMStudioClient({ baseUrl, model: opts.model });
+  const health = await client.checkConnection();
+
+  printWelcomeHero();
+
+  if (!health.connected) {
+    console.log(`  ${C.amber}!! LM Studio offline${C.reset}`);
+    console.log(`  ${C.dim}• ${health.error}${C.reset}\n`);
+    console.log(`  ${C.bold}${C.sakura}Attempting auto-start...${C.reset}`);
+
+    const autoHealth = await attemptAutoStartLMStudio(baseUrl, opts.model || config.lmStudio.model);
+    if (autoHealth) {
+      console.log(`  ${C.emerald}[OK] LM Studio started.${C.reset}\n`);
+    } else {
+      console.log(`  ${C.sakura}Setup: Open LM Studio → load google/gemma-4-e4b → Start Server :1234${C.reset}\n`);
+      if (opts.query) {
+        const directResult = await executeTool('global_search', { query: opts.query });
+        console.log(JSON.stringify(directResult, null, 2));
+        process.exit(0);
+      }
+      process.exit(1);
+    }
+  }
+
+  const agent = new KikuAgent({ baseUrl, model: health.activeModel || opts.model, thinkingMode: opts.thinking });
+
+  if (opts.query) {
+    console.log(`  ${C.bold}${C.gold}QUERY${C.reset} ${C.white}${opts.query}${C.reset}\n`);
+    await executeQueryWithUI(agent, opts.query, agent.session.thinkingMode === 'show', null, 1);
+    process.exit(0);
+  }
+
+  await agent._ready;
+
+  if (agent.restoredMessageCount > 0) {
+    const s = agent.session;
+    console.log(`\n  ${C.sakura}${C.bold}[SESSION RESTORED]${C.reset} ${C.dim}${s.id} — ${s.messages.length} messages${C.reset}\n`);
+  }
+
+  const tuiPrompt = new InteractiveTuiPrompt({
+    prompt: 'Kiku ❯ ',
+    agent,
+    onSigInt: async () => {
+      if (activeAbortController) {
+        activeAbortController.abort();
+        activeAbortController = null;
+        queryQueue.length = 0;
+        deferredCommands.length = 0;
+      } else {
+        try { await agent.endSession(); } catch {}
+        globalTuiPrompt?.dispose();
+        console.log(`\n  ${C.sakura}Goodbye. (鞠躬 ~ 谢谢!)${C.reset}\n`);
+        process.exit(0);
+      }
+    }
+  });
+
+  globalTuiPrompt = tuiPrompt;
+
+  setupOutputInterception(tuiPrompt, () => isProcessing);
+
+  agent.stateMachine.on('enter:' + AgentStates.FETCHING_TOOL, ({ toolName }) => {
+    if (globalTuiPrompt) {
+      globalTuiPrompt.agentState = `Tool: ${toolName}`;
+      globalTuiPrompt.agentStateTime = Date.now();
+    }
+  });
+
+  agent.stateMachine.on('enter:' + AgentStates.STREAMING_THOUGHTS, () => {
+    if (globalTuiPrompt) {
+      globalTuiPrompt.agentState = 'Thinking…';
+      globalTuiPrompt.agentStateTime = Date.now();
+    }
+  });
+
+  agent.stateMachine.on('enter:' + AgentStates.STREAMING_ANSWER, () => {
+    if (globalTuiPrompt) {
+      globalTuiPrompt.agentState = 'Streaming…';
+      globalTuiPrompt.agentStateTime = Date.now();
+    }
+  });
+
+  agent.stateMachine.on('enter:' + AgentStates.IDLE, () => {
+    if (globalTuiPrompt) {
+      globalTuiPrompt.agentState = '';
+    }
+  });
+
+  async function processNextQueueItem() {
+    if (isProcessing || queryQueue.length === 0) return;
+
+    isProcessing = true;
+    const nextItem = queryQueue.shift();
+    lastQuery = nextItem.prompt;
+    activeQueryNumber = nextItem.number;
+
+    tuiPrompt.clearPrompt();
+    tuiPrompt.render();
+
+    console.log('');
+    activeAbortController = new AbortController();
+    try {
+      await executeQueryWithUI(agent, nextItem.prompt, agent.session.thinkingMode === 'show', activeAbortController.signal, nextItem.number);
+    } finally {
+      activeAbortController = null;
+      queryCount++;
+      printAd();
+      console.log('');
+      isProcessing = false;
+      activeQueryNumber = null;
+      if (globalTuiPrompt) globalTuiPrompt.render();
+
+      if (queryQueue.length > 0) {
+        setTimeout(processNextQueueItem, 100);
+      } else if (deferredCommands.length > 0 && globalTuiPrompt && globalTuiPrompt.activeResolve) {
+        globalTuiPrompt.finish(' ');
+      }
+    }
+  }
+
+  while (true) {
+    let rawInput;
+
+    if (deferredCommands.length > 0 && !isProcessing) {
+      rawInput = deferredCommands.shift();
+      console.log(`\n  ${C.cyberCyan}[DEFERRED] ${rawInput}${C.reset}\n`);
+    } else {
+      rawInput = await tuiPrompt.readLine();
+    }
+
+    if (rawInput === null) break;
+    const trimmed = rawInput.trim();
+    if (!trimmed) continue;
+
+    const queryNumber = !trimmed.startsWith('/') ? nextQueryNumber++ : null;
+
+    if (!trimmed.startsWith('/')) {
+      const wrapped = wrapText(trimmed, getFullWidth() - 8);
+      const queuePosition = isProcessing ? queryQueue.length + 1 : 0;
+      const queuedLabel = queuePosition > 0 ? ` • Queued ${queuePosition}` : '';
+      printSolidPanel({
+        title: `${C.roseGlow}${C.bold}Question ${queryNumber} • ${randomFanName()}${queuedLabel}${C.reset}`,
+        lines: wrapped.map(wLine => `${C.cyberCyan}❯${C.reset} ${C.white}${wLine}${C.reset}`),
+        bg: '\x1b[48;2;36;40;52m'
+      });
+    }
+
+    if (trimmed.startsWith('/')) {
+      if (isProcessing) {
+        deferredCommands.push(trimmed);
+        console.log(`\n  ${C.cyberCyan}[DEFERRED] ${trimmed}${C.reset}\n`);
+        tuiPrompt.render();
+        continue;
+      }
+
+      const cmdCtx = {
+        agent,
+        client,
+        baseUrl,
+        sub: trimmed.split(/\s+/)[1] || '',
+        extra: trimmed.split(/\s+/).slice(2).join(' '),
+        parts: trimmed.split(/\s+/),
+        lastQuery,
+        printHelp,
+        printQueryDetails,
+        printWelcome: printWelcomeHero,
+        printAd,
+        enqueueQuery: (prompt, isRetry) => {
+          queryQueue.push({ id: 'q_' + Date.now(), number: nextQueryNumber++, prompt, addedAt: Date.now() });
+          if (!isProcessing) processNextQueueItem();
+        },
+        clearQueryQueue: () => { queryQueue.length = 0; },
+        getQueryQueueLength: () => queryQueue.length,
+      };
+
+      const result = await routeCommand(trimmed, cmdCtx);
+
+      if (result === 'EXIT') break;
+      if (result === 'RETRY' && cmdCtx.lastQuery) {
+        const retryNumber = nextQueryNumber++;
+        printSolidPanel({
+          title: `${C.roseGlow}${C.bold}Question ${retryNumber} • Retry${C.reset}`,
+          lines: wrapText(cmdCtx.lastQuery, getFullWidth() - 8)
+            .map(wLine => `${C.cyberCyan}❯${C.reset} ${C.white}${wLine}${C.reset}`),
+          bg: '\x1b[48;2;36;40;52m'
+        });
+        queryQueue.push({ id: 'q_' + Date.now(), number: retryNumber, prompt: cmdCtx.lastQuery, addedAt: Date.now() });
+        if (!isProcessing) processNextQueueItem();
+      }
+      continue;
+    }
+
+    const { sanitized, warnings } = sanitizeQuery(trimmed);
+    if (warnings.length > 0) {
+      console.log(`\n  ${C.amber}[WARNING] ${warnings.join('; ')}${C.reset}\n`);
+    }
+
+    lastQuery = trimmed;
+    queryQueue.push({ id: 'q_' + Date.now(), number: queryNumber, prompt: trimmed, addedAt: Date.now() });
+    if (isProcessing) { tuiPrompt.render(); continue; }
+    processNextQueueItem();
+  }
+}
+
+process.on('exit', () => { try { globalTuiPrompt?.dispose(); } catch {} });
+process.on('uncaughtException', (err) => {
+  try { globalTuiPrompt?.dispose(); } catch {}
+  console.error(`\n  Uncaught: ${err.message}`);
+  process.exit(1);
+});
+process.on('SIGINT', () => {
+  try { globalTuiPrompt?.dispose(); } catch {}
+  process.exit(130);
+});
+
+main().catch(err => {
+  console.error(`\n  ${C.red}Fatal: ${err.message}${C.reset}\n`);
+  process.exit(1);
+});