kiku-agent 1.0.7 → 1.0.9

package/server/agent/commands.js

@@ -4,13 +4,16 @@ 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
+  formatRichCardLines, printRichCard, printRichStatusCard, formatStatusBadge, formatRichTable, getStringDisplayWidth
 } from './ui.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 { featureCommandHandlers, aiNarration, languageHint } from './commandFeatures.js';
 
 function levenshteinDistance(a, b) {
   const matrix = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
@@ -85,6 +88,7 @@ export function fuzzyMatchTools(query) {
 }
 
 export const handlers = {
+  ...featureCommandHandlers,
   '/exit': async (ctx) => {
     try { await ctx.agent.endSession(); } catch {}
     console.log(`\n  ${C.sakura}Session archived. Thank you for supporting Ju Jingyi. Goodbye. (鞠躬 ~ 谢谢!)${C.reset}\n`);
@@ -682,6 +686,34 @@ export const handlers = {
       return 'HANDLED';
     }
 
+    if (sub === 'summary' || sub === 'summarize') {
+      const messages = (agent?.session?.messages || []).map(m => {
+        const textPart = m.parts?.find(p => p.type === 'text');
+        return { role: m.role, text: textPart ? textPart.content : '' };
+      }).filter(m => m.text);
+      if (messages.length === 0) {
+        printSolidPanel({
+          title: 'History Summary',
+          lines: [`${C.dim}No conversation history to summarize.${C.reset}`],
+          headerBg: '\x1b[48;2;48;54;70m',
+          bg: '\x1b[48;2;36;40;52m',
+        });
+        return 'HANDLED';
+      }
+      const summary = await aiNarration(ctx, {
+        system: `You are the Kiku session archivist. In 2-3 concise sentences, summarize the key topics, queries, and findings discussed across this conversation history. ${languageHint(ctx)} Do not invent facts. No markdown.`,
+        user: JSON.stringify({ messageCount: messages.length, messages: messages.slice(-15) }),
+        limit: 450,
+      });
+      printSolidPanel({
+        title: `History Summary • ${messages.length} message${messages.length === 1 ? '' : 's'}`,
+        lines: summary ? [`  ${C.white}${summary}${C.reset}`] : [`${C.dim}Could not generate history summary (requires active chat model).${C.reset}`],
+        headerBg: '\x1b[48;2;48;54;70m',
+        bg: '\x1b[48;2;36;40;52m',
+      });
+      return 'HANDLED';
+    }
+
     if (sub === 'search' && extra) {
       const q = extra.toLowerCase().trim();
       const matches = [];
@@ -768,6 +800,39 @@ export const handlers = {
       return 'HANDLED';
     }
 
+    if (action === 'summary' || action === 'summarize') {
+      const messages = (sess?.messages || []).map(m => {
+        const textPart = m.parts?.find(p => p.type === 'text');
+        return { role: m.role, text: textPart ? textPart.content : '' };
+      }).filter(m => m.text);
+      if (messages.length === 0) {
+        printSolidPanel({
+          title: 'Session Summary',
+          lines: [`${C.dim}No messages in the active session to summarize.${C.reset}`],
+          headerBg: '\x1b[48;2;48;54;70m',
+          bg: '\x1b[48;2;36;40;52m',
+        });
+        return 'HANDLED';
+      }
+      const summary = await aiNarration(ctx, {
+        system: `You are the Kiku session analyst. In 2-3 concise sentences, summarize what this session achieved, what tools were used, and key takeaways for the user. ${languageHint(ctx)} Do not invent facts. No markdown.`,
+        user: JSON.stringify({
+          sessionId: sess.id,
+          totalQueries: sess.stats?.totalQueries || 0,
+          totalToolCalls: sess.stats?.totalToolCalls || 0,
+          recentExchanges: messages.slice(-10),
+        }),
+        limit: 450,
+      });
+      printSolidPanel({
+        title: `Session Summary • ${sess.id}`,
+        lines: summary ? [`  ${C.white}${summary}${C.reset}`] : [`${C.dim}Could not generate session summary (requires active chat model).${C.reset}`],
+        headerBg: '\x1b[48;2;48;54;70m',
+        bg: '\x1b[48;2;36;40;52m',
+      });
+      return 'HANDLED';
+    }
+
     if (action === 'list') {
       const sessions = agent.memory.getArchivedSessions(15);
       printSolidPanel({
@@ -1021,13 +1086,40 @@ export const handlers = {
       printSolidPanel({
         title: 'Topic Profile',
         lines: topics.map(t => {
-        const bar = '█'.repeat(Math.min(t.count, 15));
-          return `${C.gold}${t.topic.padEnd(14)}${C.reset} ${C.cyberCyan}${bar}${C.reset} ${C.dim}(${t.count}x)${C.reset}`;
+          const bar = '█'.repeat(Math.min(t.count, 15));
+          const pad = ' '.repeat(Math.max(0, 14 - getStringDisplayWidth(t.topic)));
+          return `${C.gold}${t.topic}${pad}${C.reset} ${C.cyberCyan}${bar}${C.reset} ${C.dim}(${t.count}x)${C.reset}`;
         }),
       });
       return 'HANDLED';
     }
 
+    if (memAction === 'summary' || memAction === 'summarize' || memAction === 'profile') {
+      const facts = typeof agent.memory?.getFacts === 'function' ? agent.memory.getFacts() : (agent.memory?.facts || []);
+      const topics = typeof agent.memory?.getTopTopics === 'function' ? agent.memory.getTopTopics(10) : [];
+      if (!facts.length && !topics.length) {
+        printSolidPanel({
+          title: 'Memory Profile Summary',
+          lines: [`${C.dim}No long-term memories or topics stored yet. Use /mem add <fact> first.${C.reset}`]
+        });
+        return 'HANDLED';
+      }
+      const summary = await aiNarration(ctx, {
+        system: `You are the Kiku persona & memory archivist. Synthesize a concise profile (2-3 sentences) of what this user knows, likes, or tracks about Ju Jingyi based on their saved facts and topics. ${languageHint(ctx)} Do not invent facts. No markdown.`,
+        user: JSON.stringify({
+          storedFactsCount: facts.length,
+          sampleFacts: facts.slice(0, 10).map(f => f.content),
+          topTopics: topics,
+        }),
+        limit: 450,
+      });
+      printSolidPanel({
+        title: `Memory Profile Summary • ${facts.length} fact${facts.length === 1 ? '' : 's'} • ${topics.length} topic${topics.length === 1 ? '' : 's'}`,
+        lines: summary ? [`  ${C.white}${summary}${C.reset}`] : [`${C.dim}Could not generate memory profile summary (requires active chat model).${C.reset}`],
+      });
+      return 'HANDLED';
+    }
+
     if (memAction === 'export') {
       const exported = await agent.memory.exportToJSON();
       console.log(`\n  ${C.emerald}[OK] Memory exported.${C.reset} ${C.white}${exported.filePath}${C.reset}\n`);
@@ -1198,7 +1290,7 @@ export const handlers = {
 
       if (!targetProvider) {
         console.log(`\n  ${C.amber}Usage: /provider use <provider_name> [model_id]${C.reset}`);
-        console.log(`  ${C.dim}Example: /provider use groq openai/gpt-oss-120b${C.reset}\n`);
+        console.log(`  ${C.dim}Example: /provider use groq openai/gpt-oss-120b${C.reset}\n`);
         return 'HANDLED';
       }
 
@@ -1206,16 +1298,16 @@ export const handlers = {
         const options = targetModel ? { model: targetModel } : {};
         const info = ctx.client.switchProvider(targetProvider, options);
         if (ctx.agent?.client) ctx.agent.client.switchProvider(targetProvider, options);
-        if (ctx.modelManager) {
-          ctx.modelManager.client = ctx.client;
-          ctx.modelManager.requestedModel = info.model;
-          const resolution = await ctx.modelManager.resolve({ requestedModel: info.model });
-          if (resolution.connected && resolution.usedFallback) {
-            console.log(`  ${C.amber}• Requested model unavailable; using ${resolution.selectedModel}${C.reset}`);
-          } else if (!resolution.connected) {
-            console.log(`  ${C.amber}• Provider is not ready: ${resolution.error}${C.reset}`);
-          }
-        }
+        if (ctx.modelManager) {
+          ctx.modelManager.client = ctx.client;
+          ctx.modelManager.requestedModel = info.model;
+          const resolution = await ctx.modelManager.resolve({ requestedModel: info.model });
+          if (resolution.connected && resolution.usedFallback) {
+            console.log(`  ${C.amber}• Requested model unavailable; using ${resolution.selectedModel}${C.reset}`);
+          } else if (!resolution.connected) {
+            console.log(`  ${C.amber}• Provider is not ready: ${resolution.error}${C.reset}`);
+          }
+        }
         ctx.baseUrl = info.baseUrl;
 
         console.log(`\n  ${C.emerald}[OK] Switched provider to ${C.bold}${info.providerName}${C.reset} (${info.provider})`);
@@ -1683,12 +1775,18 @@ export const handlers = {
       for (const s of status.servers) {
         const serverName = sanitizeTerminalText(s.name, 128) || 'unnamed';
         const serverType = sanitizeTerminalText(s.type, 80) || 'unknown';
+        const sourceNames = (s.sources || [])
+          .map(source => sanitizeTerminalText(String(source).split(/[\\/]/).pop(), 128))
+          .filter(Boolean);
+        const sourceLabel = sourceNames.length > 0
+          ? ` ${C.slate}• source: ${[...new Set(sourceNames)].join(', ')}${C.reset}`
+          : '';
         if (s.status === 'connected') {
-          lines.push(`  ${C.emerald}● Connected:${C.reset} ${C.bold}${C.white}${serverName}${C.reset} ${C.dim}(${serverType})${C.reset} — ${C.emerald}${s.toolsCount} tools${C.reset}, ${s.resourcesCount} resources`);
+          lines.push(`  ${C.emerald}● Connected:${C.reset} ${C.bold}${C.white}${serverName}${C.reset} ${C.dim}(${serverType})${C.reset} — ${C.emerald}${s.toolsCount} tools${C.reset}, ${s.resourcesCount} resources${sourceLabel}`);
         } else if (s.status === 'saved_offline') {
-          lines.push(`  ${C.slate}○ Saved (Offline):${C.reset} ${C.bold}${C.white}${serverName}${C.reset} ${C.dim}(${serverType})${C.reset} — ${C.dim}type /mcp reconnect ${serverName} to start${C.reset}`);
+          lines.push(`  ${C.slate}○ Saved (Offline):${C.reset} ${C.bold}${C.white}${serverName}${C.reset} ${C.dim}(${serverType})${C.reset} — ${C.dim}type /mcp reconnect ${serverName} to start${C.reset}${sourceLabel}`);
         } else {
-          lines.push(`  ${C.red}✕ Error:${C.reset} ${C.bold}${C.white}${serverName}${C.reset} ${C.dim}(${serverType})${C.reset} — ${C.red}${s.error || 'Connection failed'}${C.reset}`);
+          lines.push(`  ${C.red}✕ Error:${C.reset} ${C.bold}${C.white}${serverName}${C.reset} ${C.dim}(${serverType})${C.reset} — ${C.red}${s.error || 'Connection failed'}${C.reset}${sourceLabel}`);
         }
       }
 
@@ -1859,12 +1957,16 @@ export const handlers = {
           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: [
-            `${C.emerald}[OK] Future /update checks will use ${C.bold}${channel}${C.reset}${C.emerald}.${C.reset}`,
-            `${C.dim}This changes only the release channel; it does not install anything.${C.reset}`,
-          ],
+          lines,
         });
         return 'HANDLED';
       }
@@ -1949,12 +2051,16 @@ export const handlers = {
       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: [
-          `${C.red}[${error.code || 'UPDATE_ERROR'}] ${safeMessage}${C.reset}`,
-          `${C.dim}No session, memory, or environment files were changed.${C.reset}`,
-        ],
+        lines,
       });
       return 'HANDLED';
     }
@@ -2108,10 +2214,15 @@ export const handlers = {
     return 'HANDLED';
   },
 
-  '/stats': async () => {
+  '/stats': async (ctx) => {
     try {
       const result = await executeTool('get_system_stats', {});
       const s = result.stats || {};
+      const insight = await aiNarration(ctx, {
+        system: `You are the Kiku data narrator. In ONE short sentence, point out the most interesting thing about this catalog snapshot. ${languageHint(ctx)} Mention only the numbers provided. Never invent numbers. No markdown.`,
+        user: JSON.stringify({ totalWorks: s.totalWorks || 0, totalSongs: s.totalUniqueSongs || 0, brands: s.brandEndorsements || 0, awards: s.totalAwards || 0, timeline: s.timelineMilestones || 0 }),
+        limit: 240,
+      });
       printSolidPanel({
         title: `Database Overview`,
         lines: [
@@ -2119,7 +2230,8 @@ export const handlers = {
           `${C.gold}Songs:${C.reset}     ${C.cyberCyan}${s.totalUniqueSongs || 0}${C.reset}`,
           `${C.gold}Brands:${C.reset}    ${C.cyberCyan}${s.brandEndorsements || 0}${C.reset}`,
           `${C.gold}Awards:${C.reset}    ${C.cyberCyan}${s.totalAwards || 0}${C.reset}`,
-          `${C.gold}Timeline:${C.reset}  ${C.cyberCyan}${s.timelineMilestones || 0}${C.reset}`
+          `${C.gold}Timeline:${C.reset}  ${C.cyberCyan}${s.timelineMilestones || 0}${C.reset}`,
+          ...(insight ? ['', `  ${C.slate}${insight}${C.reset}`] : []),
         ],
         headerBg: '\x1b[48;2;48;54;70m', bg: '\x1b[48;2;36;40;52m'
       });
@@ -2204,6 +2316,261 @@ export const handlers = {
     ctx.printAd();
     return 'HANDLED';
   },
+
+  '/gallery': async (ctx) => {
+    const displayed = typeof ctx.showTerminalImage === 'function' && ctx.showTerminalImage();
+    if (!displayed) {
+      printRichCard({
+        title: 'Terminal Gallery Unavailable',
+        status: 'warning',
+        lines: [
+          'Images require an interactive color terminal and packaged files in src/assets/images.',
+          'Set KIKU_TUI_IMAGES=on to override terminal detection, or off to disable images.',
+        ],
+      });
+    }
+    return 'HANDLED';
+  },
+
+  '/quiz': async (ctx) => {
+    const { sub, extra } = ctx;
+    const langArg = (sub === 'lang' ? extra : sub || '').toLowerCase().trim();
+    const quizLang = ['th', 'en', 'zh'].includes(langArg) ? langArg : (ctx.agent?.memory?.preferences?.language || 'en');
+    const i18n = QUIZ_I18N[quizLang] || QUIZ_I18N.en;
+
+    const shuffled = shuffleQuizQuestions(QUIZ_QUESTIONS);
+    let score = 0;
+    let challengeToken = null;
+    let isOnline = false;
+
+    printSolidPanel({
+      title: i18n.title,
+      lines: [
+        `${C.bold}${C.white}${i18n.subtitle}${C.reset}`,
+        `${C.dim}Language: ${quizLang.toUpperCase()} | Questions: 15 | Target: 15/15${C.reset}`,
+      ],
+      bg: '\x1b[48;2;48;40;60m'
+    });
+
+
+    const baseUrl = ctx.baseUrl || process.env.KIKU_API_URL || 'http://localhost:3000';
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    try {
+      const res = await fetch(`${baseUrl}/api/v1/quiz/challenge`, { signal: controller.signal });
+      if (res.ok) {
+        const json = await res.json();
+        challengeToken = json.data?.challengeToken;
+        isOnline = true;
+      }
+    } catch {
+   
+    } finally {
+      clearTimeout(timeout);
+    }
+
+    if (isOnline) {
+      console.log(`  ${C.dim}Connected to server. Quiz answers will be verified via API.${C.reset}`);
+    } else {
+      console.log(`  ${C.dim}Offline mode. Answers verified locally — key generated on completion.${C.reset}`);
+    }
+
+    const answers = [];
+    const stdin = process.stdin;
+    const wasRaw = stdin.isTTY && stdin.isRaw;
+    let rl = null;
+
+    if (typeof ctx.readInput !== 'function') {
+      const { createInterface } = await import('node:readline');
+      if (stdin.isTTY) {
+        try { stdin.setRawMode(false); } catch {}
+      }
+      rl = createInterface({ input: stdin, output: process.stdout });
+    }
+
+    const askQuestion = () => {
+      if (typeof ctx.readInput === 'function') {
+        return ctx.readInput({
+          prompt: i18n.answerPrompt,
+          placeholder: i18n.answerPlaceholder,
+          history: false,
+          cancelValue: 'q',
+        });
+      }
+      return new Promise(resolve => rl.question(`  ${C.roseGlow}>${C.reset} `, resolve));
+    };
+
+    let cancelled = false;
+    try {
+      for (let i = 0; i < shuffled.length; i++) {
+        const q = shuffled[i];
+        const numberedText = q.q[quizLang] || q.q.en;
+        const qText = numberedText.replace(/^\s*\d+[.)]\s*/, '');
+        const opts = q.options[quizLang] || q.options.en;
+
+        printSolidPanel({
+          title: `${i18n.questionOf(i + 1, shuffled.length)}  •  ${i18n.score(score, shuffled.length)}`,
+          lines: [
+            `${C.bold}${C.white}${qText}${C.reset}`,
+            '',
+            ...opts.map((opt, idx) => `  ${C.bold}${C.cyberCyan}${LETTER_LABELS[idx]})${C.reset} ${C.white}${opt}${C.reset}`),
+          ],
+          bg: '\x1b[48;2;36;40;52m'
+        });
+
+        let answeredCorrectly = false;
+        while (!answeredCorrectly) {
+          const input = String(await askQuestion() ?? '').trim().toLowerCase();
+
+          if (['q', 'quit', 'exit', 'cancel'].includes(input)) {
+            cancelled = true;
+            break;
+          }
+          if (input === 'h' || input === 'hint') {
+            const hintText = q.hint[quizLang] || q.hint.en;
+            console.log(`  ${C.amber}${i18n.hint}:${C.reset} ${C.dim}${hintText}${C.reset}`);
+            continue;
+          }
+
+          let idx = -1;
+          if (['a', 'b', 'c', 'd'].includes(input)) idx = input.charCodeAt(0) - 97;
+          else if (['1', '2', '3', '4'].includes(input)) idx = Number.parseInt(input, 10) - 1;
+
+          if (idx < 0 || idx >= opts.length) {
+            console.log(`  ${C.amber}${i18n.invalidAnswer}${C.reset}`);
+            continue;
+          }
+
+          const selectedLabel = LETTER_LABELS[idx];
+          const selectedText = opts[idx];
+          if (idx === q.answer) {
+            answers.push({
+              qIndex: i,
+              answerIndex: q.optionOrder?.[idx] ?? idx,
+            });
+            score++;
+            answeredCorrectly = true;
+            console.log(`  ${C.emerald}✓ ${i18n.correct.trim()}${C.reset} ${C.dim}— ${selectedLabel}) ${selectedText}${C.reset}`);
+          } else {
+            console.log(`  ${C.red}${i18n.incorrect}${C.reset} ${C.dim}— ${selectedLabel}) ${selectedText}${C.reset}`);
+          }
+        }
+
+        if (cancelled) break;
+      }
+    } finally {
+      rl?.close();
+      if (wasRaw && stdin.isTTY) {
+        try { stdin.setRawMode(true); } catch {}
+      }
+    }
+
+    if (cancelled) {
+      console.log(`  ${C.amber}${i18n.cancelled}${C.reset}`);
+      return 'HANDLED';
+    }
+
+    printSolidPanel({
+      title: `${i18n.score(score, shuffled.length)}`,
+      lines: [`${C.bold}${score === 15 ? C.emerald : C.amber}${score === 15 ? 'Perfect Score!' : `${score}/15 — Need 15/15 to claim a VIP Key.`}${C.reset}`],
+    });
+
+    if (score < 15) {
+      console.log(`\n  ${C.dim}Run ${C.cyberCyan}/quiz${C.reset}${C.dim} to try again.${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    console.log(`\n  ${C.amber}${i18n.generatingKey}${C.reset}\n`);
+
+    let key = null;
+
+
+    if (isOnline && challengeToken) {
+      try {
+        const res = await fetch(`${baseUrl}/api/v1/keys/claim`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ score, answers, challengeToken })
+        });
+        const json = await res.json();
+        if (json.status === 'success' && json.data?.apiKey) {
+          key = json.data.apiKey;
+        }
+      } catch {
+
+      }
+    }
+
+
+    if (!key) {
+      const token = crypto.randomBytes(16).toString('hex');
+      key = `kiku_vip_sk_${token}`;
+    }
+
+    ctx.agent?.memory?.setPreference('vipKey', key);
+
+    printSolidPanel({
+      title: `${i18n.congratsTitle}`,
+      lines: [
+        `${C.bold}${C.white}${i18n.congratsDesc}${C.reset}`,
+        '',
+        `${C.bold}${C.roseGlow}${i18n.keyLabel}:${C.reset}`,
+        `  ${C.gold}${key}${C.reset}`,
+        '',
+        `${C.dim}Usage: header 'X-API-Key: ${key}' or query '?apiKey=${key}'${C.reset}`,
+        `${C.dim}Key saved automatically. Use ${C.cyberCyan}/key show${C.reset}${C.dim} to view or ${C.cyberCyan}/key clear${C.reset}${C.dim} to remove.${C.reset}`,
+      ],
+      bg: '\x1b[48;2;48;40;60m'
+    });
+
+    return 'HANDLED';
+  },
+
+  '/key': async (ctx) => {
+    const { sub, extra } = ctx;
+    const action = (sub || 'show').toLowerCase();
+    const mem = ctx.agent?.memory;
+
+    if (action === 'clear') {
+      mem?.setPreference('vipKey', null);
+      console.log(`\n  ${C.emerald}[OK] ${QUIZ_I18N.en.keyCleared}${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    if (action === 'apply') {
+      const key = extra.trim();
+      if (!key) {
+        console.log(`\n  ${C.amber}Usage: /key apply <kiku_vip_sk_...>${C.reset}\n`);
+        return 'HANDLED';
+      }
+      mem?.setPreference('vipKey', key);
+      printSolidPanel({
+        title: 'VIP Key Applied',
+        lines: [
+          `${C.emerald}[OK] Key saved and ready to use!${C.reset}`,
+          `${C.gold}Key:${C.reset} ${C.white}${key}${C.reset}`,
+        ],
+      });
+      return 'HANDLED';
+    }
+
+    const storedKey = mem?.preferences?.vipKey;
+    if (storedKey) {
+      printSolidPanel({
+        title: 'Developer VIP Key',
+        lines: [
+          `${C.gold}Key:${C.reset}    ${C.bold}${C.white}${storedKey}${C.reset}`,
+          `${C.gold}Tier:${C.reset}   ${C.emerald}Developer VIP (1,000 req/min)${C.reset}`,
+          `${C.gold}Usage:${C.reset}  ${C.dim}X-API-Key: ${storedKey}${C.reset}`,
+          '',
+          `${C.dim}Clear: /key clear | Apply new: /key apply <key>${C.reset}`,
+        ],
+      });
+    } else {
+      console.log(`\n  ${C.amber}${QUIZ_I18N.en.noKey}${C.reset}\n`);
+    }
+    return 'HANDLED';
+  },
 };
 
 const ALIASES = {
@@ -2220,6 +2587,12 @@ const ALIASES = {
   '/suggest': '/suggestion', '/suggestions': '/suggestion',
   '/exec': '/tool', '/call': '/tool',
   '/toollist': '/tools',
+  '/lookup': '/find', '/findall': '/find',
+  '/cmp': '/compare',
+  '/fav': '/favorites', '/favs': '/favorites',
+  '/latest': '/news',
+  '/job': '/jobs',
+  '/random': '/discover',
   '/metrics': '/stats', '/catalog': '/stats',
   '/llm': '/model', '/engine': '/model',
   '/health': '/ping',
@@ -2230,9 +2603,11 @@ const ALIASES = {
   '/vram': '/gpu', '/gpus': '/gpu',
   '/info': '/about',
   '/sponsor': '/ads', '/ad': '/ads',
+  '/image': '/gallery', '/photo': '/gallery',
   '/cls': '/clear', '/reset': '/clear',
   '/export': '/save',
   '/r': '/retry',
+  '/kvip': '/key',
 };
 
 export async function routeCommand(rawInput, ctx) {
@@ -2262,5 +2637,5 @@ export async function routeCommand(rawInput, ctx) {
     return handlers['/help']({ ...ctx, sub: rawCmd, extra: '' });
   }
 
-  return await handler({ ...ctx, sub, extra, parts });
+  return await handler({ ...ctx, sub, extra, parts, rawInput: trimmed });
 }

package/server/agent/jobManager.js

@@ -0,0 +1,96 @@
+function errorMessage(error) {
+  return error?.message || String(error || 'Unknown error');
+}
+
+export class AgentJobManager {
+  constructor(limit = 50) {
+    this.limit = limit;
+    this.jobs = [];
+  }
+
+  create(type, label) {
+    const controller = new AbortController();
+    const job = {
+      id: `job_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+      type: String(type || 'task'),
+      label: String(label || type || 'Task').slice(0, 200),
+      state: 'running',
+      createdAt: new Date().toISOString(),
+      startedAt: new Date().toISOString(),
+      completedAt: null,
+      error: null,
+      result: null,
+      controller,
+    };
+    this.jobs.unshift(job);
+    this.jobs = this.jobs.slice(0, this.limit);
+    return job;
+  }
+
+  async run(type, label, runner, options = {}) {
+    const job = this.create(type, label);
+    const abortParent = () => job.controller.abort(options.signal?.reason);
+    options.signal?.addEventListener('abort', abortParent, { once: true });
+    options.onJob?.(this.publicJob(job));
+    try {
+      const result = await runner({ signal: job.controller.signal, job: this.publicJob(job) });
+      job.state = job.controller.signal.aborted ? 'cancelled' : 'completed';
+      job.result = result;
+      job.completedAt = new Date().toISOString();
+      return result;
+    } catch (error) {
+      job.state = job.controller.signal.aborted || error?.name === 'AbortError' ? 'cancelled' : 'failed';
+      job.error = errorMessage(error);
+      job.completedAt = new Date().toISOString();
+      throw error;
+    } finally {
+      options.signal?.removeEventListener('abort', abortParent);
+    }
+  }
+
+  list() {
+    return this.jobs.map(job => this.publicJob(job));
+  }
+
+  get(id) {
+    const job = this.jobs.find(item => item.id === id);
+    return job ? this.publicJob(job) : null;
+  }
+
+  cancel(id) {
+    const job = this.jobs.find(item => item.id === id);
+    if (!job || job.state !== 'running') return false;
+    job.state = 'cancelled';
+    job.completedAt = new Date().toISOString();
+    job.controller.abort(new DOMException('Cancelled by user', 'AbortError'));
+    return true;
+  }
+
+  cancelType(type) {
+    let cancelled = false;
+    for (const job of this.jobs) {
+      if (job.type === type && job.state === 'running') cancelled = this.cancel(job.id) || cancelled;
+    }
+    return cancelled;
+  }
+
+  clear() {
+    const before = this.jobs.length;
+    this.jobs = this.jobs.filter(job => job.state === 'running');
+    return before - this.jobs.length;
+  }
+
+  publicJob(job) {
+    return {
+      id: job.id,
+      type: job.type,
+      label: job.label,
+      state: job.state,
+      createdAt: job.createdAt,
+      startedAt: job.startedAt,
+      completedAt: job.completedAt,
+      error: job.error,
+      result: job.result,
+    };
+  }
+}