kiku-agent 1.0.11 → 1.2.0

package/server/agent/commands.js

@@ -4,16 +4,21 @@ import { ensureYouTubeCookies, resetCookieCheck, getCookieStatus } from './youtu
 import { AgentMemory } from './memory.js';
 import {
   C, UI_ICONS, printSolidPanel, formatTerminalMarkdown, formatMarkdownLines, randomFanName, createProgressRunner, wrapText, getFullWidth, getWelcomeHeroLines, sanitizeTerminalText,
-  formatRichCardLines, printRichCard, printRichStatusCard, formatStatusBadge, formatRichTable, getStringDisplayWidth
+  formatRichCardLines, printRichCard, printRichStatusCard, formatStatusBadge, formatRichTable, getStringDisplayWidth,
+  formatCareerTimelineGraphic, formatDebateMatrix, formatWorkerProgressMatrix, formatExecutiveFindings, getCategoryBadge
 } from './ui.js';
+import { promptInteractiveSuggestion } from './suggestionTui.js';
+import { DebateOrchestrator } from './debate.js';
+import { timelineData } from '../../src/data/timelineData.js';
 import { COMMAND_NAMES, getCommandDetails, findCommandDefinition } from './commandRegistry.js';
 import { THEMES, THEME_NAMES, ansiBackground, ansiForeground, getThemeName, setTheme } from './theme.js';
 import { getGpuMetrics, formatProgressBar } from './gpuMetrics.js';
 import { PACKAGE_NAME, PACKAGE_VERSION } from './version.js';
-import { UpdateError, UpdateManager, UPDATE_CHANNELS } from './updateManager.js';
 import { QUIZ_QUESTIONS, QUIZ_I18N, LETTER_LABELS, shuffleQuizQuestions } from './quizData.js';
 import crypto from 'node:crypto';
+import { isAbortError } from './errors.js';
 import { featureCommandHandlers, aiNarration, languageHint } from './commandFeatures.js';
+import { startWebChatServer, stopWebChatServer, getWebChatServerStatus, openBrowser } from '../webChatServer.js';
 
 function levenshteinDistance(a, b) {
   const matrix = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
@@ -138,8 +143,74 @@ export const handlers = {
     return 'HANDLED';
   },
 
+  '/web': async (ctx) => {
+    const rawAction = (ctx.sub || 'start').toLowerCase();
+    const extraPort = Number(ctx.extra || (ctx.sub && /^\d+$/.test(ctx.sub) ? ctx.sub : null)) || 3300;
+
+    if (rawAction === 'stop' || rawAction === 'close') {
+      const stopped = await stopWebChatServer();
+      const msg = stopped
+        ? `  ${C.emerald}[OK] Standalone web chatbot server stopped.${C.reset}`
+        : `  ${C.slate}Standalone web chatbot server was not running.${C.reset}`;
+      if (ctx.tuiPrompt?.addViewportLines) ctx.tuiPrompt.addViewportLines(msg);
+      else console.log(`\n${msg}\n`);
+      return 'HANDLED';
+    }
+
+    if (rawAction === 'status' || rawAction === 'info') {
+      const status = getWebChatServerStatus();
+      const lines = [
+        `• Status: ${status.running ? `${C.emerald}Running${C.reset}` : `${C.slate}Stopped${C.reset}`}`,
+        `• URL: ${status.running ? `${C.cyberCyan}${status.url}${C.reset}` : `${C.dim}${status.url}${C.reset}`}`,
+        `• Port: ${status.port}`,
+        `• Provider: ${status.provider || 'lmstudio'}`,
+        `• Model: ${status.model || 'google/gemma-4-e4b'}`,
+      ];
+      printRichCard({
+        title: 'Standalone Web Chatbot Status',
+        status: status.running ? 'ok' : 'info',
+        lines,
+      });
+      return 'HANDLED';
+    }
+
+    if (rawAction === 'restart') {
+      await stopWebChatServer();
+    }
+
+    const port = extraPort >= 1000 ? extraPort : 3300;
+    const res = await startWebChatServer({ port, agent: ctx.agent });
+    openBrowser(res.url);
+
+    const lines = [
+      `• Dedicated Web Chatbot started on ${C.bold}${C.cyberCyan}${res.url}${C.reset}`,
+      `• Running as an independent web application on Port ${res.port}.`,
+      `• Browser opened automatically.`,
+      `• To stop the web server, type ${C.cyberCyan}/web stop${C.reset}`,
+    ];
+
+    printRichCard({
+      title: 'Standalone Web Chatbot Launched',
+      status: 'ok',
+      lines,
+    });
+
+    return 'HANDLED';
+  },
+
+  '/web-chat': async (ctx) => handlers['/web'](ctx),
+
   '/details': async (ctx) => {
-    ctx.printQueryDetails([ctx.sub, ctx.extra].filter(Boolean).join(' '));
+    if (typeof ctx.printQueryDetails === 'function') {
+      ctx.printQueryDetails([ctx.sub, ctx.extra].filter(Boolean).join(' '));
+      return 'HANDLED';
+    }
+    const { formatQueryDetails, parseDetailsRequest } = await import('./queryDetails.js');
+    const reference = [ctx.sub, ctx.extra].filter(Boolean).join(' ');
+    const request = parseDetailsRequest(reference);
+    const details = ctx.agent?.lastQueryDetails || ctx.agent?._lastQueryDetails || null;
+    const formatted = formatQueryDetails(details, request, ctx.agent?.session);
+    console.log(`\n${formatted}\n`);
     return 'HANDLED';
   },
 
@@ -219,6 +290,7 @@ export const handlers = {
     ctx.setIsProcessing?.(true, `Subagent: ${task.slice(0, 24)}`);
     try {
       const result = await ctx.agent.runSubagent(task, {
+        signal: ctx.signal,
         onProgress: event => {
           if (event.type === 'iteration') {
             console.log(`  ${C.dim}[ITERATION ${event.iteration}/${event.maxIterations}]...${C.reset}`);
@@ -231,6 +303,23 @@ export const handlers = {
       const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
       ctx.agent._lastSubagentResult = result;
 
+      ctx.recordQueryDiagnostics?.({
+        prompt: task,
+        answer: result.answer,
+        thinking: result.thinking || '',
+        tools: result.toolCalls?.map((tc, idx) => ({
+          name: tc.name || 'tool',
+          args: tc.args || {},
+          result: tc.result || { status: 'ok' },
+          duration: tc.duration || 0,
+        })) || [],
+        status: 'complete',
+        iterations: result.iterations || (result.toolCalls?.length ? 1 : 0),
+        startedAt: startTime,
+        completedAt: Date.now(),
+        durationMs: Date.now() - startTime,
+      });
+
       const lines = [
         `${C.bold}${C.emerald}[DONE] Subagent completed in ${elapsed}s with ${result.toolCalls.length} tool calls.${C.reset}`,
         ''
@@ -257,7 +346,9 @@ export const handlers = {
         lines,
       });
     } catch (error) {
-      console.log(`\n  ${C.red}[SUBAGENT ERROR] ${error.message}${C.reset}\n`);
+      if (!isAbortError(error)) {
+        console.log(`\n  ${C.red}[SUBAGENT ERROR] ${error.message}${C.reset}\n`);
+      }
     } finally {
       ctx.setIsProcessing?.(false);
     }
@@ -356,6 +447,7 @@ export const handlers = {
     ctx.setIsProcessing?.(true, `Research: ${question.slice(0, 24)}`);
     try {
       const result = await ctx.agent.runResearch(question, {
+        signal: ctx.signal,
         onProgress: event => {
           if (event.type === 'worker-start') console.log(`  ${C.dim}▸ Worker started: ${event.label}${C.reset}`);
           if (event.type === 'worker-complete') console.log(`  ${C.emerald}[OK] Worker finished: ${event.label}${C.reset}`);
@@ -363,6 +455,24 @@ export const handlers = {
       });
 
       const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
+      const allWorkerTools = (result.reports || []).flatMap(r => r.toolCalls || []).map((tc, idx) => ({
+        name: typeof tc === 'string' ? tc : (tc.name || 'tool'),
+        args: typeof tc === 'object' && tc.args ? tc.args : {},
+        result: typeof tc === 'object' && tc.result ? tc.result : { status: 'ok' },
+        duration: typeof tc === 'object' && tc.duration ? tc.duration : 0,
+      }));
+
+      ctx.recordQueryDiagnostics?.({
+        prompt: question,
+        answer: result.answer,
+        tools: allWorkerTools,
+        status: 'complete',
+        iterations: (result.reports || []).length || 1,
+        startedAt: startTime,
+        completedAt: Date.now(),
+        durationMs: Date.now() - startTime,
+      });
+
       const lines = [
         `${C.bold}${C.emerald}[DONE] Research synthesis completed in ${elapsed}s across 3 workers.${C.reset}`,
         '',
@@ -378,7 +488,9 @@ export const handlers = {
         lines
       });
     } catch (error) {
-      console.log(`\n  ${C.red}[RESEARCH ERROR] ${error.message}${C.reset}\n`);
+      if (!isAbortError(error)) {
+        console.log(`\n  ${C.red}[RESEARCH ERROR] ${error.message}${C.reset}\n`);
+      }
     } finally {
       ctx.setIsProcessing?.(false);
     }
@@ -416,10 +528,28 @@ export const handlers = {
     const startTime = Date.now();
     ctx.setIsProcessing?.(true, `Verifying: ${claim.slice(0, 24)}`);
     try {
-      const result = await ctx.agent.runResearch(claim, { mode: 'verify' });
+      const result = await ctx.agent.runResearch(claim, { mode: 'verify', signal: ctx.signal });
       const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
       const answerStr = String(result.answer || '');
 
+      const allWorkerTools = (result.reports || []).flatMap(r => r.toolCalls || []).map((tc, idx) => ({
+        name: typeof tc === 'string' ? tc : (tc.name || 'tool'),
+        args: typeof tc === 'object' && tc.args ? tc.args : {},
+        result: typeof tc === 'object' && tc.result ? tc.result : { status: 'ok' },
+        duration: typeof tc === 'object' && tc.duration ? tc.duration : 0,
+      }));
+
+      ctx.recordQueryDiagnostics?.({
+        prompt: `/verify ${claim}`,
+        answer: answerStr,
+        tools: allWorkerTools,
+        status: 'complete',
+        iterations: (result.reports || []).length || 1,
+        startedAt: startTime,
+        completedAt: Date.now(),
+        durationMs: Date.now() - startTime,
+      });
+
       let verdictBadge = `${C.amber}[UNVERIFIED / AMBIGUOUS]`;
       if (/VERIFIED|จริง|ถูกต้อง|ยืนยันแล้ว|CONFIRMED/i.test(answerStr) && !/UNVERIFIED|FALSE|เท็จ|ไม่จริง/i.test(answerStr.slice(0, 80))) {
         verdictBadge = `${C.emerald}${C.bold}[VERIFIED / FACTUAL]${C.reset}`;
@@ -444,7 +574,9 @@ export const handlers = {
         lines
       });
     } catch (error) {
-      console.log(`\n  ${C.red}[VERIFY ERROR] ${error.message}${C.reset}\n`);
+      if (!isAbortError(error)) {
+        console.log(`\n  ${C.red}[VERIFY ERROR] ${error.message}${C.reset}\n`);
+      }
     } finally {
       ctx.setIsProcessing?.(false);
     }
@@ -452,11 +584,152 @@ export const handlers = {
   },
 
   '/sources': async (ctx) => {
-    const latest = ctx.agent.getResearchStatus().lastResult;
-    printSolidPanel({
-      title: 'Latest Research Sources',
-      lines: latest?.sources?.length ? latest.sources.map((url, index) => `${C.gold}[${index + 1}]${C.reset} ${C.cyberCyan}${url}${C.reset}`) : [`${C.dim}No research sources recorded.${C.reset}`],
+    if (ctx.agent?.lastCitations?.length > 0) {
+      const lines = ctx.agent.lastCitations.map(c => {
+        const meta = [c.category, c.year, c.tool].filter(Boolean).join(' • ');
+        const urlStr = c.url ? ` ${C.cyberCyan}${c.url}${C.reset}` : '';
+        return `${C.gold}[${c.id}]${C.reset} ${C.bold}${c.title}${C.reset} ${C.dim}(${meta})${C.reset}${urlStr}`;
+      });
+      printSolidPanel({
+        title: `Grounded Sources & Citations • ${ctx.agent.lastCitations.length} sources`,
+        lines
+      });
+      return 'HANDLED';
+    }
+    return handlers['/research']({ ...ctx, sub: 'sources' });
+  },
+
+  '/debate': async (ctx) => {
+    const rawAction = (ctx.sub || '').trim();
+    const extra = (ctx.extra || '').trim();
+    const fullQuery = `${rawAction} ${extra}`.trim();
+
+    if (!fullQuery || fullQuery === 'help') {
+      console.log(`\n  ${C.bold}Usage:${C.reset} /debate <topic or claim> | /debate status | /debate last\n`);
+      return 'HANDLED';
+    }
+
+    if (rawAction.toLowerCase() === 'status') {
+      const status = ctx.agent?.debateOrchestrator?.getStatus?.() || { state: 'idle' };
+      printRichCard({
+        title: `Debate Status • ${status.state.toUpperCase()}`,
+        status: status.state === 'running' ? 'autostart' : 'info',
+        lines: [
+          status.state === 'running' ? `Active Topic: ${status.topic}` : 'No debate job is currently running.',
+        ],
+      });
+      return 'HANDLED';
+    }
+
+    if (rawAction.toLowerCase() === 'last') {
+      const last = ctx.agent?.debateOrchestrator?.getStatus?.()?.lastResult;
+      if (!last) {
+        console.log(`\n  ${C.amber}No previous debate results recorded.${C.reset}\n`);
+        return 'HANDLED';
+      }
+      const lines = formatDebateMatrix(last, getFullWidth());
+      console.log(`\n${lines.join('\n')}\n`);
+      return 'HANDLED';
+    }
+
+    if (rawAction.toLowerCase() === 'cancel' || rawAction.toLowerCase() === 'abort') {
+      const cancelled = ctx.agent?.debateOrchestrator?.cancel?.();
+      console.log(`\n  ${cancelled ? C.emerald + '[OK] Cancelled active debate job.' : C.amber + 'No active debate job to cancel.'}${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    const debateOrchestrator = ctx.agent?.debateOrchestrator || new DebateOrchestrator({
+      client: ctx.agent?.client || ctx.agent?.llmClient,
+      executeTool: (name, args) => ctx.agent?.executeTool?.(name, args) || executeTool(name, args),
     });
+    if (ctx.agent) ctx.agent.debateOrchestrator = debateOrchestrator;
+
+    printRichCard({
+      title: 'Initiating Adversarial Fact Debate',
+      status: 'autostart',
+      lines: [
+        `• Topic / Claim: "${fullQuery}"`,
+        '• Dispatching Advocate and Skeptic subagents with verified sources...',
+      ],
+    });
+
+    const startTime = Date.now();
+    ctx.setIsProcessing?.(true, `Debating: ${fullQuery.slice(0, 24)}`);
+
+    try {
+      const result = await debateOrchestrator.run(fullQuery, {
+        signal: ctx.signal,
+        onProgress: event => {
+          if (event.type === 'worker-start') {
+            ctx.setAgentState?.(`Debating • ${event.id === 'advocate' ? 'Advocate' : 'Critic'}`);
+            if (ctx.tuiPrompt?.addViewportLines) {
+              ctx.tuiPrompt.addViewportLines(`  ${C.cyberCyan}▸ Debate Worker Started:${C.reset} ${C.bold}${event.label}${C.reset}`);
+            }
+          } else if (event.type === 'synthesizing') {
+            ctx.setAgentState?.('Synthesizing Verdict…');
+            if (ctx.tuiPrompt?.addViewportLines) {
+              ctx.tuiPrompt.addViewportLines(`  ${C.gold}✦ Synthesizing Neutral Judge Verdict...${C.reset}`);
+            }
+          }
+        },
+      });
+
+      const lines = formatDebateMatrix(result, getFullWidth());
+      if (ctx.tuiPrompt?.addViewportLines) {
+        ctx.tuiPrompt.addViewportLines(lines);
+      } else {
+        console.log(`\n${lines.join('\n')}\n`);
+      }
+    } catch (error) {
+      if (!isAbortError(error)) {
+        if (ctx.tuiPrompt?.addViewportLines) {
+          ctx.tuiPrompt.addViewportLines(`  ${C.red}[DEBATE ERROR] ${error.message}${C.reset}`);
+        } else {
+          console.log(`\n  ${C.red}[DEBATE ERROR] ${error.message}${C.reset}\n`);
+        }
+      }
+    } finally {
+      ctx.setIsProcessing?.(false);
+    }
+    return 'HANDLED';
+  },
+
+  '/timeline': async (ctx) => {
+    const rawFilter = `${ctx.sub || ''} ${ctx.extra || ''}`.trim().toLowerCase();
+    let items = [...timelineData];
+
+    if (rawFilter) {
+      if (/^\d{4}$/.test(rawFilter)) {
+        items = items.filter(t => t.year === rawFilter);
+      } else if (/^\d{4}-\d{4}$/.test(rawFilter)) {
+        const [startY, endY] = rawFilter.split('-').map(Number);
+        items = items.filter(t => {
+          const y = Number(t.year);
+          return !isNaN(y) && y >= startY && y <= endY;
+        });
+      } else {
+        items = items.filter(t =>
+          (t.era && t.era.toLowerCase().includes(rawFilter)) ||
+          (t.category && t.category.toLowerCase().includes(rawFilter)) ||
+          (t.title && t.title.toLowerCase().includes(rawFilter)) ||
+          (t.summary && t.summary.toLowerCase().includes(rawFilter))
+        );
+      }
+    }
+
+    if (items.length === 0) {
+      const msg = `  ${C.amber}No career timeline milestones found matching "${rawFilter}".${C.reset}`;
+      if (ctx.tuiPrompt?.addViewportLines) ctx.tuiPrompt.addViewportLines(msg);
+      else console.log(`\n${msg}\n`);
+      return 'HANDLED';
+    }
+
+    const lines = formatCareerTimelineGraphic(items, getFullWidth());
+    if (ctx.tuiPrompt?.addViewportLines) {
+      ctx.tuiPrompt.addViewportLines(lines);
+    } else {
+      console.log(`\n${lines.join('\n')}\n`);
+    }
     return 'HANDLED';
   },
 
@@ -480,6 +753,7 @@ export const handlers = {
       ctx.setIsProcessing?.(true, `Suggestions: ${targets.slice(0, 20)}`);
       try {
         const batchResult = await ctx.agent.runSuggestionBatch(targets, {
+          signal: ctx.signal,
           onProgress: event => {
             if (event.type === 'worker-start') {
               console.log(`  ${C.cyberCyan}▸ Worker ${event.index} Started:${C.reset} ${C.bold}${event.label}${C.reset} — ${C.dim}${event.question}${C.reset}`);
@@ -501,36 +775,41 @@ export const handlers = {
           ],
         });
 
-        for (const res of batchResult.results) {
-          if (res.answer) {
-            const answerLines = formatMarkdownLines(res.answer);
-            printSolidPanel({
-              title: `[Worker ${res.index}] ${res.category} • ${res.question}`,
-              lines: [
-                `${C.bold}${C.cyberCyan}Question:${C.reset} ${res.question}`,
-                `${C.dim}Tool calls: ${res.toolCalls?.length || 0} • Iterations: ${res.iterations || 1}${C.reset}`,
-                '',
-                `${C.bold}${C.roseGlow}Findings:${C.reset}`,
-                ...answerLines,
-              ],
-            });
-          } else {
-            printRichCard({
-              title: `Worker ${res.index} Failed: ${res.category}`,
-              status: 'error',
-              lines: [
-                `Question: ${res.question}`,
-                `Error: ${res.error || 'Failed to research'}`,
-              ],
-            });
-          }
+        const allTools = (batchResult.results || []).flatMap(r => r.toolCalls || []).map(tc => ({
+          name: typeof tc === 'string' ? tc : (tc.name || 'tool'),
+          args: typeof tc === 'object' && tc.args ? tc.args : {},
+          result: typeof tc === 'object' && tc.result ? tc.result : { status: 'ok' },
+          duration: typeof tc === 'object' && tc.duration ? tc.duration : 0,
+        }));
+
+        const combinedAnswers = (batchResult.results || [])
+          .filter(r => Boolean(r.answer))
+          .map(r => `### [Worker ${r.index}] ${r.category} • ${r.question}\n${r.answer}`)
+          .join('\n\n') || '';
+
+        ctx.recordQueryDiagnostics?.({
+          prompt: `/suggestion run ${targets}`,
+          answer: combinedAnswers,
+          tools: allTools,
+          status: batchResult.successfulCount > 0 ? 'complete' : 'error',
+          iterations: batchResult.tasksCount || 1,
+          startedAt: startTime,
+          completedAt: Date.now(),
+          durationMs: Date.now() - startTime,
+        });
+
+        const findingLines = formatExecutiveFindings({ batchResult, termWidth: getFullWidth() });
+        for (const line of findingLines) {
+          console.log(line);
         }
       } catch (err) {
-        printRichCard({
-          title: 'Batch Subagent Error',
-          status: 'error',
-          lines: [err.message],
-        });
+        if (!isAbortError(err)) {
+          printRichCard({
+            title: 'Batch Subagent Error',
+            status: 'error',
+            lines: [err.message],
+          });
+        }
       } finally {
         ctx.setIsProcessing?.(false);
       }
@@ -558,14 +837,42 @@ export const handlers = {
         topic: topicName,
         limit: 5,
       });
+      ctx.setIsProcessing?.(false);
 
+    
+      const isInteractiveTty = Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.KIKU_PLAIN && ctx.readInput);
+
+      if (isInteractiveTty && !isTopic && (rawAction === 'list' || !rawAction)) {
+        const selected = await promptInteractiveSuggestion(suggestions, {
+          stdin: process.stdin,
+          stdout: process.stdout,
+          signal: ctx.signal,
+        });
+
+        if (selected.action === 'run' && selected.targets) {
+          return handlers['/suggestion']({ ...ctx, sub: 'run', extra: selected.targets });
+        }
+        if (selected.action === 'refresh') {
+          return handlers['/suggestion']({ ...ctx, sub: 'list', extra: '' });
+        }
+        if (selected.action === 'cancel') {
+          return 'HANDLED';
+        }
+      }
+
+     
       const cardLines = [
         `${C.dim}Explore exciting Ju Jingyi topics with concurrent subagents:${C.reset}`,
         '',
-        ...suggestions.flatMap((s) => [
-          `  ${C.bold}${C.gold}[${s.id}]${C.reset} ${C.bold}${C.cyberCyan}[${s.category}]${C.reset} ${C.white}${s.question}${C.reset}`,
-          `      ${C.dim}↳ ${s.description}${C.reset}`,
-        ]),
+        ...suggestions.flatMap((s, idx) => {
+          const badge = getCategoryBadge(s.category);
+          return [
+            `  ${C.bold}${C.gold}[${s.id}]${C.reset} ${badge.color}[${badge.icon} ${badge.label}]${C.reset} ${C.bold}${C.white}${s.question}${C.reset}`,
+            `      ${C.dim}↳ ${s.description}${C.reset}`,
+            `      ${C.slate}Tools: ${(s.tools || []).join(', ')}   •   Est: ~${s.estimatedSeconds || 2}s   •   Depth: ${s.depth || 'Standard'}${C.reset}`,
+            ...(idx < suggestions.length - 1 ? [''] : []),
+          ];
+        }),
         '',
         `${C.bold}${C.roseGlow}Quick Execution Tips:${C.reset}`,
         `  • Run one task: ${C.white}/suggestion run 1${C.reset}`,
@@ -927,19 +1234,22 @@ export const handlers = {
       let exported;
       if (format === 'json') {
         exported = await agent.session.exportToJson();
+      } else if (format === 'html' || format === 'web') {
+        exported = await agent.session.exportToHtml();
       } else if (format === 'text' || format === 'txt') {
         exported = await agent.session.exportToText();
       } else {
         exported = await agent.session.exportToMarkdown();
       }
 
+      const fmt = (exported?.format || (format === 'json' ? 'JSON' : format === 'html' || format === 'web' ? 'HTML' : format === 'text' || format === 'txt' ? 'TEXT' : 'MARKDOWN')).toUpperCase();
       printRichCard({
         title: 'Session Exported Successfully',
         status: 'ok',
         lines: [
-          `• Format:   ${exported.format.toUpperCase()}`,
-          `• File:     ${exported.filePath}`,
-          `• Size:     ${(exported.size || 0).toLocaleString()} bytes`,
+          `• Format:   ${fmt}`,
+          `• File:     ${exported?.filePath || 'Export generated'}`,
+          `• Size:     ${(exported?.size || 0).toLocaleString()} bytes`,
         ],
       });
       return 'HANDLED';
@@ -1048,15 +1358,7 @@ export const handlers = {
       ctx.tuiPrompt.render();
     }
 
-    printSolidPanel({
-      title: 'Theme Updated',
-      lines: [
-        `${C.emerald}[OK] Active theme: ${C.bold}${theme.label} (${requested})${C.reset}`,
-        `${C.dim}${theme.description}${C.reset}`,
-        `${C.sakura}Primary${C.reset}  ${C.roseGlow}Accent${C.reset}  ${C.cyberCyan}Info${C.reset}  ${C.emerald}Success${C.reset}  ${C.amber}Warning${C.reset}  ${C.red}Error${C.reset}`,
-        `${C.dim}Saved for future Kiku Agent sessions.${C.reset}`,
-      ],
-    });
+    console.log(`\n  ${C.sakura}◆${C.reset} Active theme: ${C.bold}${theme.label}${C.reset} ${C.dim}(${requested})${C.reset}\n`);
     return 'HANDLED';
   },
 
@@ -1368,17 +1670,12 @@ export const handlers = {
   },
 
   '/save': async (ctx) => {
-    try {
-      const exported = await ctx.agent.session.exportToMarkdown();
-      console.log(`\n  ${C.emerald}[OK] Exported.${C.reset} ${C.white}${exported.filePath}${C.reset}\n`);
-    } catch (err) {
-      console.log(`\n  ${C.red}[SAVE ERROR] ${err.message || String(err)}${C.reset}\n`);
-    }
-    return 'HANDLED';
+    const fmt = ctx.sub || ctx.extra || 'markdown';
+    return handlers['/session']({ ...ctx, sub: 'export', extra: fmt });
   },
 
   '/provider': async (ctx) => {
-    const { CLOUD_PROVIDERS, getProvider, getRecommendedModels } = await import('./config.js');
+    const { CLOUD_PROVIDERS, getProvider, getRecommendedModels, isProviderKeyPersistenceEnabled } = await import('./config.js');
     const action = (ctx.sub || 'status').toLowerCase();
     const parts = ctx.parts || [];
 
@@ -1574,7 +1871,10 @@ export const handlers = {
       const masked = newKey.length > 8
         ? `${newKey.slice(0, 4)}...${newKey.slice(-4)}`
         : '****';
-      console.log(`\n  ${C.emerald}[OK] API key saved & persisted for ${targetProvider}${C.reset} (${masked})\n`);
+      const persistenceLabel = isProviderKeyPersistenceEnabled()
+        ? 'saved with encrypted persistence'
+        : 'saved in memory only (set KIKU_PROVIDER_KEY_ENCRYPTION_KEY to persist)';
+      console.log(`\n  ${C.emerald}[OK] API key ${persistenceLabel} for ${targetProvider}${C.reset} (${masked})\n`);
       return 'HANDLED';
     }
 
@@ -1653,12 +1953,25 @@ export const handlers = {
       : await ctx.client.checkConnection();
 
     if (action === 'list') {
-      const serverModels = (liveCheck.models || []).slice(0, 40).map(id => `${id === ctx.client.model ? '[x]' : '[ ]'} ${id}`);
+      const activeLoaded = liveCheck.activeLoadedModel;
+      const serverModels = (liveCheck.models || []).slice(0, 40).map(id => {
+        const isCurrent = id === ctx.client.model;
+        const isLoaded = id === activeLoaded || (liveCheck.loadedModels && liveCheck.loadedModels.includes(id));
+        const badge = isCurrent ? `${C.gold}[x]${C.reset}` : `${C.dim}[ ]${C.reset}`;
+        const loadTag = isLoaded ? ` ${C.emerald}(Loaded in VRAM)${C.reset}` : '';
+        return `${badge} ${C.white}${id}${C.reset}${loadTag}`;
+      });
       const recs = getRecommendedModels(ctx.client.provider);
       const recLines = recs.length > 0
         ? [
-            `${C.bold}${C.lavender}Recommended Active Models:${C.reset}`,
-            ...recs.map(m => `  ${m.id === ctx.client.model ? C.gold + '[x]' : C.dim + '[ ]'} ${C.white}${m.id}${C.reset} ${C.dim}(${m.cost} • ${m.tier})${C.reset}`),
+            `${C.bold}${C.lavender}Recommended Active Models / Quantizations:${C.reset}`,
+            ...recs.map(m => {
+              const isCurrent = m.id === ctx.client.model || (ctx.client.model && ctx.client.model.includes(m.id.replace('google/', '')));
+              const isLoaded = activeLoaded && activeLoaded.includes(m.id.replace('google/', ''));
+              const marker = isCurrent ? `${C.gold}[x]${C.reset}` : `${C.dim}[ ]${C.reset}`;
+              const loadTag = isLoaded ? ` ${C.emerald}● VRAM Ready${C.reset}` : '';
+              return `  ${marker} ${C.white}${m.id.padEnd(28)}${C.reset} ${C.dim}(${m.cost} • ${m.tier})${C.reset}${loadTag}`;
+            }),
             ''
           ]
         : [];
@@ -1670,7 +1983,7 @@ export const handlers = {
           `${C.bold}${C.lavender}Reported by Server:${C.reset}`,
           ...(serverModels.length ? serverModels.map(s => `  ${s}`) : [`  ${C.dim}No live model list reported by ${providerName}.${C.reset}`]),
           '',
-          `${C.dim}Select model: /model use <model_id> or /model <provider_or_model>${C.reset}`
+          `${C.dim}Select model: /model use <model_id> or /model use <Q8_0|Q6_K|Q4_K_M>${C.reset}`
         ],
       });
       return 'HANDLED';
@@ -1683,14 +1996,16 @@ export const handlers = {
       try {
         const lowerTarget = targetModel.toLowerCase();
 
-        
         if (CLOUD_PROVIDERS[lowerTarget]) {
           return await handlers['/provider']({ ...ctx, sub: 'use', extra: lowerTarget, parts: ['/provider', 'use', lowerTarget] });
         }
 
-       
         let matchedProvider = null;
-        if (lowerTarget.includes('gemma') || lowerTarget === 'google/gemma-4-e4b') {
+        if (
+          lowerTarget.includes('gemma') ||
+          lowerTarget === 'google/gemma-4-e4b' ||
+          /^(q[0-9]|8bit|6bit|4bit|fp16)/i.test(lowerTarget)
+        ) {
           matchedProvider = 'lmstudio';
         } else {
           for (const [pId, pDef] of Object.entries(CLOUD_PROVIDERS)) {
@@ -1708,9 +2023,19 @@ export const handlers = {
 
         if (ctx.modelManager) {
           const selected = ctx.modelManager.select(targetModel, liveCheck.models || []);
+          if (ctx.tuiPrompt) {
+            ctx.tuiPrompt.modelName = selected;
+            ctx.tuiPrompt.isConnected = true;
+            ctx.tuiPrompt.render();
+          }
           console.log(`\n  ${C.emerald}[OK] Active model changed to ${selected}.${C.reset}\n`);
         } else {
           ctx.client.setModel(targetModel);
+          if (ctx.tuiPrompt) {
+            ctx.tuiPrompt.modelName = targetModel;
+            ctx.tuiPrompt.isConnected = true;
+            ctx.tuiPrompt.render();
+          }
           console.log(`\n  ${C.emerald}[OK] Active model changed to ${targetModel}.${C.reset}\n`);
         }
       } catch (error) {
@@ -2001,17 +2326,122 @@ export const handlers = {
     return 'HANDLED';
   },
 
+  '/profile': async (ctx) => {
+    const { listProfiles, getProfile, setActiveProfile, createOrUpdateProfile, deleteProfile, getActiveProfile } = await import('./profiles.js');
+    const action = (ctx.sub || 'list').toLowerCase();
+    const parts = ctx.parts || [];
+
+    if (action === 'list' || (action === 'show' && !ctx.extra)) {
+      const profiles = listProfiles();
+      const lines = profiles.map(p => {
+        const marker = p.isActive ? `${C.emerald}* [ACTIVE]${C.reset}` : `  [      ]`;
+        const nameCol = `${C.bold}${C.cyberCyan}${p.name.padEnd(16)}${C.reset}`;
+        const provCol = `${C.white}${(p.provider || 'lmstudio').padEnd(12)}${C.reset}`;
+        const modelCol = `${C.lavender}${(p.model || '').padEnd(26)}${C.reset}`;
+        const thinkCol = p.thinking === 'show' ? `${C.emerald}think:on${C.reset}` : `${C.dim}think:off${C.reset}`;
+        return `${marker} ${nameCol} ${provCol} ${modelCol} ${thinkCol}`;
+      });
+
+      printSolidPanel({
+        title: `Configuration Profiles (${profiles.length})`,
+        lines: [
+          ...lines,
+          '',
+          `${C.dim}Usage: /profile use <name> | /profile show <name> | /profile save <name>${C.reset}`
+        ],
+      });
+      return 'HANDLED';
+    }
+
+    if (action === 'use' || action === 'switch') {
+      const targetName = (parts[2] || ctx.extra || '').trim();
+      if (!targetName) {
+        console.log(`\n  ${C.amber}Usage: /profile use <profile_name>${C.reset}\n`);
+        return 'HANDLED';
+      }
+      try {
+        const profile = setActiveProfile(targetName);
+        if (ctx.client && profile.provider) {
+          ctx.client.switchProvider(profile.provider, { model: profile.model });
+        }
+        if (ctx.agent) {
+          if (profile.thinking) ctx.agent.session.thinkingMode = profile.thinking;
+        }
+        if (ctx.tuiPrompt) {
+          ctx.tuiPrompt.modelName = profile.model;
+          ctx.tuiPrompt.providerName = profile.provider;
+          ctx.tuiPrompt.render();
+        }
+        console.log(`\n  ${C.emerald}[OK] Switched to profile "${profile.name}" (${profile.provider} / ${profile.model})${C.reset}\n`);
+      } catch (err) {
+        console.log(`\n  ${C.red}[PROFILE ERROR] ${err.message}${C.reset}\n`);
+      }
+      return 'HANDLED';
+    }
+
+    if (action === 'save') {
+      const targetName = (parts[2] || ctx.extra || '').trim();
+      if (!targetName) {
+        console.log(`\n  ${C.amber}Usage: /profile save <profile_name>${C.reset}\n`);
+        return 'HANDLED';
+      }
+      try {
+        const currentProvider = ctx.client?.provider || 'lmstudio';
+        const currentModel = ctx.client?.model || 'google/gemma-4-e4b';
+        const currentThinking = ctx.agent?.session?.thinkingMode || 'show';
+        const saved = createOrUpdateProfile(targetName, {
+          provider: currentProvider,
+          model: currentModel,
+          thinking: currentThinking,
+          description: `Custom profile created from active session`
+        });
+        console.log(`\n  ${C.emerald}[OK] Saved profile "${saved.name}" (${saved.provider} / ${saved.model})${C.reset}\n`);
+      } catch (err) {
+        console.log(`\n  ${C.red}[PROFILE ERROR] ${err.message}${C.reset}\n`);
+      }
+      return 'HANDLED';
+    }
+
+    if (action === 'delete' || action === 'del') {
+      const targetName = (parts[2] || ctx.extra || '').trim();
+      if (!targetName) {
+        console.log(`\n  ${C.amber}Usage: /profile delete <profile_name>${C.reset}\n`);
+        return 'HANDLED';
+      }
+      try {
+        deleteProfile(targetName);
+        console.log(`\n  ${C.emerald}[OK] Deleted profile "${targetName}".${C.reset}\n`);
+      } catch (err) {
+        console.log(`\n  ${C.red}[PROFILE ERROR] ${err.message}${C.reset}\n`);
+      }
+      return 'HANDLED';
+    }
+
+    return 'HANDLED';
+  },
+
   '/config': async (ctx) => {
-    const { config } = await import('./config.js');
+    const { getActiveProfile } = await import('./profiles.js');
+    if (ctx.sub === 'list' || ctx.sub === 'profiles') {
+      return handlers['/profile'](ctx);
+    }
+    if (ctx.sub === 'use') {
+      return handlers['/profile'](ctx);
+    }
+    const activeProf = getActiveProfile();
     printSolidPanel({
       title: `Configuration`,
       lines: [
-        `${C.gold}URL:${C.reset}      ${C.cyberCyan}${ctx.baseUrl}${C.reset}`,
+        `${C.gold}Profile:${C.reset}   ${C.bold}${C.emerald}${activeProf.name}${C.reset} ${C.dim}(${activeProf.description || ''})${C.reset}`,
+        `${C.gold}Provider:${C.reset}  ${C.white}${ctx.client.providerName || ctx.client.provider || 'LM Studio'}${C.reset}`,
         `${C.gold}Model:${C.reset}     ${C.white}${ctx.client.model}${C.reset}`,
+        `${C.gold}Thinking:${C.reset}  ${C.white}${ctx.agent?.session?.thinkingMode || 'show'}${C.reset}`,
         `${C.gold}Theme:${C.reset}     ${C.white}${getThemeName()}${C.reset}`,
-        `${C.gold}Max Iters:${C.reset} ${C.white}${ctx.agent.maxIterations}${C.reset}`,
-        `${C.gold}Window:${C.reset}    ${C.white}${ctx.agent.slidingWindowSize}${C.reset}`,
-        `${C.gold}Tools:${C.reset}     ${C.cyberCyan}${toolsSchema.length}${C.reset}`
+        `${C.gold}Max Iters:${C.reset} ${C.white}${ctx.agent?.maxIterations ?? 5}${C.reset}`,
+        `${C.gold}Window:${C.reset}    ${C.white}${ctx.agent?.slidingWindowSize ?? 10}${C.reset}`,
+        `${C.gold}Tools:${C.reset}     ${C.cyberCyan}${toolsSchema.length}${C.reset}`,
+        '',
+        `${C.dim}Manage profiles: /profile list | /profile use <name> | /profile save <name>${C.reset}`
       ],
       headerBg: '\x1b[48;2;48;54;70m', bg: '\x1b[48;2;36;40;52m'
     });
@@ -2048,194 +2478,6 @@ export const handlers = {
     return 'HANDLED';
   },
 
-  '/update': async (ctx) => {
-    const manager = ctx.updateManager || new UpdateManager();
-    const action = (ctx.sub || 'check').toLowerCase();
-    const parts = ctx.parts || [];
-    const allowMajor = parts.includes('--allow-major');
-    const allowDeprecated = parts.includes('--allow-deprecated');
-    const positional = parts.slice(2).filter(part => !part.startsWith('--'));
-    const flags = parts.slice(2).filter(part => part.startsWith('--'));
-
-    const printUpdateHelp = () => printSolidPanel({
-      title: 'Kiku Agent Update',
-      lines: [
-        `${C.bold}${C.white}/update${C.reset} ${C.dim}or /update check — check the configured channel${C.reset}`,
-        `${C.bold}${C.white}/update install [latest|next|canary|x.y.z]${C.reset}`,
-        `${C.bold}${C.white}/update channel [latest|next|canary]${C.reset}`,
-        `${C.bold}${C.white}/update rollback${C.reset} ${C.dim}— reinstall the previously recorded version${C.reset}`,
-        '',
-        `${C.dim}Major releases require --allow-major. Deprecated releases require --allow-deprecated.${C.reset}`,
-      ],
-    });
-
-    const statusLines = status => {
-      const changeLabel = status.change === 'upgrade'
-        ? `${C.emerald}UPDATE AVAILABLE${C.reset}`
-        : status.change === 'downgrade'
-          ? `${C.amber}OLDER RELEASE${C.reset}`
-          : `${C.emerald}UP TO DATE${C.reset}`;
-      const lines = [
-        `${C.gold}Current:${C.reset}      ${C.white}${status.currentVersion}${C.reset}`,
-        `${C.gold}Target:${C.reset}       ${C.white}${status.targetVersion}${C.reset} ${C.dim}(${status.target})${C.reset}`,
-        `${C.gold}Status:${C.reset}       ${changeLabel}`,
-        `${C.gold}Installation:${C.reset} ${C.white}${status.installMode.label}${C.reset}`,
-        `${C.gold}Node:${C.reset}         ${status.nodeCompatible ? C.emerald + 'Compatible' : C.red + 'Incompatible'}${C.reset}${status.nodeRange ? ` ${C.dim}(requires ${status.nodeRange})${C.reset}` : ''}`,
-        `${C.gold}Integrity:${C.reset}    ${status.integrity ? C.emerald + 'Published with npm integrity metadata' : C.amber + 'Not reported'}${C.reset}`,
-      ];
-      if (status.majorChange) lines.push(`${C.amber}[MAJOR] This release crosses a major-version boundary.${C.reset}`);
-      if (status.deprecated) lines.push(`${C.red}[DEPRECATED] ${status.deprecated}${C.reset}`);
-      lines.push('', `${C.bold}${C.lavender}What's new:${C.reset}`);
-      if (status.releaseNotes.length > 0) {
-        for (const note of status.releaseNotes) lines.push(`  ${C.sakura}•${C.reset} ${C.white}${note}${C.reset}`);
-      } else {
-        lines.push(`  ${C.dim}No release summary was published for this version.${C.reset}`);
-      }
-      if (status.releaseUrl) lines.push('', `${C.dim}Release: ${status.releaseUrl}${C.reset}`);
-      return lines;
-    };
-
-    try {
-      const allowedFlags = action === 'install'
-        ? ['--allow-major', '--allow-deprecated']
-        : action === 'rollback'
-          ? ['--allow-deprecated']
-          : [];
-      if (flags.some(flag => !allowedFlags.includes(flag))) {
-        throw new UpdateError('Unknown option. Run /update help for supported arguments.', 'INVALID_OPTION');
-      }
-      if (positional.length > 1 || ((action === 'rollback' || action === 'help') && positional.length > 0)) {
-        throw new UpdateError('Too many update arguments. Run /update help for usage.', 'INVALID_ARGUMENTS');
-      }
-
-      if (action === 'help') {
-        printUpdateHelp();
-        return 'HANDLED';
-      }
-
-      if (action === 'channel') {
-        const requested = positional[0];
-        if (!requested) {
-          const channel = await manager.getChannel();
-          printSolidPanel({
-            title: 'Update Channel',
-            lines: [
-              `${C.gold}Current:${C.reset} ${C.white}${channel}${C.reset}`,
-              `${C.dim}Available: ${UPDATE_CHANNELS.join(', ')}${C.reset}`,
-            ],
-          });
-          return 'HANDLED';
-        }
-        const channel = await manager.setChannel(requested);
-        const lines = [
-          `${C.emerald}[OK] Future /update checks will use ${C.bold}${channel}${C.reset}${C.emerald}.${C.reset}`,
-        ];
-        if (channel !== 'latest') {
-          lines.push(`${C.amber}[NOTE] The "${channel}" channel may not have published builds on npm yet.${C.reset}`);
-        }
-        lines.push(`${C.dim}This changes only the release channel; it does not install anything.${C.reset}`);
-        printSolidPanel({
-          title: 'Update Channel Changed',
-          lines,
-        });
-        return 'HANDLED';
-      }
-
-      if (action === 'install') {
-        const target = positional[0];
-        console.log(`\n  ${C.cyberCyan}[UPDATE] Resolving and validating the requested npm release...${C.reset}\n`);
-        const result = await manager.install(target, {
-          allowMajor,
-          allowDeprecated,
-          onProgress: message => { if (message) console.log(`  ${C.dim}${message}${C.reset}`); },
-        });
-        if (result.outcome === 'manual') {
-          printSolidPanel({
-            title: 'Manual Update Required',
-            lines: [
-              ...statusLines(result),
-              '',
-              `${C.amber}This installation type is not modified automatically.${C.reset}`,
-              `${C.gold}Run:${C.reset} ${C.white}${result.command}${C.reset}`,
-            ],
-          });
-          return 'HANDLED';
-        }
-        if (result.outcome === 'current') {
-          printSolidPanel({ title: 'Kiku Agent Is Up to Date', lines: statusLines(result) });
-          return 'HANDLED';
-        }
-        printSolidPanel({
-          title: 'Update Installed Successfully',
-          lines: [
-            `${C.emerald}[OK] ${PACKAGE_NAME} ${result.installedVersion} was installed and verified.${C.reset}`,
-            ...(!result.historyRecorded ? [`${C.amber}[WARNING] Rollback history could not be saved.${C.reset}`] : []),
-            `${C.dim}This session will close. Start kiku-agent again to load the new code.${C.reset}`,
-            `${C.dim}Restart MCP hosts to load the matching kiku-mcp server version.${C.reset}`,
-          ],
-        });
-        try { await ctx.agent?.endSession?.(); } catch {}
-        return 'EXIT';
-      }
-
-      if (action === 'rollback') {
-        console.log(`\n  ${C.cyberCyan}[UPDATE] Resolving the previously installed version...${C.reset}\n`);
-        const result = await manager.rollback({ allowDeprecated });
-        if (result.outcome === 'manual') {
-          printSolidPanel({
-            title: 'Manual Rollback Required',
-            lines: [
-              `${C.amber}Run the following command outside Kiku Agent:${C.reset}`,
-              `${C.white}${result.command}${C.reset}`,
-            ],
-          });
-          return 'HANDLED';
-        }
-        if (result.outcome === 'current') {
-          printSolidPanel({ title: 'Rollback Not Needed', lines: statusLines(result) });
-          return 'HANDLED';
-        }
-        printSolidPanel({
-          title: 'Rollback Installed Successfully',
-          lines: [
-            `${C.emerald}[OK] Restored ${PACKAGE_NAME} ${result.installedVersion}.${C.reset}`,
-            ...(!result.historyRecorded ? [`${C.amber}[WARNING] Rollback history could not be saved.${C.reset}`] : []),
-            `${C.dim}This session will close. Restart Kiku Agent and any MCP host.${C.reset}`,
-          ],
-        });
-        try { await ctx.agent?.endSession?.(); } catch {}
-        return 'EXIT';
-      }
-
-      if (action === 'check' || action === 'status') {
-        const status = await manager.check(positional[0]);
-        const lines = statusLines(status);
-        if (status.updateAvailable) {
-          lines.push('', `${C.cyberCyan}Run /update install${status.target === 'latest' ? '' : ` ${status.target}`} to update.${C.reset}`);
-        }
-        printSolidPanel({ title: 'Kiku Agent Update', lines });
-        return 'HANDLED';
-      }
-
-      printUpdateHelp();
-      return 'HANDLED';
-    } catch (error) {
-      const safeMessage = error instanceof UpdateError ? error.message : 'The update operation failed unexpectedly.';
-      const lines = [
-        `${C.red}[${error.code || 'UPDATE_ERROR'}] ${safeMessage}${C.reset}`,
-      ];
-      if (error.code === 'CHANNEL_NOT_FOUND') {
-        lines.push(`${C.gold}Tip:${C.reset} ${C.white}Run ${C.bold}/update channel latest${C.reset}${C.white} to return to the active release channel.${C.reset}`);
-      }
-      lines.push(`${C.dim}No session, memory, or environment files were changed.${C.reset}`);
-      printSolidPanel({
-        title: 'Update Failed',
-        lines,
-      });
-      return 'HANDLED';
-    }
-  },
-
   '/system': async () => {
     const os = await import('node:os');
     const mem = process.memoryUsage();
@@ -2451,13 +2693,13 @@ export const handlers = {
     const { getCopyableContent, copyToClipboard, parseDetailsRequest } = await import('./queryDetails.js');
     const reference = [ctx.sub, ctx.extra].filter(Boolean).join(' ');
     const request = parseDetailsRequest(reference);
-    const details = ctx.agent?.lastQueryDetails || null;
+    const details = ctx.agent?.lastQueryDetails || ctx.agent?._lastQueryDetails || null;
     const copyable = getCopyableContent(details, request, ctx.agent?.session);
-    if (!copyable?.text) {
+    if (!copyable?.text || !copyable.text.trim()) {
       printRichCard({
         title: 'Nothing to Copy',
         status: 'warning',
-        lines: ['The requested query or session section is empty.'],
+        lines: ['The requested query or session section is empty or no query has been recorded.'],
       });
       return 'HANDLED';
     }
@@ -2480,14 +2722,42 @@ export const handlers = {
   },
 
   '/gallery': async (ctx) => {
-    const count = Number(ctx.sub) || 2;
-    const displayed = typeof ctx.showTerminalImage === 'function' && ctx.showTerminalImage(count);
+    const rawSub = String(ctx.sub || '').trim().toLowerCase();
+    let renderOptions = { count: 2 };
+
+    if (rawSub === 'hd' || rawSub === 'single' || rawSub === 'card') {
+      renderOptions = { count: 1, hd: true };
+    } else if (!isNaN(Number(rawSub)) && Number(rawSub) > 0) {
+      renderOptions = { index: Number(rawSub) - 1, hd: true };
+    } else if (rawSub === 'all' || rawSub === 'pair') {
+      renderOptions = { count: 2 };
+    } else if (rawSub === 'list') {
+      const { discoverImages, findGalleryMetadata } = await import('./terminalImage.js');
+      const imgs = discoverImages();
+      const lines = imgs.map((img, i) => {
+        const meta = findGalleryMetadata(img);
+        const title = meta?.titleCn || meta?.titleTh || path.basename(img);
+        return `  ${C.cyan}${String(i + 1).padStart(2, ' ')}.${C.reset} ${C.bold}${title}${C.reset} ${meta?.date ? `${C.dim}(${meta.date})${C.reset}` : ''}`;
+      });
+      printSolidPanel({
+        title: '🌸 Ju Jingyi Visual Photo Gallery Catalog',
+        lines: [
+          `${C.dim}Use /gallery <number> or /gallery hd to render in crystal-clear TrueColor:${C.reset}`,
+          '',
+          ...lines,
+        ],
+        bg: '\x1b[48;2;45;35;55m'
+      });
+      return 'HANDLED';
+    }
+
+    const displayed = typeof ctx.showTerminalImage === 'function' && ctx.showTerminalImage(renderOptions);
     if (!displayed) {
       printRichCard({
         title: 'Terminal Gallery Unavailable',
         status: 'warning',
         lines: [
-          'Images require an interactive color terminal and packaged files in src/assets/images.',
+          'Images require an interactive color terminal and packaged files in public/images or src/assets/images.',
           'Set KIKU_TUI_IMAGES=on to override terminal detection, or off to disable images.',
         ],
       });
@@ -2608,7 +2878,7 @@ export const handlers = {
           const selectedText = opts[idx];
           if (idx === q.answer) {
             answers.push({
-              qIndex: i,
+              qIndex: q.originalIndex ?? i,
               answerIndex: q.optionOrder?.[idx] ?? idx,
             });
             score++;
@@ -2774,12 +3044,16 @@ const ALIASES = {
   '/sponsor': '/ads', '/ad': '/ads',
   '/image': '/gallery', '/photo': '/gallery',
   '/cls': '/clear', '/reset': '/clear',
-  '/export': '/save',
+  '/export': '/save', '/markdown': '/save',
+  '/src': '/sources', '/srcs': '/sources',
   '/r': '/retry',
   '/kvip': '/key',
   '/switch': '/provider',
   '/providers': '/provider',
   '/fallback': '/provider',
+  '/profiles': '/profile',
+  '/preset': '/profile',
+  '/presets': '/profile',
 };
 
 export async function routeCommand(rawInput, ctx) {