kiku-agent 1.0.5 → 1.0.7

package/server/agent/cli.js

@@ -1,10 +1,11 @@
-#!/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';
+#!/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 './youtubeAuth.js';
+import { KikuAgent } from './agentCore.js';
 import { LLMClient, LMStudioClient } from './llmClient.js';
 import { toolsSchema, toolHandlers, executeTool } from './tools.js';
 import { config, CLOUD_PROVIDERS } from './config.js';
@@ -14,18 +15,30 @@ 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 { COMMAND_DEFINITIONS, SUB_COMMANDS, findCommandDefinition, getCommandDetails } from './commandRegistry.js';
 import { ModelManager } from './modelManager.js';
+import { PACKAGE_VERSION } from './version.js';
+import { getTheme, getThemeName } from './theme.js';
+import {
+  classifyToolResult,
+  formatDetailDuration,
+  parseDetailsRequest,
+  serializeDetailValue,
+  summarizeQueryDetails,
+  copyToClipboard,
+  getCopyableContent,
+} from './queryDetails.js';
 
 import {
-  C, getStringDisplayWidth, getFullWidth, wrapText, stripAnsi, fitStyledText,
+  C, getStringDisplayWidth, getFullWidth, wrapText, stripAnsi, fitStyledText, sanitizeTerminalText,
   previousGraphemeBoundary, nextGraphemeBoundary, sliceLineForDisplay,
   printSolidBannerRow, printSolidPanel, formatSolidPanelLines, formatTerminalMarkdown,
   parseMarkdownTableRow, isMarkdownTableSeparator, expandMarkdownLinks,
+  formatRichCardLines, printRichCard, printRichStatusCard, formatStatusBadge, formatRichTable,
   printWelcomeHero, getWelcomeHeroLines, randomFanName, setupOutputInterception,
   rawWrite, INPUT_PLACEHOLDER, UI_ICONS,
   spinnerFrames, thinkingFrames, createProgressRunner,
-  enterAlternateScreen, exitAlternateScreen, VirtualScreenBuffer,
+  enterAlternateScreen, exitAlternateScreen, getTuiViewportLayout, VirtualScreenBuffer,
 } from './ui.js';
 
 let activeAbortController = null;
@@ -53,12 +66,14 @@ function parseCliArgs() {
     showStats: false,
     thinking: 'show',
     verbose: false,
-    help: false
+    help: false,
+    version: false
   };
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === '--help' || arg === '-h') options.help = true;
+    else if (arg === '--version' || arg === '-V') options.version = 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'; }
@@ -91,10 +106,10 @@ async function attemptAutoStartLMStudio(baseUrl, model) {
 
   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'
-      ]
+      `${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'];
@@ -107,11 +122,15 @@ async function attemptAutoStartLMStudio(baseUrl, model) {
   });
 
   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 {}
+    try { const parsedUrl = new URL(baseUrl); if (parsedUrl.port) port = parsedUrl.port; } catch { }
+    printRichCard({
+      title: 'LM Studio Auto-Start',
+      status: 'autostart',
+      lines: [`Launching local LM Studio process on port ${port}...`],
+    });
 
     const child = spawn(exe, isWin
       ? ['--model', model, '--serve', '--port', port]
@@ -125,12 +144,11 @@ async function attemptAutoStartLMStudio(baseUrl, model) {
 }
 
 function extractPreview(result, toolName) {
-  const MAX = 80;
+  if (!result || typeof result !== 'object') return '';
   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 || '';
+    raw = result.results.map(r => r.title || r.name || r.id || JSON.stringify(r)).join(', ');
   } 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(', ');
@@ -138,8 +156,7 @@ function extractPreview(result, toolName) {
   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;
+  return raw.replace(/\s+/g, ' ').trim();
 }
 
 function cleanThinkingLine(line) {
@@ -153,77 +170,263 @@ function cleanThinkingLine(line) {
 }
 
 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;
+  const request = parseDetailsRequest(reference);
+  if (request.error) {
+    printSolidPanel({
+      title: 'Query Details — Invalid Request',
+      lines: [
+        `${C.amber}${request.error}${C.reset}`,
+        '',
+        `${C.white}/details [Qn]${C.reset} ${C.dim}— overview${C.reset}`,
+        `${C.white}/details [Qn] answer${C.reset}`,
+        `${C.white}/details [Qn] thinking${C.reset}`,
+        `${C.white}/details [Qn] tools${C.reset}`,
+        `${C.white}/details [Qn] tool <n>${C.reset}`,
+        `${C.white}/details [Qn] all${C.reset}`,
+      ],
+    });
+    return;
+  }
+
+  const details = request.queryNumber == null
+    ? lastQueryDetails
+    : queryDetails.get(request.queryNumber);
 
   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`);
+    const target = request.queryNumber == null ? 'the latest query' : `Q${request.queryNumber}`;
+    console.log(`\n  ${C.amber}[NOT FOUND] No diagnostics recorded for ${target}.${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}`);
+  const safeWrappedLines = (value, color = C.white) => {
+    const inputLines = String(value || '—').split('\n');
+    return inputLines.flatMap(line => wrapText(sanitizeTerminalText(line, 500000) || ' ', width))
+      .map(line => `${color}${line}${C.reset}`);
+  };
+  const summary = summarizeQueryDetails(details);
+  const queryLabel = `Q${details.number}`;
+  const statusColor = details.status === 'complete' ? C.emerald : details.status === 'aborted' ? C.amber : C.red;
+  const statusLabel = String(details.status || 'complete').toUpperCase();
+  const startedLabel = Number.isFinite(details.startedAt)
+    ? new Date(details.startedAt).toLocaleString()
+    : 'n/a';
+
+  const toolTimelineLines = (includeArgs = false) => {
+    if (!details.tools?.length) return [`${C.dim}${C.slate}No tools were used.${C.reset}`];
+    return details.tools.flatMap((tool, index) => {
+      const resultState = classifyToolResult(tool.result);
+      const stateColor = resultState.state === 'ok' ? C.emerald : resultState.state === 'not_found' ? C.amber : C.red;
+      const countLabel = resultState.count == null ? '' : ` • ${resultState.count} results`;
+      const preview = extractPreview(tool.result || {}, tool.name);
+      const rows = [
+        `${C.slate}${String(index + 1).padStart(2)}.${C.reset} ${C.bold}${C.cyberCyan}${sanitizeTerminalText(tool.name, 128)}${C.reset} ${stateColor}[${resultState.state.toUpperCase()}]${C.reset} ${C.dim}${formatDetailDuration(tool.duration)}${countLabel}${C.reset}`,
+      ];
+      if (includeArgs) {
+        const serializedArgs = serializeDetailValue(tool.args, Infinity).text.replace(/\s+/g, ' ');
+        rows.push(...safeWrappedLines(`   Args: ${serializedArgs}`, C.slate));
+      }
+      if (preview) rows.push(...safeWrappedLines(`   Result: ${preview}`, C.slate));
+      return rows;
+    });
   };
 
-  printSolidPanel({
-    title: `Details • Q${details.number}`,
-    lines: safeLines('Question', details.prompt),
-  });
+  if (request.view === 'answer') {
+    printSolidPanel({
+      title: `Answer • ${queryLabel}`,
+      lines: details.answer
+        ? String(details.answer).split('\n').flatMap(line => wrapText(sanitizeTerminalText(line, 500000), width)).map(line => `${C.white}${formatTerminalMarkdown(line)}${C.reset}`)
+        : [`${C.dim}${C.slate}No final answer was recorded.${C.reset}`],
+    });
+    return;
+  }
 
-  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 (request.view === 'thinking') {
+    const thinking = String(details.thinking || '').trim();
+    printSolidPanel({
+      title: `Thinking • ${queryLabel} • ${summary.thinkingCharacters} chars`,
+      lines: thinking
+        ? thinking.split('\n').flatMap(line => wrapText(sanitizeTerminalText(cleanThinkingLine(line), 500000), width)).map(line => `${C.dim}${C.slate}${line}${C.reset}`)
+        : [`${C.dim}${C.slate}No thinking trace was recorded.${C.reset}`],
+    });
+    return;
+  }
 
-  if (!details.tools.length) {
+  if (request.view === 'tools') {
     printSolidPanel({
-      title: `Tools • Q${details.number}`,
-      lines: [`${C.dim}${C.slate}No tools were used.${C.reset}`],
+      title: `Tool Timeline • ${queryLabel} • ${summary.toolCount} calls`,
+      lines: [
+        ...toolTimelineLines(true),
+        '',
+        `${C.dim}Open raw data with /details ${queryLabel} tool <n>.${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),
+  if (request.view === 'tool') {
+    const tool = details.tools?.[request.toolIndex - 1];
+    if (!tool) {
+      console.log(`\n  ${C.amber}[NOT FOUND] ${queryLabel} has no tool call #${request.toolIndex}.${C.reset}\n`);
+      return;
+    }
+    const args = serializeDetailValue(tool.args, Infinity);
+    const result = serializeDetailValue(tool.result, Infinity);
+    const rawLines = (label, serialized) => [
+      `${C.bold}${C.lavender}${label}:${C.reset}`,
+      ...serialized.text.split('\n').flatMap(line => safeWrappedLines(line, C.slate)),
     ];
-    printSolidPanel({ title: `Tool ${index + 1} • ${tool.name} • Q${details.number}`, lines });
+    printSolidPanel({
+      title: `Tool ${request.toolIndex} • ${sanitizeTerminalText(tool.name, 128)} • ${queryLabel}`,
+      lines: [
+        `${C.gold}Duration:${C.reset} ${C.white}${formatDetailDuration(tool.duration)}${C.reset}`,
+        ...rawLines('Arguments', args),
+        ...rawLines('Result', result),
+      ],
+    });
+    return;
+  }
+
+  if (request.view === 'markdown' || request.view === 'all') {
+    const copyable = getCopyableContent(details, request);
+    printSolidPanel({
+      title: copyable.title,
+      lines: copyable.text.split('\n').flatMap(line => wrapText(line, width)).map(line => `${C.white}${line}${C.reset}`),
+    });
+    return;
+  }
+
+  printSolidPanel({
+    title: `Query Diagnostics • ${queryLabel}`,
+    lines: [
+      `${C.gold}Status:${C.reset}     ${statusColor}${statusLabel}${C.reset}${details.error ? ` ${C.red}• ${sanitizeTerminalText(details.error, 240)}${C.reset}` : ''}`,
+      `${C.gold}Runtime:${C.reset}    ${C.white}${sanitizeTerminalText(details.provider || 'unknown', 80)} / ${sanitizeTerminalText(details.model || 'unknown', 160)}${C.reset}`,
+      `${C.gold}Duration:${C.reset}   ${C.white}${formatDetailDuration(details.durationMs)}${C.reset} ${C.dim}• ${details.iterations || 0}/${details.maxIterations || '?'} iterations${C.reset}`,
+      `${C.gold}Tools:${C.reset}      ${C.white}${summary.toolCount} calls${C.reset} ${C.dim}• ${summary.successfulTools} ok • ${summary.emptyTools} empty • ${summary.failedTools} failed • ${formatDetailDuration(summary.toolDurationMs)}${C.reset}`,
+      `${C.gold}Output:${C.reset}     ${C.white}${summary.answerCharacters} answer chars${C.reset} ${C.dim}• ${summary.thinkingCharacters} thinking chars • ${details.language || 'n/a'}${C.reset}`,
+      `${C.gold}Started:${C.reset}    ${C.dim}${startedLabel}${C.reset}`,
+      '',
+      `${C.bold}${C.lavender}Question:${C.reset}`,
+      ...safeWrappedLines(details.prompt),
+      '',
+      `${C.bold}${C.lavender}Tool timeline:${C.reset}`,
+      ...toolTimelineLines(false),
+      '',
+      `${C.dim}Views: /details ${queryLabel} answer | thinking | tools | tool <n> | all${C.reset}`,
+    ],
+  });
+}
+
+function copyQueryDetails(reference = '') {
+  const request = parseDetailsRequest(reference);
+  if (request.error) {
+    printSolidPanel({
+      title: 'Copy Details — Invalid Request',
+      lines: [
+        `${C.amber}${request.error}${C.reset}`,
+        '',
+        `${C.white}/copy [Qn] [answer]${C.reset} ${C.dim}— copy model answer (default)${C.reset}`,
+        `${C.white}/copy [Qn] thinking${C.reset} ${C.dim}— copy thinking trace${C.reset}`,
+        `${C.white}/copy [Qn] tools${C.reset} ${C.dim}— copy tools JSON${C.reset}`,
+        `${C.white}/copy [Qn] tool <n>${C.reset} ${C.dim}— copy tool <n> raw result${C.reset}`,
+        `${C.white}/copy [Qn] all${C.reset} ${C.dim}— copy full question & answer markdown${C.reset}`,
+      ],
+    });
+    return false;
+  }
+
+  const details = request.queryNumber == null
+    ? lastQueryDetails
+    : queryDetails.get(request.queryNumber);
+
+  if (!details) {
+    const target = request.queryNumber == null ? 'the latest query' : `Q${request.queryNumber}`;
+    console.log(`\n  ${C.amber}[NOT FOUND] No diagnostics recorded for ${target}.${C.reset}\n`);
+    return false;
+  }
+
+  const copyable = getCopyableContent(details, request);
+  if (!copyable || !copyable.text) {
+    console.log(`\n  ${C.amber}[EMPTY] Nothing to copy for ${request.view || 'answer'}.${C.reset}\n`);
+    return false;
+  }
+
+  const copied = copyToClipboard(copyable.text);
+  const lineCount = copyable.text.split('\n').length;
+  const charCount = copyable.text.length.toLocaleString();
+
+  printRichCard({
+    title: copied ? 'Copied to Clipboard' : 'Copy Content Ready',
+    status: copied ? 'ok' : 'info',
+    lines: [
+      `• Target: ${copyable.title}`,
+      `• Characters: ${charCount} chars (${lineCount} lines)`,
+      ...(copied
+        ? ['• Status: Copied to system clipboard (Ready to paste with Ctrl+V / Cmd+V)']
+        : ['• Status: Clipboard utility unavailable, displaying content below:']),
+    ],
+  });
+
+  if (!copied) {
+    const width = Math.max(16, getFullWidth() - 8);
+    printSolidPanel({
+      title: copyable.title,
+      lines: copyable.text.split('\n').flatMap(l => wrapText(l, width)).map(l => `${C.white}${l}${C.reset}`),
+    });
   }
+
+  return true;
 }
 
 export 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`);
+    const rawName = specificCmd.trim().toLowerCase();
+    const cmdName = rawName.startsWith('/') ? rawName : `/${rawName}`;
+    const definition = findCommandDefinition(cmdName);
+    const details = getCommandDetails(cmdName);
+
+    if (!definition && !details) {
+      printRichCard({
+        title: 'Unknown Command',
+        status: 'warning',
+        lines: [
+          `Command "${specificCmd}" was not found.`,
+          'Type /help to see all available commands.',
+        ],
+      });
       return;
     }
-    const maxContentWidth = Math.max(40, getFullWidth() - 8);
-    const wrappedDesc = wrapText(definition.desc, maxContentWidth);
-    const wrappedUsage = wrapText(`Usage: ${definition.usage}`, maxContentWidth);
+
+    const titleName = definition?.name || cmdName;
+    const summary = details?.summary || definition?.desc || 'Command description';
+    const usage = details?.usage || definition?.usage || `${titleName} [options]`;
+
+    const lines = [
+      `${C.bold}${C.white}${summary}${C.reset}`,
+      '',
+      `${C.bold}${C.lavender}Usage:${C.reset} ${C.cyberCyan}${usage}${C.reset}`,
+    ];
+
+    if (details?.subcommands && details.subcommands.length > 0) {
+      lines.push('', `${C.bold}${C.roseGlow}Subcommands & Options:${C.reset}`);
+      for (const sub of details.subcommands) {
+        lines.push(`  ${C.bold}${C.gold}${sub.cmd.padEnd(24)}${C.reset} ${C.white}${sub.desc}${C.reset}`);
+        if (sub.example) {
+          lines.push(`    ${C.dim}↳ Example: ${C.cyberCyan}${sub.example}${C.reset}`);
+        }
+      }
+    }
+
+    if (details?.examples && details.examples.length > 0) {
+      lines.push('', `${C.bold}${C.emerald}Quick Examples:${C.reset}`);
+      for (const ex of details.examples) {
+        lines.push(`  ${C.cyberCyan}❯ ${ex}${C.reset}`);
+      }
+    }
+
     printSolidPanel({
-      title: `${UI_ICONS.help} ${definition.name}`,
-      lines: [
-        ...wrappedDesc.map(d => `${C.white}${d}${C.reset}`),
-        ...wrappedUsage.map(u => `${C.dim}${u}${C.reset}`),
-      ],
+      title: `${UI_ICONS.help} Command Help • ${titleName}`,
+      lines,
     });
     return;
   }
@@ -247,7 +450,7 @@ export function printHelp(specificCmd = null) {
     }
   }
 
-  helpLines.push(`${C.dim}Tip: Press Tab for auto-completion • Type /help <command> for details.${C.reset}`);
+  helpLines.push('', `${C.dim}Tip: Press Tab for auto-completion • Type /help <command> (e.g. /help suggestion, /help mcp, /help provider) for detailed subcommand breakdowns.${C.reset}`);
 
   printSolidPanel({
     title: `${UI_ICONS.help} Kiku AI Agent — ${COMMAND_DEFINITIONS.length} Commands`,
@@ -302,6 +505,7 @@ class InteractiveTuiPrompt {
     this.isResolving = false;
     this.activeResolve = null;
     this.activeReject = null;
+    this.onCancel = options.onCancel || null;
     this.onSigInt = options.onSigInt || null;
     this._keyHandler = null;
     this._renderTimer = null;
@@ -318,18 +522,24 @@ class InteractiveTuiPrompt {
   }
 
   addViewportLines(lines) {
-    if (!lines) return;
+    if (lines === null || lines === undefined) return;
     if (!Array.isArray(lines)) lines = [lines];
+    const wasLive = this.scrollOffset === 0;
     for (const l of lines) {
       if (typeof l === 'string') {
         const sublines = l.split('\n');
-        for (const sl of sublines) this.viewportLines.push(sl);
+        for (const sl of sublines) {
+          this.viewportLines.push(sl);
+        }
+      } else if (l != null) {
+        this.viewportLines.push(String(l));
       }
     }
     if (this.viewportLines.length > 5000) {
-      this.viewportLines.splice(0, this.viewportLines.length - 5000);
+      const removedCount = this.viewportLines.length - 5000;
+      this.viewportLines.splice(0, removedCount);
     }
-    if (this.scrollOffset === 0) {
+    if (wasLive) {
       this.scrollOffset = 0;
     }
     this.render();
@@ -351,7 +561,7 @@ class InteractiveTuiPrompt {
   }
 
   clearPrompt() {
-  
+
   }
 
   clearPopover() {
@@ -365,7 +575,7 @@ class InteractiveTuiPrompt {
   _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 {}
+    try { if (input.isTTY) input.setRawMode(false); } catch { }
   }
 
   async readLine() {
@@ -456,68 +666,84 @@ class InteractiveTuiPrompt {
   render() {
     if (this.isDisposed || !this.screenBuffer) return;
     const termCols = Math.max(20, process.stdout.columns || 80);
-    const termRows = Math.max(10, process.stdout.rows || 24);
+    const {
+      termRows,
+      viewportStartRow,
+      viewportHeight,
+      statusBarRow,
+      promptRow,
+      separatorRow,
+    } = getTuiViewportLayout(process.stdout.rows || 24);
 
     this.screenBuffer.resize(termCols, termRows);
     this.screenBuffer.clear(C.bgDark);
 
-    
+
     const shortModel = (this.modelName || 'gemma-4-e4b').replace(/^.*\//, '');
     const modelLabel = `${C.gold}✦ ${shortModel}${C.reset}`;
     const mcpCount = this.agent?.mcpManager?.servers?.size || 0;
     const mcpLabel = mcpCount > 0 ? `${C.emerald}● ${mcpCount} MCP${C.reset}` : `${C.slate}○ 0 MCP${C.reset}`;
 
-    const headerLeft = `  ${C.bold}${C.sakura}◆ KIKU AGENT${C.reset} ${C.slate}v1.0.5${C.reset}`;
-    const headerRight = `${modelLabel}  ${C.slate}│${C.reset}  ${mcpLabel}  ${C.slate}│${C.reset}  ${C.roseGlow}◆ Sakura${C.reset}  `;
+    const activeTheme = getTheme ? getTheme() : null;
+    const themeName = activeTheme?.label || 'Sakura';
+    const headerLeft = `  ${C.bold}${C.sakura}◆ KIKU AGENT${C.reset} ${C.slate}v${PACKAGE_VERSION}${C.reset}`;
+    const headerRight = `${modelLabel}  ${C.slate}│${C.reset}  ${mcpLabel}  ${C.slate}│${C.reset}  ${C.roseGlow}◆ ${themeName}${C.reset}  `;
     const safeCols = Math.max(1, termCols - 1);
     const headerPad = Math.max(1, safeCols - getStringDisplayWidth(headerLeft) - getStringDisplayWidth(headerRight));
     this.screenBuffer.setRow(0, `${headerLeft}${' '.repeat(headerPad)}${headerRight}`, C.bgPanelHeader);
 
 
-    const vpStartRow = 1;
-    const vpHeight = Math.max(1, termRows - 4);
     const totalLines = this.viewportLines.length;
-    const maxOffset = Math.max(0, totalLines - vpHeight);
+    const maxOffset = Math.max(0, totalLines - viewportHeight);
     const currentOffset = Math.min(this.scrollOffset, maxOffset);
-    const startIndex = Math.max(0, totalLines - vpHeight - currentOffset);
-    const visibleLines = this.viewportLines.slice(startIndex, startIndex + vpHeight);
+    const startIndex = Math.max(0, totalLines - viewportHeight - currentOffset);
+    const visibleLines = this.viewportLines.slice(startIndex, startIndex + viewportHeight);
 
-    for (let r = 0; r < vpHeight; r++) {
+    for (let r = 0; r < viewportHeight; r++) {
       const lineContent = visibleLines[r] || '';
-      this.screenBuffer.setRow(vpStartRow + r, lineContent, C.bgDark);
+      this.screenBuffer.setRow(viewportStartRow + r, lineContent, C.bgDark);
     }
 
-  
-    const statusBarRow = termRows - 4;
     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 stateLabel = stripAnsi(this.agentState || 'Processing…');
+      const elapsed = this.agentState && this.agentStateTime
+        ? ` ${((Date.now() - this.agentStateTime) / 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}`;
+      const statusLeft = `  ${C.cyberCyan}${frame} ${activeLabel}${stateLabel}${elapsed}${C.reset}${C.slate}${queueLabel}${C.reset}`;
+      if (currentOffset > 0) {
+        const statusRight = `${C.amber}${C.bold}↓ ${currentOffset} more${C.reset} ${C.slate}below (press [End])${C.reset}  `;
+        const pad = Math.max(1, safeCols - getStringDisplayWidth(statusLeft) - getStringDisplayWidth(statusRight));
+        statusStyled = `${statusLeft}${' '.repeat(pad)}${statusRight}`;
+      } else {
+        statusStyled = statusLeft;
+      }
+    } else if (currentOffset > 0) {
+      const posInfo = startIndex > 0 ? ` ${C.slate}• ↑ ${startIndex} above${C.reset}` : '';
+      const statusLeft = `  ${C.amber}${C.bold}↓ ${currentOffset} more${C.reset} ${C.slate}below${C.reset}${posInfo}`;
+      const statusRight = `${C.slate}press ${C.white}${C.bold}[End]${C.reset}${C.slate} to return to bottom${C.reset}  `;
+      const pad = Math.max(1, safeCols - getStringDisplayWidth(statusLeft) - getStringDisplayWidth(statusRight));
+      statusStyled = `${statusLeft}${' '.repeat(pad)}${statusRight}`;
     } else if (musicStatus) {
       statusStyled = `  ${C.cyberCyan}🎵 ${musicStatus}${C.reset}`;
-    } else if (currentOffset > 0) {
-      statusStyled = `  ${C.amber}[↑ SCROLLED +${currentOffset} lines — press [End] to return to live stream]${C.reset}`;
     } else {
-      statusStyled = `  ${C.emerald}●${C.reset} ${C.slate}IDLE • Ask anything about Ju Jingyi or type / for commands${C.reset}`;
+      statusStyled = `  ${C.emerald}● READY${C.reset}`;
     }
 
     this.screenBuffer.setRow(statusBarRow, statusStyled, C.bgPanelHeader);
 
-  
+
     if (this.popoverActive && this.popoverItems.length > 0) {
-      const maxItems = Math.min(5, Math.max(1, vpHeight - 1));
+      const maxItems = Math.min(5, Math.max(1, viewportHeight - 1));
       const startIdx = Math.max(0, Math.min(this.popoverIndex - 2, this.popoverItems.length - maxItems));
       const visibleItems = this.popoverItems.slice(startIdx, startIdx + maxItems);
       const popoverHeight = visibleItems.length + 1;
-      const popoverStartRow = Math.max(vpStartRow, statusBarRow - popoverHeight);
+      const popoverStartRow = Math.max(viewportStartRow, statusBarRow - popoverHeight);
 
       this.screenBuffer.setRow(
         popoverStartRow,
@@ -540,11 +766,10 @@ class InteractiveTuiPrompt {
       }
     }
 
-  
-    const promptRow = termRows - 2;
+
     let promptStyled = `${C.bold}${C.sakura}${this.promptText}${C.reset}`;
     const promptVisualWidth = getStringDisplayWidth(this.promptText);
-    const maxLineWidth = Math.max(1, termCols - promptVisualWidth - 3);
+    const maxLineWidth = Math.max(1, termCols - promptVisualWidth - 2);
 
     const lineVisualWidth = getStringDisplayWidth(this.line);
     const { displayLine, cursorVisualOffset } = sliceLineForDisplay(this.line, this.cursor, maxLineWidth);
@@ -563,22 +788,35 @@ class InteractiveTuiPrompt {
       trailingStyled = `${C.dim}${C.slate}${placeholder}${C.reset}`;
     }
 
-    const rowStyled = ` ❯ ${promptStyled}${C.white}${displayLine}${trailingStyled}`;
+    const rowStyled = `  ${promptStyled}${C.white}${displayLine}${trailingStyled}`;
     this.screenBuffer.setRow(promptRow, rowStyled, C.bgPanel);
 
-    this.screenBuffer.setRow(termRows - 1, '─'.repeat(termCols), C.bgDark);
+    this.screenBuffer.setRow(separatorRow, '─'.repeat(termCols), C.bgDark);
 
-    const cursorCol = 3 + promptVisualWidth + cursorVisualOffset;
+    const cursorCol = 2 + promptVisualWidth + cursorVisualOffset;
     this.screenBuffer.setCursor(promptRow, cursorCol, true);
     this.screenBuffer.render();
   }
 
   handleKeypress(str, key) {
-    if (!key) return;
+    if (!key && !str) 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; }
+    if ((key?.ctrl && key?.name === 'c') || str === '\x03') {
+      if (isProcessing) {
+        if (this.onCancel) this.onCancel();
+        else if (this.onSigInt) this.onSigInt();
+        this.addViewportLines(`  ${C.amber}[✓ Cancelled by user]${C.reset}`);
+        this.agentState = '';
+        this.render();
+        return;
+      }
+      if (this.line.length > 0) {
+        this.line = '';
+        this.cursor = 0;
+        this.updateState();
+        this.render();
+        return;
+      }
       const now = Date.now();
       if (!this._lastCtrlCTime || now - this._lastCtrlCTime > 2000) {
         this._lastCtrlCTime = now;
@@ -589,49 +827,88 @@ class InteractiveTuiPrompt {
       return;
     }
 
-    if (key.name === 'pageup') {
-      const termRows = Math.max(10, process.stdout.rows || 24);
-      const vpHeight = Math.max(1, termRows - 4);
-      const maxOffset = Math.max(0, this.viewportLines.length - vpHeight);
-      this.scrollOffset = Math.min(maxOffset, this.scrollOffset + Math.max(1, vpHeight - 2));
-      this.render();
+    if (key?.name === 'escape' || str === '\x1b') {
+      if (this.popoverActive) {
+        this.popoverActive = false;
+        this.popoverItems = [];
+        this.ghostText = '';
+        this.render();
+        return;
+      }
+      if (this.scrollOffset > 0) {
+        this.scrollOffset = 0;
+        this.render();
+        return;
+      }
+      if (isProcessing) {
+        if (this.onCancel) this.onCancel();
+        this.addViewportLines(`  ${C.amber}[✓ Cancelled by user]${C.reset}`);
+        this.agentState = '';
+        this.render();
+        return;
+      }
       return;
     }
 
-    if (key.name === 'pagedown') {
-      const termRows = Math.max(10, process.stdout.rows || 24);
-      const vpHeight = Math.max(1, termRows - 4);
-      this.scrollOffset = Math.max(0, this.scrollOffset - Math.max(1, vpHeight - 2));
+    if (
+      str && (
+        str.startsWith('\x1b') ||
+        str.includes('\x1b') ||
+        str.includes('[<') ||
+        str.includes('[M') ||
+        /^<[0-9;]*[a-zA-Z]?$/.test(str) ||
+        /^[0-9;]+[a-zA-Z]$/.test(str) ||
+        /^[0-9;]{2,}$/.test(str) ||
+        /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(str)
+      )
+    ) {
+      if (str.includes('[<64;') || str.includes('[64;') || str.includes('<64;') || (key?.name === 'up' && key?.shift)) {
+        const { viewportHeight } = getTuiViewportLayout(process.stdout.rows || 24);
+        const maxOffset = Math.max(0, this.viewportLines.length - viewportHeight);
+        this.scrollOffset = Math.min(maxOffset, this.scrollOffset + 3);
+        this.render();
+        return;
+      }
+      if (str.includes('[<65;') || str.includes('[65;') || str.includes('<65;') || (key?.name === 'down' && key?.shift)) {
+        if (this.scrollOffset > 0) {
+          this.scrollOffset = Math.max(0, this.scrollOffset - 3);
+          this.render();
+        }
+        return;
+      }
+      if (str !== '\r' && str !== '\n' && str !== '\t' && str !== '\x08' && str !== '\x7f') {
+        return;
+      }
+    }
+
+    if (key?.name === 'pageup') {
+      const { viewportHeight } = getTuiViewportLayout(process.stdout.rows || 24);
+      const maxOffset = Math.max(0, this.viewportLines.length - viewportHeight);
+      this.scrollOffset = Math.min(maxOffset, this.scrollOffset + Math.max(1, viewportHeight - 2));
       this.render();
       return;
     }
 
-    if (key.ctrl && key.name === 'l') {
+    if (key?.name === 'pagedown') {
+      const { viewportHeight } = getTuiViewportLayout(process.stdout.rows || 24);
+      this.scrollOffset = Math.max(0, this.scrollOffset - Math.max(1, viewportHeight - 2));
       this.render();
       return;
     }
 
-    if (key.name === 'escape') {
-      if (this.popoverActive) {
-        this.popoverActive = false;
-        this.popoverItems = [];
-        this.ghostText = '';
-        this.render();
-      } else if (this.scrollOffset > 0) {
-        this.scrollOffset = 0;
-        this.render();
-      }
+    if (key?.ctrl && key?.name === 'l') {
+      this.render();
       return;
     }
 
-    if (key.name === 'f2') {
+    if (key?.name === 'f2') {
       this.finish('/details');
       return;
     }
 
-    if (key.name === 'tab') {
+    if (key?.name === 'tab' || str === '\t') {
       if (this.popoverActive && this.popoverItems.length > 0) {
-        const item = this.popoverItems[this.popoverIndex];
+        const item = this.popoverItems[this.popoverIndex] || this.popoverItems[0];
         if (item) {
           this.line = item.insert || item.name;
           this.cursor = item.newCursor !== undefined ? item.newCursor : this.line.length;
@@ -649,25 +926,24 @@ class InteractiveTuiPrompt {
       return;
     }
 
-    if (key.name === 'return' || key.name === 'enter') {
+    if (key?.name === 'return' || key?.name === 'enter' || str === '\r' || str === '\n') {
+      let textToSubmit = this.line;
       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 = item.newCursor !== undefined ? item.newCursor : this.line.length;
-            this.updateState();
-            this.render();
-            return;
+        const selected = this.popoverItems[this.popoverIndex] || this.popoverItems[0];
+        if (selected) {
+          const target = (selected.insert || selected.name || '').trim();
+          if (this.line.startsWith('/') && !this.line.includes(' ')) {
+            textToSubmit = target;
+          } else if (this.line.startsWith('/') && this.line.length < target.length && target.startsWith(this.line.trim())) {
+            textToSubmit = target;
           }
-          this.line = insertVal;
-          this.finish(this.line);
-          return;
         }
       }
+      this.popoverActive = false;
+      this.popoverItems = [];
+      this.ghostText = '';
       this.scrollOffset = 0;
-      this.finish(this.line);
+      this.finish(textToSubmit);
       return;
     }
 
@@ -687,22 +963,21 @@ class InteractiveTuiPrompt {
         this.render();
         return;
       }
-      const termRows = Math.max(10, process.stdout.rows || 24);
-      const vpHeight = Math.max(1, termRows - 4);
-      const maxOffset = Math.max(0, this.viewportLines.length - vpHeight);
+      const { viewportHeight } = getTuiViewportLayout(process.stdout.rows || 24);
+      const maxOffset = Math.max(0, this.viewportLines.length - viewportHeight);
       this.scrollOffset = Math.min(maxOffset, this.scrollOffset + 1);
       this.render();
       return;
     }
 
-    if (key.name === 'down' || (key.ctrl && key.name === 'n')) {
+    if (key?.name === 'down' || (key?.ctrl && key?.name === 'n')) {
       if (this.popoverActive && this.popoverItems.length > 0) {
         this.popoverIndex = (this.popoverIndex + 1) % this.popoverItems.length;
         this.updateState();
         this.render();
         return;
       }
-      if (key.ctrl && this.history.length > 0 && this.historyIndex !== -1) {
+      if (key?.ctrl && this.history.length > 0 && this.historyIndex !== -1) {
         if (this.historyIndex < this.history.length - 1) {
           this.historyIndex++;
           this.line = this.history[this.historyIndex] || '';
@@ -722,11 +997,10 @@ class InteractiveTuiPrompt {
       return;
     }
 
-    if (key.name === 'home' || (key.ctrl && key.name === 'a')) {
+    if (key?.name === 'home' || (key?.ctrl && key?.name === 'a')) {
       if (this.line === '') {
-        const termRows = Math.max(10, process.stdout.rows || 24);
-        const vpHeight = Math.max(1, termRows - 6);
-        this.scrollOffset = Math.max(0, this.viewportLines.length - vpHeight);
+        const { viewportHeight } = getTuiViewportLayout(process.stdout.rows || 24);
+        this.scrollOffset = Math.max(0, this.viewportLines.length - viewportHeight);
         this.render();
       } else {
         this.cursor = 0;
@@ -735,7 +1009,7 @@ class InteractiveTuiPrompt {
       return;
     }
 
-    if (key.name === 'end' || (key.ctrl && key.name === 'e')) {
+    if (key?.name === 'end' || (key?.ctrl && key?.name === 'e')) {
       if (this.line === '') {
         this.scrollOffset = 0;
         this.render();
@@ -746,18 +1020,22 @@ class InteractiveTuiPrompt {
       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 === '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 === '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 (key?.name === 'backspace' || str === '\x08' || str === '\x7f') { 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 && !key?.ctrl && !key?.meta) {
       if (
         str.startsWith('\x1b') ||
-        /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(str) ||
-        /^[0-9;]+[Mm]$/.test(str) ||
-        /^<*[0-9;]+[Mm]/.test(str)
+        str.includes('\x1b') ||
+        str.includes('[<') ||
+        str.includes('[M') ||
+        /[\x00-\x1f\x7f]/.test(str) ||
+        /^<[0-9;]*[a-zA-Z]?$/.test(str) ||
+        /^[0-9;]+[a-zA-Z]$/.test(str) ||
+        /^[0-9;]{2,}$/.test(str)
       ) return;
       this.line = this.line.slice(0, this.cursor) + str + this.line.slice(this.cursor);
       this.cursor += str.length;
@@ -815,10 +1093,19 @@ function getSuggestionsForLine(line, cursor = (line || '').length, agent = null)
 
   if (parts.length > 1 || (parts.length === 1 && line.includes(' '))) {
     const subs = SUB_COMMANDS[baseCmd] || [];
+    const details = getCommandDetails(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} ` }));
+      .map(s => {
+        const subKey = s.split(/\s+/)[0].toLowerCase();
+        const matchedDetail = details?.subcommands?.find(sc => {
+          const scKey = sc.cmd.split(/\s+/)[0].toLowerCase();
+          return scKey === subKey || sc.cmd.toLowerCase().includes(subKey);
+        });
+        const desc = matchedDetail?.desc || '';
+        return { name: `${baseCmd} ${s}`, desc, insert: `${baseCmd} ${s} ` };
+      });
   }
 
   return allCmds
@@ -826,589 +1113,916 @@ function getSuggestionsForLine(line, cursor = (line || '').length, agent = null)
     .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 queryStartedAt = Date.now();
+          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 = C.bgPanel;
+          const bgHeader = C.bgPanelHeader;
+          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}`
+            : 'Answer';
+
+
+        
+          let jsonSuppressDepth = 0;
+          let jsonSuppressActive = false;
+          let fencedJsonBlock = false;
+          let suppressedLineCount = 0;
+
+          const _RAW_JSON_FIELD_RE = /["'](?:_meta|protocol|requestedTool|authoritative|tool_call_id|validationWarnings|cache|duplicate_call_in_query)["']\s*:/;
+          const _ACTION_INPUT_RE = /^Action\s*:\s*[a-zA-Z0-9_]+\s*$/;
+          const _ACTION_INPUT_BODY_RE = /^Action Input\s*:\s*\{/;
+
+          const isRawJsonPayloadLine = (line) => {
+            const trimmed = line.trim();
+            if (/^```json\s*$/i.test(trimmed)) return 'fence_start';
+            if (fencedJsonBlock && /^```\s*$/.test(trimmed)) return 'fence_end';
+            if (_RAW_JSON_FIELD_RE.test(trimmed)) return 'json_field';
+            if (_ACTION_INPUT_RE.test(trimmed) || _ACTION_INPUT_BODY_RE.test(trimmed)) return 'action_pattern';
+            if (jsonSuppressActive) {
+              if (/^[{}\[\],]*$/.test(trimmed)) return 'json_structure';
+              if (/^["'][a-zA-Z_]+["']\s*:/.test(trimmed)) return 'json_field';
+              if (/^(?:\d+|true|false|null|"[^"]*")\s*,?\s*$/.test(trimmed)) return 'json_value';
+            }
+            return null;
+          };
 
-  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 filterResponseLine = (line) => {
+            const detection = isRawJsonPayloadLine(line);
 
-  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);
-      }
-    }
-  };
+            if (detection === 'fence_start') {
+              fencedJsonBlock = true;
+              jsonSuppressActive = true;
+              suppressedLineCount = 0;
+              return false;
+            }
+            if (detection === 'fence_end') {
+              fencedJsonBlock = false;
+              jsonSuppressActive = false;
+              if (suppressedLineCount > 0) {
+                printPlainResponseLine(`${C.dim}${C.slate}[tool data filtered — ${suppressedLineCount} lines]${C.reset}`);
+              }
+              suppressedLineCount = 0;
+              return false;
+            }
+            if (fencedJsonBlock) {
+              suppressedLineCount++;
+              return false;
+            }
 
-  const flushPendingTableHeader = () => {
-    if (!pendingTableHeader) return;
-    printPlainResponseLine(`| ${pendingTableHeader.join(' | ')} |`);
-    pendingTableHeader = null;
-  };
+            if (detection) {
+              if (!jsonSuppressActive) {
+                jsonSuppressActive = true;
+                jsonSuppressDepth = 0;
+                suppressedLineCount = 0;
+              }
+              const trimmed = line.trim();
+              for (const ch of trimmed) {
+                if (ch === '{' || ch === '[') jsonSuppressDepth++;
+                else if (ch === '}' || ch === ']') jsonSuppressDepth--;
+              }
+              suppressedLineCount++;
+              if (jsonSuppressDepth <= 0 && suppressedLineCount > 1) {
+                jsonSuppressActive = false;
+                if (suppressedLineCount > 2) {
+                  printPlainResponseLine(`${C.dim}${C.slate}[tool data filtered — ${suppressedLineCount} lines]${C.reset}`);
+                }
+                suppressedLineCount = 0;
+              }
+              return false;
+            }
 
-  const printResponseLine = (line) => {
-    const cells = parseMarkdownTableRow(line);
+            if (jsonSuppressActive) {
+              jsonSuppressActive = false;
+              jsonSuppressDepth = 0;
+              if (suppressedLineCount > 2) {
+                printPlainResponseLine(`${C.dim}${C.slate}[tool data filtered — ${suppressedLineCount} lines]${C.reset}`);
+              }
+              suppressedLineCount = 0;
+            }
 
-    if (pendingTableHeader) {
-      if (cells && cells.length === pendingTableHeader.length && isMarkdownTableSeparator(cells)) {
-        activeTableHeaders = pendingTableHeader;
-        pendingTableHeader = null;
-        tableRowNumber = 0;
-        return;
-      }
-      flushPendingTableHeader();
-    }
+            return true;
+          };
+
+          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);
+              }
+            }
+          };
 
-    if (activeTableHeaders) {
-      if (cells && cells.length === activeTableHeaders.length && !isMarkdownTableSeparator(cells)) {
-        printTableRecord(cells);
-        return;
-      }
-      activeTableHeaders = null;
-      tableRowNumber = 0;
-    }
+          const flushPendingTableHeader = () => {
+            if (!pendingTableHeader) return;
+            printPlainResponseLine(`| ${pendingTableHeader.join(' | ')} |`);
+            pendingTableHeader = null;
+          };
 
-    if (cells && !isMarkdownTableSeparator(cells)) {
-      pendingTableHeader = cells;
-      return;
-    }
+          const printResponseLine = (line) => {
+            if (!filterResponseLine(line)) return;
 
-    printPlainResponseLine(line);
-  };
+            const cells = parseMarkdownTableRow(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();
-  };
+            if (pendingTableHeader) {
+              if (cells && cells.length === pendingTableHeader.length && isMarkdownTableSeparator(cells)) {
+                activeTableHeaders = pendingTableHeader;
+                pendingTableHeader = null;
+                tableRowNumber = 0;
+                return;
+              }
+              flushPendingTableHeader();
+            }
 
-  const startSpinner = (label) => {
-    if (globalTuiPrompt) { globalTuiPrompt.agentState = label; globalTuiPrompt.agentStateTime = Date.now(); }
-    if (!spinnerInterval) {
-      spinnerInterval = setInterval(() => { if (globalTuiPrompt && isProcessing) globalTuiPrompt.render(); }, 80);
-    }
-  };
+            if (activeTableHeaders) {
+              if (cells && cells.length === activeTableHeaders.length && !isMarkdownTableSeparator(cells)) {
+                printTableRecord(cells);
+                return;
+              }
+              activeTableHeaders = null;
+              tableRowNumber = 0;
+            }
 
-  const stopSpinner = () => {
-    if (spinnerInterval) { clearInterval(spinnerInterval); spinnerInterval = null; }
-    if (globalTuiPrompt) { globalTuiPrompt.agentState = ''; globalTuiPrompt.render(); }
-  };
+            if (cells && !isMarkdownTableSeparator(cells)) {
+              pendingTableHeader = cells;
+              return;
+            }
 
-  let thinkingShown = false;
-  let thinkingBuffer = '';
-  let thinkingStartTime = 0;
-  let accumulatedThinking = '';
-  let recordedTools = [];
-  let currentToolArgs = {};
+            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) {
+              if (jsonSuppressActive && suppressedLineCount > 2) {
+                printPlainResponseLine(`${C.dim}${C.slate}[tool data filtered — ${suppressedLineCount} lines]${C.reset}`);
+              }
+              jsonSuppressActive = false;
+              jsonSuppressDepth = 0;
+              suppressedLineCount = 0;
+              fencedJsonBlock = false;
+              flushPendingTableHeader();
+            }
+          };
 
-  startSpinner(`${C.slate}Thinking…${C.reset}`);
+          const startSpinner = (label) => {
+            if (globalTuiPrompt) {
+              globalTuiPrompt.agentState = label;
+              globalTuiPrompt.agentStateTime = Date.now();
+              globalTuiPrompt.render();
+            }
+            if (!spinnerInterval) {
+              spinnerInterval = setInterval(() => {
+                if (globalTuiPrompt && isProcessing) {
+                  globalTuiPrompt.render();
+                }
+              }, 80);
+            }
+          };
 
-  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);
-              }
+          const stopSpinner = () => {
+            if (spinnerInterval) {
+              clearInterval(spinnerInterval);
+              spinnerInterval = null;
             }
-          }
-        }
-      },
-      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);
+            if (globalTuiPrompt) {
+              globalTuiPrompt.agentState = '';
+              globalTuiPrompt.render();
             }
-          }
-          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);
+          };
+
+          let thinkingShown = false;
+          let thinkingBuffer = '';
+          let thinkingStartTime = 0;
+          let accumulatedThinking = '';
+          let recordedTools = [];
+          let currentToolArgs = {};
+          let completedIterations = 0;
+          let finalAnswer = '';
+          let finalMeta = {};
+
+          const persistQueryDetails = (status, error = null) => {
+            lastQueryDetails = {
+              number: queryNumber,
+              prompt,
+              answer: finalAnswer,
+              thinking: accumulatedThinking,
+              tools: recordedTools,
+              status,
+              error: error ? String(error.message || error) : null,
+              provider: agent.client?.providerName || agent.client?.provider || 'unknown',
+              model: agent.client?.model || 'unknown',
+              language: finalMeta.language || null,
+              iterations: completedIterations,
+              maxIterations: agent.maxIterations,
+              startedAt: queryStartedAt,
+              completedAt: Date.now(),
+              durationMs: finalMeta.durationMs ?? (Date.now() - queryStartedAt),
+              timestamp: Date.now(),
+            };
+            if (queryNumber != null) {
+              queryDetails.set(queryNumber, lastQueryDetails);
+              if (queryDetails.size > 50) queryDetails.delete(queryDetails.keys().next().value);
             }
+          };
+
+          startSpinner(`${C.slate}Thinking…${C.reset}`);
+
+          try {
+            const returnedAnswer = await agent.ask(prompt, {
+              signal,
+              onStepStart: iteration => { completedIterations = Math.max(completedIterations, Number(iteration) || 0); },
+              onReasoningStart: () => {
+                startSpinner(`${C.slate}Thinking…${C.reset}`);
+                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 {
+                  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) => {
+                if (!toolSectionStarted) {
+                  console.log('');
+                  const detailHint = queryTag ? `  ${C.dim}Details: F2 or /details ${queryTag}` : '';
+                  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 : '';
+                startSpinner(`${C.cyberCyan}• ${C.bold}${C.white}${toolName}${C.reset}${displayQuery ? ` ${C.slate}"${displayQuery}"${C.reset}` : ''}`);
+              },
+
+              onToolResult: (toolName, result, durationMs) => {
+                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: () => {
+                if (globalTuiPrompt) {
+                  globalTuiPrompt.agentState = 'Streaming…';
+                  globalTuiPrompt.agentStateTime = Date.now();
+                  globalTuiPrompt.render();
+                }
+              },
+
+              onTokenDelta: (token) => {
+                if (!hasPrintedResponseHeader) { hasPrintedResponseHeader = true; }
+                responseLineBuffer += token;
+                flushResponseBuffer(false);
+              },
+
+              onFinalAnswer: (answer, meta = {}) => {
+                stopSpinner();
+                finalAnswer = String(answer || '');
+                finalMeta = meta || {};
+                if (!hasPrintedResponseHeader) {
+                  for (const line of (answer || '').split('\n')) { if (line.length > 0) printResponseLine(line); }
+                  flushPendingTableHeader();
+                } else {
+                  flushResponseBuffer(true);
+                }
+              },
+
+              onError: (err) => {
+                stopSpinner();
+                printRichCard({
+                  title: 'Execution Error',
+                  status: 'error',
+                  lines: [err.message],
+                });
+              },
+            });
+
+            if (!finalAnswer && returnedAnswer) finalAnswer = String(returnedAnswer);
+            persistQueryDetails('complete');
+            if (responsePanelStarted) console.log('');
+          } catch (err) {
+            stopSpinner();
+            persistQueryDetails(isAbortError(err) ? 'aborted' : 'error', err);
+            if (!isAbortError(err)) {
+              printRichCard({
+                title: 'Query Failed',
+                status: 'error',
+                lines: [err.message],
+              });
+            } else {
+              printRichCard({
+                title: 'Query Cancelled',
+                status: 'warning',
+                lines: ['Query processing was interrupted.'],
+              });
+            }
+          } finally {
+            stopSpinner();
           }
         }
-      },
-
-      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();
+          const opts = parseCliArgs();
+
+          if (opts.version) { console.log(PACKAGE_VERSION); process.exit(0); }
+          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.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); }
+
+          if (opts.query) {
+            printWelcomeHero();
+            const client = new LLMClient({
+              provider: opts.provider || config.activeProvider,
+              baseUrl: opts.url,
+              apiKey: opts.apiKey,
+              model: opts.model
+            });
+            const modelManager = new ModelManager(client, { requestedModel: opts.model || client.model });
+            const modelResolution = await modelManager.resolve({ requestedModel: opts.model || client.model });
+            if (!modelResolution.connected || !modelResolution.selectedModel) {
+              throw new Error(modelResolution.error || `No available chat model found for ${client.providerName}`);
+            }
+            if (modelResolution.usedFallback) {
+              console.log(`  ${C.amber}Model ${modelResolution.requestedModel} is unavailable; using ${modelResolution.selectedModel}.${C.reset}\n`);
+            }
+            console.log(`  ${C.bold}${C.gold}QUERY${C.reset} ${C.white}${opts.query}${C.reset}\n`);
+            const agent = new KikuAgent({ client, thinkingMode: opts.thinking });
+            await executeQueryWithUI(agent, opts.query, agent.session.thinkingMode === 'show', null, 1);
+            process.exit(0);
+          }
 
-  if (opts.showStats) { printWelcomeHero(); const r = await executeTool('get_system_stats', {}); console.log(JSON.stringify(r, null, 2)); process.exit(0); }
 
-  if (opts.query) {
-    printWelcomeHero();
-    const client = new LLMClient({
-      provider: opts.provider || config.activeProvider,
-      baseUrl: opts.url,
-      apiKey: opts.apiKey,
-      model: opts.model
-    });
-    console.log(`  ${C.bold}${C.gold}QUERY${C.reset} ${C.white}${opts.query}${C.reset}\n`);
-    const agent = new KikuAgent({ client, thinkingMode: opts.thinking });
-    await executeQueryWithUI(agent, opts.query, agent.session.thinkingMode === 'show', null, 1);
-    process.exit(0);
-  }
+          try { process.stdout.write('\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1005l\x1b[?1006l\x1b[?1015l'); } catch { }
+          enterAlternateScreen();
 
+          const client = new LLMClient({
+            provider: opts.provider || config.activeProvider,
+            baseUrl: opts.url,
+            apiKey: opts.apiKey,
+            model: opts.model
+          });
+          const baseUrl = client.baseUrl;
+          const agent = new KikuAgent({ client, thinkingMode: opts.thinking });
+
+          function cancelActiveQuery() {
+            let cancelled = false;
+            if (activeAbortController) {
+              activeAbortController.abort();
+              activeAbortController = null;
+              cancelled = true;
+            }
+            if (agent && typeof agent.cancelResearch === 'function') {
+              agent.cancelResearch();
+              cancelled = true;
+            }
+            if (queryQueue.length > 0) {
+              queryQueue.length = 0;
+              cancelled = true;
+            }
+            if (cancelled) {
+              if (globalTuiPrompt) {
+                globalTuiPrompt.agentState = '';
+                globalTuiPrompt.render();
+              }
+              return true;
+            }
+            return false;
+          }
 
-  enterAlternateScreen();
+          const tuiPrompt = new InteractiveTuiPrompt({
+            prompt: 'Kiku ❯ ',
+            agent,
+            modelName: opts.model || client.model || 'gemma-4-e4b',
+            provider: client.providerName,
+            onCancel: cancelActiveQuery,
+            onSigInt: async () => {
+              if (activeAbortController || isProcessing) {
+                cancelActiveQuery();
+              } else {
+                try { await agent.endSession(); } catch { }
+                if (globalTuiPrompt) {
+                  globalTuiPrompt.dispose();
+                  globalTuiPrompt = null;
+                }
+                exitAlternateScreen();
+                console.log(`\n  ${C.sakura}Goodbye. (鞠躬 ~ 谢谢!)${C.reset}\n`);
+                process.exit(0);
+              }
+            }
+          });
 
-  const client = new LLMClient({
-    provider: opts.provider || config.activeProvider,
-    baseUrl: opts.url,
-    apiKey: opts.apiKey,
-    model: opts.model
-  });
-  const baseUrl = client.baseUrl;
-  const agent = new KikuAgent({ client, thinkingMode: opts.thinking });
-
-  const tuiPrompt = new InteractiveTuiPrompt({
-    prompt: 'Kiku ❯ ',
-    agent,
-    modelName: opts.model || client.model || 'gemma-4-e4b',
-    provider: client.providerName,
-    onSigInt: async () => {
-      if (activeAbortController) {
-        activeAbortController.abort();
-        activeAbortController = null;
-        queryQueue.length = 0;
-        deferredCommands.length = 0;
-      } else {
-        try { await agent.endSession(); } catch {}
-        if (globalTuiPrompt) {
-          globalTuiPrompt.dispose();
-          globalTuiPrompt = null;
-        }
-        exitAlternateScreen();
-        console.log(`\n  ${C.sakura}Goodbye. (鞠躬 ~ 谢谢!)${C.reset}\n`);
-        process.exit(0);
-      }
-    }
-  });
+          globalTuiPrompt = tuiPrompt;
+          setupOutputInterception(tuiPrompt, () => isProcessing);
+
+          let health = await client.checkConnection();
+          let catalogOnlyMode = false;
+
+          if (!health.connected) {
+            printRichCard({
+              title: `${client.providerName} Offline`,
+              status: 'offline',
+              lines: [
+                `• Endpoint: ${baseUrl || 'local'} (${health.error || 'unreachable'})`,
+                ...(client.provider === 'lmstudio' ? ['• Action: Attempting auto-start of local LM Studio...'] : []),
+              ],
+            });
+
+            if (client.provider === 'lmstudio') {
+              const autoHealth = await attemptAutoStartLMStudio(baseUrl, opts.model || client.model);
+              if (autoHealth) {
+                health = autoHealth;
+                printRichCard({
+                  title: 'LM Studio Started',
+                  status: 'ok',
+                  lines: [
+                    'Local LM Studio process started and responding.',
+                  ],
+                });
+              } else {
+                catalogOnlyMode = true;
+                printRichCard({
+                  title: 'Catalog-Only Mode',
+                  status: 'catalog',
+                  lines: [
+                    'Direct database & MCP tools remain available without AI synthesis.',
+                    'Start LM Studio and run /model reconnect to enable conversational chat.',
+                  ],
+                });
+              }
+            } else {
+              catalogOnlyMode = true;
+              printRichCard({
+                title: 'Catalog-Only Mode',
+                status: 'catalog',
+                lines: [
+                  'Direct database & MCP tools remain available without AI synthesis.',
+                  'Verify your provider endpoint/key and use /model reconnect.',
+                ],
+              });
+            }
+          }
 
-  globalTuiPrompt = tuiPrompt;
-  setupOutputInterception(tuiPrompt, () => isProcessing);
+          const modelManager = new ModelManager(client, { requestedModel: opts.model || client.model });
+          const modelResolution = catalogOnlyMode
+            ? { connected: false, state: 'catalog_only' }
+            : await modelManager.resolve({ requestedModel: opts.model || client.model });
+          if (!catalogOnlyMode && (!modelResolution.connected || !modelResolution.selectedModel)) {
+            printRichCard({
+              title: 'Model Not Loaded',
+              status: 'warning',
+              lines: [
+                modelResolution.error || 'No chat-capable model loaded',
+                'Load a model in LM Studio, then type /model reconnect.',
+              ],
+            });
+            catalogOnlyMode = true;
+          } else if (!catalogOnlyMode && modelResolution.selectedModel) {
+            tuiPrompt.modelName = modelResolution.selectedModel;
+            printRichCard({
+              title: 'Connected & Ready',
+              status: 'connected',
+              lines: [
+                `• Provider: ${client.providerName}${client.provider === 'lmstudio' ? ' (Local)' : ''}  • Model: ${modelResolution.selectedModel}`,
+                `• Status: Chat & Tool DAG Active  • Tools: ${toolsSchema.length} Loaded`,
+              ],
+            });
+          }
+          if (modelResolution.usedFallback) {
+            printRichCard({
+              title: 'Model Fallback',
+              status: 'warning',
+              lines: [
+                `Requested model ${opts.model} was unavailable.`,
+                `Fallback model ${modelResolution.selectedModel} selected.`,
+              ],
+            });
+          }
 
-  let health = await client.checkConnection();
-  let catalogOnlyMode = false;
+          if (opts.mcp) {
+            try {
+              if (opts.mcp.endsWith('.json')) {
+                await agent.mcpManager.loadConfigFile(opts.mcp);
+                printRichCard({
+                  title: 'MCP Configuration',
+                  status: 'mcp',
+                  lines: [`Loaded MCP configuration from ${opts.mcp}`],
+                });
+              } else {
+                const res = await agent.connectMcp('remote', { url: opts.mcp });
+                printRichCard({
+                  title: 'MCP Connected',
+                  status: 'mcp',
+                  lines: [
+                    `Server: ${opts.mcp}`,
+                    `Tools registered: ${res.toolsCount}`,
+                  ],
+                });
+              }
+            } catch (err) {
+              printRichCard({
+                title: 'MCP Error',
+                status: 'error',
+                lines: [err.message],
+              });
+            }
+          }
 
-  if (!health.connected) {
-    console.log(`  ${C.amber}!! ${client.providerName} offline or unreachable${C.reset}`);
-    console.log(`  ${C.dim}• ${health.error}${C.reset}\n`);
+          await agent._ready;
+
+          const mcpStatus = agent.mcpManager ? agent.mcpManager.getStatus() : null;
+          if (mcpStatus && mcpStatus.activeServersCount > 0 && !opts.mcp) {
+            const serverSummaries = mcpStatus.servers
+              .filter(s => s.status === 'connected')
+              .map(s => `• ${s.name} (${s.type}) — ${s.toolsCount} tools`);
+            printRichCard({
+              title: 'Persisted MCP Connected',
+              status: 'mcp',
+              lines: [
+                `Reconnected ${mcpStatus.activeServersCount} saved MCP server(s):`,
+                ...serverSummaries,
+              ],
+            });
+          }
 
-    if (client.provider === 'lmstudio') {
-      console.log(`  ${C.bold}${C.sakura}Attempting auto-start...${C.reset}`);
-      const autoHealth = await attemptAutoStartLMStudio(baseUrl, opts.model || client.model);
-      if (autoHealth) {
-        health = autoHealth;
-        console.log(`  ${C.emerald}[OK] LM Studio started.${C.reset}\n`);
-      } else {
-        catalogOnlyMode = true;
-        console.log(`  ${C.amber}[CATALOG-ONLY] Kiku will remain available without AI synthesis.${C.reset}\n`);
-      }
-    } else {
-      catalogOnlyMode = true;
-      console.log(`  ${C.amber}[CATALOG-ONLY] Kiku will remain available without AI synthesis.${C.reset}\n`);
-    }
-  }
+          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 modelManager = new ModelManager(client, { requestedModel: opts.model || client.model });
-  const modelResolution = catalogOnlyMode
-    ? { connected: false, state: 'catalog_only' }
-    : await modelManager.resolve({ requestedModel: opts.model || client.model });
-  if (!catalogOnlyMode && (!modelResolution.connected || !modelResolution.selectedModel)) {
-    console.log(`  ${C.amber}[MODEL WARNING] ${modelResolution.error}${C.reset}`);
-    catalogOnlyMode = true;
-    console.log(`  ${C.amber}[CATALOG-ONLY] Load or select a chat model, then use /model reconnect.${C.reset}\n`);
-  }
-  if (modelResolution.selectedModel) {
-    tuiPrompt.modelName = modelResolution.selectedModel;
-  }
-  if (modelResolution.usedFallback) {
-    console.log(`  ${C.amber}[MODEL FALLBACK] Requested ${opts.model}, using ${modelResolution.selectedModel}.${C.reset}\n`);
-  }
+          agent.stateMachine.on('enter:' + AgentStates.FETCHING_TOOL, ({ toolName }) => {
+            if (globalTuiPrompt) {
+              globalTuiPrompt.agentState = `Tool: ${toolName}`;
+              globalTuiPrompt.agentStateTime = Date.now();
+              globalTuiPrompt.render();
+            }
+          });
 
-  if (opts.mcp) {
-    try {
-      if (opts.mcp.endsWith('.json')) {
-        await agent.mcpManager.loadConfigFile(opts.mcp);
-        console.log(`  ${C.emerald}[OK] Loaded MCP configuration from ${opts.mcp}${C.reset}\n`);
-      } else {
-        const res = await agent.connectMcp('remote', { url: opts.mcp });
-        console.log(`  ${C.emerald}[OK] MCP Connected: ${opts.mcp} (${res.toolsCount} Tools)${C.reset}\n`);
-      }
-    } catch (err) {
-      console.log(`  ${C.red}[MCP Error] ${err.message}${C.reset}\n`);
-    }
-  }
+          agent.stateMachine.on('enter:' + AgentStates.STREAMING_THOUGHTS, () => {
+            if (globalTuiPrompt) {
+              globalTuiPrompt.agentState = 'Thinking…';
+              globalTuiPrompt.agentStateTime = Date.now();
+              globalTuiPrompt.render();
+            }
+          });
 
-  await agent._ready;
+          agent.stateMachine.on('enter:' + AgentStates.STREAMING_ANSWER, () => {
+            if (globalTuiPrompt) {
+              globalTuiPrompt.agentState = 'Streaming…';
+              globalTuiPrompt.agentStateTime = Date.now();
+              globalTuiPrompt.render();
+            }
+          });
 
-  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`);
-  }
+          agent.stateMachine.on('enter:' + AgentStates.IDLE, () => {
+            if (globalTuiPrompt) {
+              globalTuiPrompt.agentState = '';
+            }
+          });
 
-  agent.stateMachine.on('enter:' + AgentStates.FETCHING_TOOL, ({ toolName }) => {
-    if (globalTuiPrompt) {
-      globalTuiPrompt.agentState = `Tool: ${toolName}`;
-      globalTuiPrompt.agentStateTime = Date.now();
-    }
-  });
+          const cmdCtx = {
+            tuiPrompt,
+            agent,
+            client,
+            baseUrl,
+            modelManager,
+            catalogOnlyMode,
+            setCatalogOnlyMode: value => { catalogOnlyMode = Boolean(value); },
+            get lastQuery() { return lastQuery; },
+            set lastQuery(value) { lastQuery = value; },
+            printHelp,
+            printQueryDetails,
+            copyQueryDetails,
+            printWelcome: printWelcomeHero,
+            printAd,
+            cancelActiveQuery,
+            enqueueQuery: async (prompt, isRetry) => {
+              queryQueue.push({ id: 'q_' + Date.now(), number: nextQueryNumber++, prompt, addedAt: Date.now() });
+              triggerQueueProcessing();
+            },
+            clearQueryQueue: () => { queryQueue.length = 0; },
+            getQueryQueueLength: () => queryQueue.length,
+            get isProcessing() { return isProcessing; },
+            setIsProcessing: (val, label = '') => {
+              isProcessing = Boolean(val);
+              if (globalTuiPrompt) {
+                globalTuiPrompt.agentState = label || '';
+                if (label) globalTuiPrompt.agentStateTime = Date.now();
+                globalTuiPrompt.render();
+              }
+            },
+            setAgentState: (label, time = Date.now()) => {
+              if (globalTuiPrompt) {
+                globalTuiPrompt.agentState = label || '';
+                globalTuiPrompt.agentStateTime = time;
+                globalTuiPrompt.render();
+              }
+            },
+          };
+
+          const triggerQueueProcessing = () => {
+            if (isProcessing || queryQueue.length === 0) return;
+            isProcessing = true;
+
+            (async () => {
+              try {
+                while (queryQueue.length > 0) {
+                  const nextItem = queryQueue.shift();
+                  activeQueryNumber = nextItem.number;
+                  cmdCtx.lastQuery = nextItem.prompt;
+                  activeAbortController = new AbortController();
+
+                  try {
+                    if (catalogOnlyMode) {
+                      const targetTool = nextItem.prompt.startsWith('@')
+                        ? nextItem.prompt.slice(1).split(/\s+/)[0]
+                        : 'search_works';
+                      const rawArg = nextItem.prompt.startsWith('@')
+                        ? nextItem.prompt.slice(targetTool.length + 1).trim()
+                        : nextItem.prompt;
+
+                      let queryArgs = {};
+                      try { queryArgs = JSON.parse(rawArg); } catch { queryArgs = { query: rawArg }; }
+
+                      let result;
+                      if (agent.mcpManager?.isMcpTool(targetTool)) {
+                        result = await agent.mcpManager.callTool(targetTool, queryArgs);
+                      } else {
+                        result = await executeTool(targetTool, queryArgs);
+                      }
+
+                      const serialized = JSON.stringify(result, null, 2);
+                      printSolidPanel({
+                        title: `Direct Tool Result • ${targetTool} • Q${nextItem.number}`,
+                        lines: serialized.split('\n'),
+                      });
+                    } else {
+                      await executeQueryWithUI(agent, nextItem.prompt, agent.session.thinkingMode === 'show', activeAbortController.signal, nextItem.number);
+                    }
+                  } catch (err) {
+                    if (!isAbortError(err)) {
+                      printRichCard({
+                        title: 'Execution Error',
+                        status: 'error',
+                        lines: [err.message],
+                      });
+                    }
+                  } finally {
+                    activeAbortController = null;
+                    queryCount++;
+                    printAd();
+                    activeQueryNumber = null;
+                    if (globalTuiPrompt) {
+                      globalTuiPrompt.agentState = '';
+                      globalTuiPrompt.render();
+                    }
+                  }
+                }
+              } finally {
+                isProcessing = false;
+                if (globalTuiPrompt) {
+                  globalTuiPrompt.agentState = '';
+                  globalTuiPrompt.render();
+                }
+              }
+            })();
+          };
+
+          while (true) {
+            let rawInput;
+
+            if (deferredCommands.length > 0 && !isProcessing) {
+              rawInput = deferredCommands.shift();
+              printRichCard({
+                title: 'Deferred Command Executed',
+                status: 'info',
+                lines: [rawInput],
+              });
+            } else {
+              rawInput = await tuiPrompt.readLine();
+            }
 
-  agent.stateMachine.on('enter:' + AgentStates.STREAMING_THOUGHTS, () => {
-    if (globalTuiPrompt) {
-      globalTuiPrompt.agentState = 'Thinking…';
-      globalTuiPrompt.agentStateTime = Date.now();
-    }
-  });
+            if (rawInput === null) break;
+            const trimmed = rawInput.trim();
+            if (!trimmed) continue;
 
-  agent.stateMachine.on('enter:' + AgentStates.STREAMING_ANSWER, () => {
-    if (globalTuiPrompt) {
-      globalTuiPrompt.agentState = 'Streaming…';
-      globalTuiPrompt.agentStateTime = Date.now();
-    }
-  });
+            if (trimmed.startsWith('/')) {
+              const lower = trimmed.toLowerCase();
+              if (lower === '/cancel' || lower === '/abort' || (lower === '/stop' && isProcessing)) {
+                cancelActiveQuery();
+                continue;
+              }
 
-  agent.stateMachine.on('enter:' + AgentStates.IDLE, () => {
-    if (globalTuiPrompt) {
-      globalTuiPrompt.agentState = '';
-    }
-  });
+              if (isProcessing) {
+                deferredCommands.push(trimmed);
+                printRichCard({
+                  title: 'Command Queued',
+                  status: 'info',
+                  lines: [`• "${trimmed}" queued to run when active processing finishes.`],
+                });
+                continue;
+              }
 
-  async function processNextQueueItem() {
-    if (isProcessing || queryQueue.length === 0) return;
+              const parts = trimmed.split(/\s+/);
+              const sub = parts[1] || '';
+              const extra = parts.slice(2).join(' ');
+
+              let result;
+              try {
+                result = await routeCommand(trimmed, {
+                  ...cmdCtx,
+                  sub,
+                  extra,
+                  parts,
+                });
+              } catch (cmdErr) {
+                printRichCard({
+                  title: 'Command Error',
+                  status: 'error',
+                  lines: [cmdErr.message || String(cmdErr)],
+                });
+                continue;
+              }
 
-    isProcessing = true;
-    while (queryQueue.length > 0) {
-      const nextItem = queryQueue.shift();
-      lastQuery = nextItem.prompt;
-      activeQueryNumber = nextItem.number;
+              if (result === 'EXIT') {
+                cancelActiveQuery();
+                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: C.bgPanel
+                });
+                queryQueue.push({ id: 'q_' + Date.now(), number: retryNumber, prompt: cmdCtx.lastQuery, addedAt: Date.now() });
+                triggerQueueProcessing();
+              }
+              continue;
+            }
 
-      activeAbortController = new AbortController();
-      try {
-        if (catalogOnlyMode) {
-          let targetTool = 'global_search';
-          let queryArgs = { query: nextItem.prompt };
-          const atMatch = nextItem.prompt.match(/^@([a-zA-Z0-9_-]+)(?:\s+(.*))?$/);
-          if (atMatch) {
-            targetTool = atMatch[1];
-            const rawArg = (atMatch[2] || '').trim();
-            if (rawArg) {
-              try { queryArgs = JSON.parse(rawArg); } catch { queryArgs = { query: rawArg }; }
-            } else {
-              queryArgs = {};
+            const { sanitized, warnings } = sanitizeQuery(trimmed);
+            if (warnings.length > 0) {
+              printRichCard({
+                title: 'Query Warning',
+                status: 'warning',
+                lines: warnings,
+              });
             }
-          }
 
-          let result;
-          if (agent.mcpManager?.isMcpTool(targetTool)) {
-            result = await agent.mcpManager.callTool(targetTool, queryArgs);
-          } else {
-            result = await executeTool(targetTool, queryArgs);
+            const queryNumber = nextQueryNumber++;
+            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: wrapText(trimmed, getFullWidth() - 8).map(wLine => `${C.cyberCyan}❯${C.reset} ${C.white}${wLine}${C.reset}`),
+              bg: C.bgPanel
+            });
+
+            lastQuery = trimmed;
+            queryQueue.push({ id: 'q_' + Date.now(), number: queryNumber, prompt: trimmed, addedAt: Date.now() });
+            triggerQueueProcessing();
           }
 
-          const serialized = JSON.stringify(result, null, 2);
-          printSolidPanel({
-            title: `Direct Tool Result • ${targetTool} • Q${nextItem.number}`,
-            lines: [
-              ...serialized.slice(0, 6000).split('\n'),
-              ...(serialized.length > 6000 ? [`${C.dim}… result truncated${C.reset}`] : []),
-            ],
-          });
-        } else {
-          await executeQueryWithUI(agent, nextItem.prompt, agent.session.thinkingMode === 'show', activeAbortController.signal, nextItem.number);
+          if (globalTuiPrompt) {
+            globalTuiPrompt.dispose();
+            globalTuiPrompt = null;
+          }
+          exitAlternateScreen();
+          console.log(`\n  ${C.sakura}Goodbye. (鞠躬 ~ 谢谢!)${C.reset}\n`);
+          process.exit(0);
         }
-      } finally {
-        activeAbortController = null;
-        queryCount++;
-        printAd();
-        activeQueryNumber = null;
-      }
-    }
-    isProcessing = false;
-  }
-
-  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 = {
-        tuiPrompt,
-        agent,
-        client,
-        baseUrl,
-        modelManager,
-        catalogOnlyMode,
-        setCatalogOnlyMode: value => { catalogOnlyMode = Boolean(value); },
-        sub: trimmed.split(/\s+/)[1] || '',
-        extra: trimmed.split(/\s+/).slice(2).join(' '),
-        parts: trimmed.split(/\s+/),
-        lastQuery,
-        printHelp,
-        printQueryDetails,
-        printWelcome: printWelcomeHero,
-        printAd,
-        enqueueQuery: async (prompt, isRetry) => {
-          queryQueue.push({ id: 'q_' + Date.now(), number: nextQueryNumber++, prompt, addedAt: Date.now() });
-          await 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'
+process.on('exit', () => {
+          try { globalTuiPrompt?.dispose(); } catch { }
+          exitAlternateScreen();
         });
-        queryQueue.push({ id: 'q_' + Date.now(), number: retryNumber, prompt: cmdCtx.lastQuery, addedAt: Date.now() });
-        await 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() });
-    await processNextQueueItem();
-  }
-
-  if (globalTuiPrompt) {
-    globalTuiPrompt.dispose();
-    globalTuiPrompt = null;
-  }
-  exitAlternateScreen();
-  console.log(`\n  ${C.sakura}Goodbye. (鞠躬 ~ 谢谢!)${C.reset}\n`);
-  process.exit(0);
-}
+    process.on('uncaughtException', (err) => {
+      try { globalTuiPrompt?.dispose(); } catch { }
+      exitAlternateScreen();
+      console.error(`\n  Uncaught: ${err.message}`);
+      process.exit(1);
+    });
+    process.on('SIGINT', () => {
+      try { globalTuiPrompt?.dispose(); } catch { }
+      exitAlternateScreen();
+      process.exit(130);
+    });
 
-process.on('exit', () => {
-  try { globalTuiPrompt?.dispose(); } catch {}
-  exitAlternateScreen();
-});
-process.on('uncaughtException', (err) => {
-  try { globalTuiPrompt?.dispose(); } catch {}
-  exitAlternateScreen();
-  console.error(`\n  Uncaught: ${err.message}`);
-  process.exit(1);
-});
-process.on('SIGINT', () => {
-  try { globalTuiPrompt?.dispose(); } catch {}
-  exitAlternateScreen();
-  process.exit(130);
-});
-
-main().catch(err => {
-  exitAlternateScreen();
-  console.error(`\n  ${C.red}Fatal: ${err.message}${C.reset}\n`);
-  process.exit(1);
-});
+    main().catch(err => {
+      exitAlternateScreen();
+      console.error(`\n  ${C.red}Fatal: ${err.message}${C.reset}\n`);
+      process.exit(1);
+    });