kiku-agent 1.3.2 → 1.3.4

package/server/agent/commands.js

@@ -10,7 +10,7 @@ import {
 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 { COMMAND_NAMES, COMMAND_ALIASES, getCommandDetails, findCommandDefinition } from './commandRegistry.js';
 import { THEMES, THEME_NAMES, ansiBackground, ansiForeground, getThemeName, setTheme } from './theme.js';
 import { getGpuMetrics, getSharedMemoryMetrics, formatProgressBar } from './gpuMetrics.js';
 import { computeVramEstimate, getHardwareTarget, probeLmStudioRuntime, resolveSystemHardwareTier } from './vramService.js';
@@ -23,6 +23,7 @@ import path from 'node:path';
 import http from 'node:http';
 import { PACKAGE_NAME, PACKAGE_VERSION } from './version.js';
 import { QUIZ_QUESTIONS, QUIZ_I18N, LETTER_LABELS, shuffleQuizQuestions } from './quizData.js';
+import { MCP_QUIZ_QUESTIONS, MCP_QUIZ_I18N, shuffleMcpQuizQuestions } from './mcpQuizData.js';
 import crypto from 'node:crypto';
 import { isAbortError } from './errors.js';
 import { featureCommandHandlers, aiNarration, languageHint } from './commandFeatures.js';
@@ -43,7 +44,16 @@ import {
 } from './envManager.js';
 import { cleanUrl } from './research.js';
 
-function askEnvQuestion(question, defaultValue = '') {
+function askEnvQuestion(ctx, question, defaultValue = '') {
+  if (ctx && typeof ctx.readInput === 'function') {
+  
+    return Promise.resolve(ctx.readInput({
+      prompt: `${question}${defaultValue ? ` [${defaultValue}]` : ''}`,
+      placeholder: ' ',
+      history: false,
+      cancelValue: '',
+    })).then(answer => String(answer ?? '').trim());
+  }
   return new Promise((resolve) => {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
     const suffix = defaultValue ? ` ${C.dim}[${defaultValue}]${C.reset}` : '';
@@ -157,13 +167,13 @@ function zoneBadge(zone) {
 }
 
 function resolveVramModelTarget(ctx, positional = []) {
-  const target = positional.join(' ');
-  if (!target) return { modelName: ctx.agent?.client?.model || null, modelPath: null };
+  const target = positional.join(' ').trim();
+  if (!target || /^<.*>$/.test(target)) return { modelName: ctx.agent?.client?.model || 'google/gemma-4-e4b', modelPath: null };
   if (/\.gguf$/i.test(target)) return { modelName: null, modelPath: target };
   return { modelName: target, modelPath: null };
 }
 
-/** `/vram live` — actual VRAM usage right now vs. the model's footprint. */
+
 async function printVramLivePanel(ctx, { overrides, positional }) {
   const client = ctx.agent?.client || null;
   const { modelName, modelPath } = resolveVramModelTarget(ctx, positional);
@@ -1439,9 +1449,20 @@ export const handlers = {
       const msgCount = sess.messages.length;
       const userMsgs = sess.messages.filter(m => m.role === 'user').length;
       const assistantMsgs = sess.messages.filter(m => m.role === 'assistant').length;
-      const toolCalls = sess.stats.totalToolCalls || 0;
-      const totalDur = ((sess.stats.totalDurationMs || 0) / 1000).toFixed(1);
-      const createdAt = sess.createdAt ? sess.createdAt.toLocaleString() : 'unknown';
+      const toolStats = typeof sess.getToolStats === 'function' ? sess.getToolStats() : {};
+      const toolCalls = typeof sess.getTotalToolCalls === 'function'
+        ? sess.getTotalToolCalls()
+        : Math.max(sess.stats?.totalToolCalls || 0, Object.values(toolStats).reduce((sum, s) => sum + (s.count || 0), 0));
+      const totalDurMs = Math.max(
+        sess.stats?.totalDurationMs || 0,
+        Object.values(toolStats).reduce((sum, s) => sum + (s.totalDurationMs || 0), 0)
+      );
+      const totalDur = (totalDurMs > 0 && totalDurMs < 1000)
+        ? (totalDurMs / 1000).toFixed(2)
+        : ((totalDurMs || 0) / 1000).toFixed(1);
+      const createdAt = sess.createdAt && !isNaN(new Date(sess.createdAt).getTime())
+        ? new Date(sess.createdAt).toLocaleString()
+        : 'unknown';
 
       const lines = [
         `${C.gold}Session ID:${C.reset}      ${C.white}${sess.id}${C.reset}`,
@@ -1453,7 +1474,6 @@ export const handlers = {
         `${C.gold}Thinking Mode:${C.reset}   ${C.bold}${C.gold}${sess.thinkingMode.toUpperCase()}${C.reset}`
       ];
 
-      const toolStats = typeof sess.getToolStats === 'function' ? sess.getToolStats() : {};
       const toolEntries = Object.entries(toolStats);
       if (toolEntries.length > 0) {
         lines.push('', `${C.bold}${C.lavender}Tool Executions Breakdown:${C.reset}`);
@@ -2039,14 +2059,12 @@ export const handlers = {
     if (ctx.tuiPrompt) {
       ctx.tuiPrompt.viewportLines = [...getWelcomeHeroLines()];
       ctx.tuiPrompt.scrollOffset = 0;
-      ctx.tuiPrompt.addViewportLines(`  ${C.emerald}[OK] Fresh start.${C.reset}\n`);
       ctx.tuiPrompt.render();
     } else {
       console.clear();
       if (typeof ctx.printWelcome === 'function') {
         ctx.printWelcome();
       }
-      console.log(`  ${C.emerald}[OK] Fresh start.${C.reset}\n`);
     }
     return 'HANDLED';
   },
@@ -2057,16 +2075,57 @@ export const handlers = {
   },
 
   '/lan': async (ctx) => {
-    const { scanLan, mapServerTypeToProvider } = await import('./lanDiscovery.js');
+    const { scanLan, mapServerTypeToProvider, listLanInterfaces, describeLanInterface, parseLanScanArgs, classifyScanToken, loadLanState, saveLanState, describeLanScanAge, pickLanEndpointModel } = await import('./lanDiscovery.js');
     const { savePersistedProviderBaseUrl } = await import('./config.js');
     const action = (ctx.sub || 'scan').toLowerCase();
     const parts = ctx.parts || [];
 
+    if (action === 'ifs' || action === 'interfaces' || action === 'iface') {
+      const rest = parts.slice(2).join(' ').trim();
+      if (rest && !['list', 'ls', 'show'].includes(rest.toLowerCase())) {
+        console.log(`\n  ${C.amber}Usage: /lan ifs   (list selectable network interfaces)${C.reset}`);
+        console.log(`  ${C.dim}Scan one of them with: /lan scan --iface <n|name>${C.reset}\n`);
+        return 'HANDLED';
+      }
+      console.log(`\n  ${C.cyberCyan}Detecting network interfaces...${C.reset}`);
+      let interfaces;
+      try {
+        interfaces = await listLanInterfaces({});
+      } catch (err) {
+        console.log(`\n  ${C.red}[LAN ERROR] ${err.message}${C.reset}\n`);
+        return 'HANDLED';
+      }
+      const lanState = await loadLanState().catch(() => null);
+      const lastIface = lanState?.lastIface ? String(lanState.lastIface).toLowerCase() : '';
+      const lines = [
+        '',
+        ...interfaces.map(i => {
+          const isLast = lastIface && (i.name.toLowerCase() === lastIface || String(i.index) === lastIface);
+          return `  ${C.white}${describeLanInterface(i)}${C.reset}${isLast ? `  ${C.gold}• last${C.reset}` : ''}`;
+        }),
+        '',
+      ];
+      lines.push(`${C.dim}Scan a single LAN: /lan scan --iface <n|name>  (e.g. /lan scan --iface Wi-Fi)${C.reset}`);
+      lines.push(`${C.dim}Explicit ranges still win: /lan scan 192.168.1.0/24 --ports 1234,8000${C.reset}`);
+      printSolidPanel({ title: `LAN Interfaces (${interfaces.length})`, lines });
+      return 'HANDLED';
+    }
+
     if (action === 'use') {
       const arg = (parts[2] || ctx.extra || '').trim();
-      const endpoints = lastLanScan?.endpoints || [];
+      const modelArg = parts.slice(3).join(' ').trim() || null;
+      let endpoints = lastLanScan?.endpoints || [];
+      let scanAgeNote = '';
+      if (endpoints.length === 0) {
+        const disk = await loadLanState().catch(() => null);
+        const diskEndpoints = disk?.lastScan?.endpoints;
+        if (Array.isArray(diskEndpoints) && diskEndpoints.length > 0) {
+          endpoints = diskEndpoints;
+          scanAgeNote = ` (from saved scan ${describeLanScanAge(disk.lastScan.savedAt)} — rescan if stale)`;
+        }
+      }
       if (!arg) {
-        console.log(`\n  ${C.amber}Usage: /lan use <n>   (run /lan first to discover endpoints)${C.reset}\n`);
+        console.log(`\n  ${C.amber}Usage: /lan use <n> [model-index-or-name]   (run /lan first to discover endpoints)${C.reset}\n`);
         return 'HANDLED';
       }
       const endpoint = /^\d+$/.test(arg)
@@ -2079,7 +2138,15 @@ export const handlers = {
       }
 
       const provider = mapServerTypeToProvider(endpoint.serverType);
-      const model = endpoint.models[0] || null;
+      const picked = pickLanEndpointModel(endpoint, modelArg);
+      if (!picked.matched) {
+        console.log(`\n  ${C.red}[ERROR] Model "${modelArg}" not on ${endpoint.host}:${endpoint.port}.${C.reset}`);
+        const available = (endpoint.models || []).map((m, i) => `    [${i + 1}] ${m}`).join('\n') || '    (no models reported)';
+        console.log(`  ${C.slate}Available:${C.reset}\n${available}`);
+        console.log(`  ${C.dim}Usage: /lan use <n> [model-index-or-name]${C.reset}\n`);
+        return 'HANDLED';
+      }
+      const model = picked.model;
       const cleanUrl = savePersistedProviderBaseUrl(provider, endpoint.url);
       const options = { baseUrl: cleanUrl, ...(model ? { model } : {}) };
       try {
@@ -2103,12 +2170,12 @@ export const handlers = {
           }
         }
         ctx.baseUrl = info.baseUrl;
-        console.log(`\n  ${C.emerald}[OK] Connected to LAN endpoint ${C.bold}${endpoint.host}:${endpoint.port}${C.reset}`);
+        console.log(`\n  ${C.emerald}[OK] Connected to LAN endpoint ${C.bold}${endpoint.host}:${endpoint.port}${C.reset}${scanAgeNote}`);
         console.log(`  ${C.slate}• Server:${C.reset}    ${C.white}${endpoint.serverName}${C.reset}`);
         console.log(`  ${C.slate}• Provider:${C.reset}  ${C.cyberCyan}${info.provider}${C.reset} → ${C.cyberCyan}${info.baseUrl}${C.reset}`);
         console.log(`  ${C.slate}• Model:${C.reset}     ${C.white}${info.model}${C.reset}`);
-        if (endpoint.models.length > 1) {
-          console.log(`  ${C.dim}• ${endpoint.models.length} models available — switch with /model use <id>${C.reset}`);
+        if (!modelArg && endpoint.models.length > 1) {
+          console.log(`  ${C.dim}• ${endpoint.models.length} models available — pick with /lan use <n> [model] or /model use <id>${C.reset}`);
         }
         console.log('');
       } catch (err) {
@@ -2119,31 +2186,47 @@ export const handlers = {
 
     console.log(`\n  ${C.cyberCyan}Scanning local network for LM servers (LM Studio :1234, vLLM :8000, Ollama :11434, :8080)...${C.reset}`);
     const restTokens = parts.slice(2).map(t => String(t || '').trim()).filter(Boolean);
-    if (action !== 'scan' && action !== 'json' && action !== 'use') {
+    if (action !== 'scan' && action !== 'json' && action !== 'use' && action !== 'ifs' && action !== 'interfaces' && action !== 'iface') {
       restTokens.unshift(action);
     }
-    let scanTargets = null;
-    let scanPorts = null;
-    const portsFlagIdx = restTokens.indexOf('--ports');
-    if (portsFlagIdx >= 0) {
-      const rawPorts = String(restTokens[portsFlagIdx + 1] || '').split(',').map(Number).filter(p => Number.isInteger(p) && p >= 1 && p <= 65535);
-      if (rawPorts.length === 0) {
-        console.log(`\n  ${C.amber}Usage: /lan scan <targets> --ports <p1,p2,...>${C.reset}`);
-        console.log(`  ${C.dim}Example: /lan scan 192.168.1.0/24 --ports 1234,8000${C.reset}\n`);
-        return 'HANDLED';
-      }
-      scanPorts = rawPorts;
-      restTokens.splice(portsFlagIdx, 2);
+    const parsed = parseLanScanArgs(restTokens);
+    if (parsed.error === 'ports') {
+      console.log(`\n  ${C.amber}Usage: /lan scan <targets> [--iface <n|name>] [--ports <p1,p2,...>] [--force]${C.reset}`);
+      console.log(`  ${C.dim}Example: /lan scan --iface Wi-Fi --ports 1234,8000${C.reset}\n`);
+      return 'HANDLED';
     }
-    if (restTokens.length > 0) {
-      scanTargets = restTokens.join(',').split(',').map(s => s.trim()).filter(Boolean);
+    if (parsed.error === 'iface') {
+      console.log(`\n  ${C.amber}Usage: /lan scan --iface <n|name>   (see /lan ifs for the list)${C.reset}\n`);
+      return 'HANDLED';
+    }
+    const scanTargets = parsed.subnets;
+    const scanPorts = parsed.ports;
+    let scanIface = parsed.iface;
+
+    if (!scanIface && scanTargets) {
+      // Bare adapter names work without the flag: `/lan scan Wi-Fi`.
+      const names = scanTargets.filter(t => classifyScanToken(t) === 'name');
+      if (names.length > 0) {
+        if (names.length > 1 || scanTargets.length > 1) {
+          console.log(`\n  ${C.amber}Mixed targets and interface names — pick one:${C.reset}`);
+          console.log(`  ${C.dim}• One LAN: /lan scan --iface <n|name>  (see /lan ifs)${C.reset}`);
+          console.log(`  ${C.dim}• Ranges:  /lan scan 192.168.1.0/24 --ports 1234,8000${C.reset}\n`);
+          return 'HANDLED';
+        }
+        scanIface = names[0];
+      }
     }
+    const effectiveTargets = scanIface
+      ? null
+      : (scanTargets || []).filter(t => classifyScanToken(t) !== 'name');
 
     let result;
     try {
       result = await scanLan({
-        ...(scanTargets ? { subnets: scanTargets } : {}),
+        ...(effectiveTargets && effectiveTargets.length > 0 ? { subnets: effectiveTargets } : {}),
+        ...(scanIface ? { iface: scanIface } : {}),
         ...(scanPorts ? { ports: scanPorts } : {}),
+        ...(parsed.force ? { force: true } : {}),
         signal: ctx.signal,
       });
     } catch (err) {
@@ -2159,6 +2242,16 @@ export const handlers = {
       return 'HANDLED';
     }
     lastLanScan = result;
+    try {
+      await saveLanState({
+        lastScan: {
+          savedAt: result.scannedAt || new Date().toISOString(),
+          subnets: result.subnets || [],
+          endpoints: result.endpoints || [],
+        },
+        ...(scanIface ? { lastIface: scanIface } : {}),
+      });
+    } catch {}
 
     if (action === 'json') {
       console.log(JSON.stringify(result, null, 2));
@@ -2194,6 +2287,13 @@ export const handlers = {
       lines.push('');
       lines.push(`${C.dim}Connect: /lan use <n>  (persists the Base URL for this provider)${C.reset}`);
     }
+    if (Array.isArray(result.skippedSubnets) && result.skippedSubnets.length > 0) {
+      lines.push('');
+      for (const s of result.skippedSubnets) {
+        const slice = String(s.cidr || '').split('/')[0].split('.').slice(0, 3).join('.');
+        lines.push(`  ${C.dim}• Skipped ${s.cidr} (${s.interfaceName}, ${Number(s.hostCount || 0).toLocaleString()} hosts, over budget) — slice it: /lan scan ${slice}.0/24${C.reset}`);
+      }
+    }
     printSolidPanel({ title: `LAN LM Server Discovery (${endpoints.length} found)`, lines });
     return 'HANDLED';
   },
@@ -2490,6 +2590,21 @@ export const handlers = {
 
   '/url': async (ctx) => handlers['/provider']({ ...ctx, sub: 'url', parts: ['/provider', 'url', ...(ctx.parts?.slice(1) || [])] }),
   '/endpoint': async (ctx) => handlers['/provider']({ ...ctx, sub: 'url', parts: ['/provider', 'url', ...(ctx.parts?.slice(1) || [])] }),
+  '/unload': async (ctx) => {
+    const { unloadModelFromEngine } = await import('./engineService.js');
+    const { getActiveLocalEngine } = await import('./config.js');
+    const targetArg = (ctx.sub || '').trim().toLowerCase();
+    const targetEngine = targetArg === 'vllm' ? 'vllm' : (targetArg === 'lms' || targetArg === 'lmstudio' ? 'lms' : getActiveLocalEngine() || 'lms');
+    const currentModel = ctx.client?.model || ctx.modelManager?.currentModel || null;
+    ctx.setIsProcessing?.(true, `Unloading model on ${targetEngine}…`);
+    const res = await unloadModelFromEngine(targetEngine, currentModel);
+    if (res.ok) {
+      console.log(`\n  ${C.emerald}[OK] Model successfully unloaded from ${targetEngine}. GPU VRAM released.${C.reset}\n`);
+    } else {
+      console.log(`\n  ${C.amber}[NOTICE] Unload result: ${res.reason || res.message || 'Model could not be unloaded'}.${C.reset}\n`);
+    }
+    return 'HANDLED';
+  },
 
   '/model': async (ctx) => {
     const rawSub = (ctx.sub || '').trim();
@@ -2497,6 +2612,723 @@ export const handlers = {
     const providerName = ctx.client.providerName || 'Model';
     const { getRecommendedModels, CLOUD_PROVIDERS } = await import('./config.js');
 
+    if (action === 'load') {
+      const {
+        checkEngineCompatibility,
+        loadModelOnEngine,
+      } = await import('./engineService.js');
+      const {
+        getActiveLocalEngine,
+        setActiveLocalEngine,
+        getPersistedModelLoadSettings,
+        savePersistedModelLoadSettings,
+      } = await import('./config.js');
+
+      const rawArgs = (ctx.extra || '').trim();
+      const tokens = rawArgs ? rawArgs.split(/\s+/).filter(Boolean) : [];
+      let targetModel = null;
+      let engine = null;
+      let gpu = undefined;
+      let threads = undefined;
+      let memUtil = undefined;
+      let maxModelLen = undefined;
+      let tp = undefined;
+      let dtype = undefined;
+      let enforceEager = undefined;
+      let enablePrefixCaching = undefined;
+      let splitMode = undefined;
+      let tensorSplit = undefined;
+      let mainGpu = undefined;
+      let flashAttn = undefined;
+      let batchSize = undefined;
+      let ubatchSize = undefined;
+      let kvCacheDtype = undefined;
+
+      for (let i = 0; i < tokens.length; i++) {
+        const tok = tokens[i];
+        if (tok === '--engine' && i + 1 < tokens.length) {
+          engine = tokens[++i].toLowerCase();
+        } else if (tok === '--gpu' && i + 1 < tokens.length) {
+          gpu = tokens[++i];
+        } else if (tok === '--threads' && i + 1 < tokens.length) {
+          threads = Number(tokens[++i]);
+        } else if (tok === '--split-mode' && i + 1 < tokens.length) {
+          splitMode = tokens[++i].toLowerCase();
+        } else if ((tok === '--tensor-split' || tok === '-ts') && i + 1 < tokens.length) {
+          tensorSplit = tokens[++i];
+        } else if ((tok === '--main-gpu' || tok === '-mg') && i + 1 < tokens.length) {
+          mainGpu = Number(tokens[++i]);
+        } else if (tok === '--fa' || tok === '--flash-attn') {
+          flashAttn = true;
+        } else if (tok === '--no-fa' || tok === '--no-flash-attn') {
+          flashAttn = false;
+        } else if ((tok === '-b' || tok === '--batch-size') && i + 1 < tokens.length) {
+          batchSize = Number(tokens[++i]);
+        } else if ((tok === '-ub' || tok === '--ubatch-size') && i + 1 < tokens.length) {
+          ubatchSize = Number(tokens[++i]);
+        } else if ((tok === '--ctk' || tok === '--kv-cache') && i + 1 < tokens.length) {
+          kvCacheDtype = tokens[++i].toLowerCase();
+        } else if ((tok === '--mem-util' || tok === '--gpu-mem-util') && i + 1 < tokens.length) {
+          memUtil = Number(tokens[++i]);
+        } else if (tok === '--max-model-len' && i + 1 < tokens.length) {
+          maxModelLen = Number(tokens[++i]);
+        } else if (tok === '--tp' && i + 1 < tokens.length) {
+          tp = Number(tokens[++i]);
+        } else if (tok === '--dtype' && i + 1 < tokens.length) {
+          dtype = tokens[++i].toLowerCase();
+        } else if (tok === '--enforce-eager') {
+          enforceEager = true;
+        } else if (tok === '--prefix-caching') {
+          enablePrefixCaching = true;
+        } else if (tok === '--no-prefix-caching') {
+          enablePrefixCaching = false;
+        } else if (!tok.startsWith('--') && !targetModel) {
+          targetModel = tok;
+        }
+      }
+
+      if (!engine) {
+        if (ctx.client.provider === 'vllm') {
+          engine = 'vllm';
+        } else if (ctx.client.provider === 'lmstudio') {
+          engine = 'lms';
+        } else {
+          engine = getActiveLocalEngine() || 'lms';
+        }
+      }
+
+      const compat = checkEngineCompatibility(engine);
+      if (!compat.supported) {
+        printRichCard({
+          title: `Engine Incompatible: ${engine.toUpperCase()}`,
+          status: 'error',
+          lines: [
+            `${C.amber}Operating System:${C.reset} ${process.platform} ${C.dim}(${compat.platform || 'unknown'})${C.reset}`,
+            `${C.amber}Compatibility:${C.reset}    ${C.red}Not supported${C.reset}`,
+            '',
+            `${C.white}${compat.reason || 'This engine is not supported on your current operating system.'}${C.reset}`,
+            '',
+            compat.installHint ? `${C.cyan}Hint:${C.reset} ${compat.installHint}` : '',
+            `${C.dim}Tip: LM Studio (lms) runs universally on Windows, macOS, and Linux.${C.reset}`,
+          ].filter(Boolean),
+        });
+        return 'HANDLED';
+      }
+
+      const model = targetModel || ctx.client.model || (engine === 'vllm' ? 'google/gemma-4-e4b' : 'google/gemma-4-e4b');
+
+      setActiveLocalEngine(engine);
+      const persistUpdate = { activeEngine: engine };
+      if (engine === 'lms') {
+        if (gpu !== undefined) persistUpdate.gpuOffload = gpu;
+        if (threads !== undefined) persistUpdate.cpuThreads = threads;
+        if (splitMode !== undefined) persistUpdate.splitMode = splitMode;
+        if (tensorSplit !== undefined) persistUpdate.tensorSplit = tensorSplit;
+        if (mainGpu !== undefined) persistUpdate.mainGpu = mainGpu;
+        if (flashAttn !== undefined) persistUpdate.flashAttn = flashAttn;
+        if (batchSize !== undefined) persistUpdate.batchSize = batchSize;
+        if (ubatchSize !== undefined) persistUpdate.ubatchSize = ubatchSize;
+        if (kvCacheDtype !== undefined) persistUpdate.kvCacheDtype = kvCacheDtype;
+      } else if (engine === 'vllm') {
+        persistUpdate.vllm = {};
+        if (memUtil !== undefined) persistUpdate.vllm.gpuMemoryUtilization = memUtil;
+        if (maxModelLen !== undefined) persistUpdate.vllm.maxModelLen = maxModelLen;
+        if (tp !== undefined) persistUpdate.vllm.tensorParallelSize = tp;
+        if (dtype !== undefined) persistUpdate.vllm.dtype = dtype;
+        if (enforceEager !== undefined) persistUpdate.vllm.enforceEager = enforceEager;
+        if (enablePrefixCaching !== undefined) persistUpdate.vllm.enablePrefixCaching = enablePrefixCaching;
+        if (kvCacheDtype !== undefined) persistUpdate.vllm.kvCacheDtype = kvCacheDtype;
+      }
+      savePersistedModelLoadSettings(persistUpdate);
+
+      const currentSettings = getPersistedModelLoadSettings();
+
+      ctx.setIsProcessing?.(true, `Loading model "${model}" on ${compat.name}…`);
+      console.log(`\n  ${C.cyberCyan}• Starting model load on engine:${C.reset} ${C.bold}${compat.name}${C.reset}`);
+      console.log(`  ${C.dim}Target Model:${C.reset} ${C.white}${model}${C.reset}`);
+      if (engine === 'lms') {
+        console.log(`  ${C.dim}Parameters:${C.reset} GPU Offload=${currentSettings.gpuOffload || 'auto'}, Threads=${currentSettings.cpuThreads || 'auto'}, SplitMode=${currentSettings.splitMode || 'layer'}, TensorSplit=${currentSettings.tensorSplit || 'auto'}, FlashAttn=${currentSettings.flashAttn !== false ? 'on' : 'off'}`);
+      } else {
+        console.log(`  ${C.dim}Parameters:${C.reset} Mem Util=${currentSettings.vllm.gpuMemoryUtilization}, Max Model Len=${currentSettings.vllm.maxModelLen || 'auto'}, TP=${currentSettings.vllm.tensorParallelSize}`);
+      }
+
+      const loadResult = await loadModelOnEngine(engine, model, {
+        gpuOffload: gpu !== undefined ? gpu : currentSettings.gpuOffload,
+        cpuThreads: threads !== undefined ? threads : currentSettings.cpuThreads,
+        splitMode: splitMode !== undefined ? splitMode : currentSettings.splitMode,
+        tensorSplit: tensorSplit !== undefined ? tensorSplit : currentSettings.tensorSplit,
+        mainGpu: mainGpu !== undefined ? mainGpu : currentSettings.mainGpu,
+        flashAttn: flashAttn !== undefined ? flashAttn : currentSettings.flashAttn,
+        batchSize: batchSize !== undefined ? batchSize : currentSettings.batchSize,
+        ubatchSize: ubatchSize !== undefined ? ubatchSize : currentSettings.ubatchSize,
+        gpuMemoryUtilization: memUtil !== undefined ? memUtil : currentSettings.vllm.gpuMemoryUtilization,
+        maxModelLen: maxModelLen !== undefined ? maxModelLen : currentSettings.vllm.maxModelLen,
+        tensorParallelSize: tp !== undefined ? tp : currentSettings.vllm.tensorParallelSize,
+        dtype: dtype !== undefined ? dtype : currentSettings.vllm.dtype,
+        enforceEager: enforceEager !== undefined ? enforceEager : currentSettings.vllm.enforceEager,
+        enablePrefixCaching: enablePrefixCaching !== undefined ? enablePrefixCaching : currentSettings.vllm.enablePrefixCaching,
+        kvCacheDtype: kvCacheDtype !== undefined ? kvCacheDtype : (engine === 'vllm' ? currentSettings.vllm.kvCacheDtype : currentSettings.kvCacheDtype),
+      });
+
+      if (!loadResult.ok) {
+        printRichCard({
+          title: `Engine Load Failed: ${compat.name}`,
+          status: 'error',
+          lines: [
+            `${C.red}Error:${C.reset}   ${loadResult.reason || 'Failed to start or load model.'}`,
+            loadResult.rawCommand ? `${C.dim}Command:${C.reset} ${C.cyan}${loadResult.rawCommand}${C.reset}` : '',
+          ].filter(Boolean),
+        });
+        return 'HANDLED';
+      }
+
+      const resolvedLoadedModel = loadResult.loadedModel || model;
+      if (engine === 'vllm' && ctx.client.provider !== 'vllm') {
+        try {
+          ctx.client.switchProvider?.('vllm', { model: resolvedLoadedModel });
+          if (ctx.agent?.client) ctx.agent.client.switchProvider?.('vllm', { model: resolvedLoadedModel });
+        } catch {}
+      } else if (engine === 'lms' && ctx.client.provider !== 'lmstudio') {
+        try {
+          ctx.client.switchProvider?.('lmstudio', { model: resolvedLoadedModel });
+          if (ctx.agent?.client) ctx.agent.client.switchProvider?.('lmstudio', { model: resolvedLoadedModel });
+        } catch {}
+      }
+
+      if (ctx.modelManager) {
+        ctx.modelManager.select(resolvedLoadedModel, [resolvedLoadedModel]);
+      }
+      ctx.client.setModel(resolvedLoadedModel);
+      ctx.setCatalogOnlyMode?.(false);
+      if (ctx.tuiPrompt) {
+        ctx.tuiPrompt.modelName = resolvedLoadedModel;
+        ctx.tuiPrompt.isConnected = true;
+        ctx.tuiPrompt.render();
+      }
+
+      printSolidPanel({
+        title: `Model Ready • ${compat.name}`,
+        lines: [
+          `${C.gold}Engine:${C.reset}     ${C.white}${compat.name}${C.reset} ${C.dim}(${compat.targetLevel === 'enterprise' ? 'Enterprise Data Center' : 'Universal 3-OS'})${C.reset}`,
+          `${C.gold}Model:${C.reset}      ${C.bold}${C.emerald}${resolvedLoadedModel}${C.reset}`,
+          `${C.gold}Port:${C.reset}       ${C.cyberCyan}${loadResult.engine === 'vllm' ? 8000 : 1234}${C.reset}`,
+          `${C.gold}Status:${C.reset}     ${C.emerald}● Active & Ready${C.reset}${loadResult.awakened ? ` ${C.dim}(Server auto-started)${C.reset}` : ''}`,
+          '',
+          `${C.dim}Run "/model status" to view detailed diagnostics or "/chat" to converse.${C.reset}`,
+        ],
+        headerBg: '\x1b[48;2;30;60;50m',
+        bg: '\x1b[48;2;20;35;30m',
+      });
+      return 'HANDLED';
+    }
+
+    if (action === 'stop') {
+      const { stopEngine } = await import('./engineService.js');
+      const target = (ctx.extra || '').trim().toLowerCase() || 'vllm';
+      ctx.setIsProcessing?.(true, `Stopping ${target} engine…`);
+      const res = await stopEngine(target);
+      if (res.ok) {
+        console.log(`\n  ${C.emerald}[OK] Engine "${target}" background process stopped successfully.${C.reset}\n`);
+      } else {
+        console.log(`\n  ${C.amber}[NOTICE] Engine "${target}" stop result: ${res.reason || 'Process not running'}.${C.reset}\n`);
+      }
+      return 'HANDLED';
+    }
+
+    if (action === 'unload') {
+      const { unloadModelFromEngine } = await import('./engineService.js');
+      const { getActiveLocalEngine } = await import('./config.js');
+      const targetArg = (ctx.extra || '').trim().toLowerCase();
+      const targetEngine = targetArg === 'vllm' ? 'vllm' : (targetArg === 'lms' || targetArg === 'lmstudio' ? 'lms' : getActiveLocalEngine() || 'lms');
+      const currentModel = ctx.client?.model || ctx.modelManager?.currentModel || null;
+      ctx.setIsProcessing?.(true, `Unloading model on ${targetEngine}…`);
+      const res = await unloadModelFromEngine(targetEngine, currentModel);
+      if (res.ok) {
+        console.log(`\n  ${C.emerald}[OK] Successfully unloaded model on ${targetEngine}. VRAM released.${C.reset}\n`);
+      } else {
+        console.log(`\n  ${C.amber}[NOTICE] Unload result: ${res.reason || res.message || 'Model could not be unloaded'}.${C.reset}\n`);
+      }
+      return 'HANDLED';
+    }
+
+    if (action === 'engine') {
+      const { checkEngineCompatibility } = await import('./engineService.js');
+      const { getActiveLocalEngine, setActiveLocalEngine } = await import('./config.js');
+
+      const targetArg = (ctx.extra || '').trim().toLowerCase();
+      if (targetArg) {
+        let validEngine = null;
+        if (targetArg === 'lms' || targetArg === 'lmstudio') validEngine = 'lms';
+        else if (targetArg === 'vllm') validEngine = 'vllm';
+
+        if (!validEngine) {
+          printRichCard({
+            title: 'Invalid Engine',
+            status: 'error',
+            lines: [
+              `${C.red}Unknown engine "${targetArg}".${C.reset}`,
+              `${C.dim}Supported local engines: "lms" (LM Studio) or "vllm" (vLLM on WSL2/Linux).${C.reset}`,
+            ],
+          });
+          return 'HANDLED';
+        }
+
+        const compat = checkEngineCompatibility(validEngine);
+        if (!compat.supported) {
+          printRichCard({
+            title: `Engine Incompatible: ${validEngine.toUpperCase()}`,
+            status: 'error',
+            lines: [
+              `${C.amber}Operating System:${C.reset} ${process.platform} ${C.dim}(${compat.platform || 'unknown'})${C.reset}`,
+              `${C.amber}Compatibility:${C.reset}    ${C.red}Not supported${C.reset}`,
+              '',
+              `${C.white}${compat.reason || 'This engine is not supported on your current operating system.'}${C.reset}`,
+              compat.installHint ? `${C.cyan}Hint:${C.reset} ${compat.installHint}` : '',
+            ].filter(Boolean),
+          });
+          return 'HANDLED';
+        }
+
+        setActiveLocalEngine(validEngine);
+        if (validEngine === 'vllm' && ctx.client.provider !== 'vllm') {
+          try {
+            ctx.client.switchProvider?.('vllm');
+            if (ctx.agent?.client) ctx.agent.client.switchProvider?.('vllm');
+          } catch {}
+        } else if (validEngine === 'lms' && ctx.client.provider !== 'lmstudio') {
+          try {
+            ctx.client.switchProvider?.('lmstudio');
+            if (ctx.agent?.client) ctx.agent.client.switchProvider?.('lmstudio');
+          } catch {}
+        }
+
+        printRichCard({
+          title: 'Active Engine Switched',
+          status: 'ok',
+          lines: [
+            `${C.gold}Active Engine:${C.reset} ${C.bold}${C.emerald}${compat.name}${C.reset} ${C.dim}(${validEngine})${C.reset}`,
+            `${C.gold}Platform:${C.reset}      ${C.white}${compat.targetLevel === 'enterprise' ? 'Enterprise Data Center (Linux / WSL2)' : 'Universal 3-OS (Windows, macOS, Linux)'}${C.reset}`,
+            `${C.gold}Default Port:${C.reset}  ${C.cyberCyan}${validEngine === 'vllm' ? 8000 : 1234}${C.reset}`,
+            '',
+            `${C.dim}Tip: Run "/model load <model>" to load model or "/model config" to adjust parameters.${C.reset}`,
+          ],
+        });
+        return 'HANDLED';
+      }
+
+      const activeEngine = getActiveLocalEngine() || 'lms';
+      const lmsCompat = checkEngineCompatibility('lms');
+      const vllmCompat = checkEngineCompatibility('vllm');
+
+      const probePort = async (url) => {
+        try {
+          const res = await fetch(url, { signal: AbortSignal.timeout(600) });
+          return res.ok || res.status < 500;
+        } catch {
+          return false;
+        }
+      };
+
+      ctx.setIsProcessing?.(true, 'Checking local engine ports…');
+      const [lmsReachable, vllmReachable] = await Promise.all([
+        probePort('http://127.0.0.1:1234/v1/models'),
+        probePort('http://127.0.0.1:8000/v1/models'),
+      ]);
+
+      printSolidPanel({
+        title: 'Local Inference Engines & Routing',
+        lines: [
+          `${C.gold}Active Local Engine:${C.reset} ${C.bold}${C.emerald}${activeEngine === 'vllm' ? vllmCompat.name : lmsCompat.name}${C.reset} ${C.dim}(${activeEngine})${C.reset}`,
+          '',
+          `${C.bold}${C.lavender}Available Engines:${C.reset}`,
+          `  ${activeEngine === 'lms' ? C.gold + '[x]' : C.dim + '[ ]'} ${C.white}LM Studio (llama.cpp)${C.reset} — Port 1234: ${lmsReachable ? C.emerald + '● Online' : C.dim + '○ Offline'}${C.reset} ${C.dim}(Universal 3-OS)${C.reset}`,
+          `  ${activeEngine === 'vllm' ? C.gold + '[x]' : C.dim + '[ ]'} ${C.white}vLLM (PagedAttention)${C.reset} — Port 8000: ${vllmReachable ? C.emerald + '● Online' : C.dim + '○ Offline'}${C.reset} ${C.dim}(${vllmCompat.supported ? 'Supported on ' + (process.platform === 'win32' ? 'WSL2' : 'Linux') : 'Not supported on this OS'})${C.reset}`,
+          '',
+          `${C.dim}Commands: /model engine lms | /model engine vllm | /model config | /model load <model>${C.reset}`,
+        ],
+        headerBg: '\x1b[48;2;30;60;50m',
+        bg: '\x1b[48;2;20;35;30m',
+      });
+      return 'HANDLED';
+    }
+
+    if (action === 'config' || action === 'params') {
+      const {
+        getActiveLocalEngine,
+        getPersistedModelLoadSettings,
+        savePersistedModelLoadSettings,
+        MODEL_LOAD_DEFAULTS,
+      } = await import('./config.js');
+
+      const rawArgs = (ctx.extra || '').trim();
+      const tokens = rawArgs ? rawArgs.split(/\s+/).filter(Boolean) : [];
+
+      if (tokens.includes('--reset')) {
+        savePersistedModelLoadSettings(MODEL_LOAD_DEFAULTS);
+        console.log(`\n  ${C.emerald}[OK] Model load parameters reset to factory defaults.${C.reset}\n`);
+      } else if (tokens.length > 0) {
+        let engine = undefined;
+        let gpu = undefined;
+        let threads = undefined;
+        let memUtil = undefined;
+        let maxModelLen = undefined;
+        let tp = undefined;
+        let dtype = undefined;
+        let enforceEager = undefined;
+        let enablePrefixCaching = undefined;
+        let splitMode = undefined;
+        let tensorSplit = undefined;
+        let mainGpu = undefined;
+        let flashAttn = undefined;
+        let batchSize = undefined;
+        let ubatchSize = undefined;
+        let kvCacheDtype = undefined;
+
+        for (let i = 0; i < tokens.length; i++) {
+          const tok = tokens[i];
+          if (tok === '--engine' && i + 1 < tokens.length) {
+            const e = tokens[++i].toLowerCase();
+            if (e === 'lms' || e === 'vllm' || e === 'lmstudio') engine = e === 'lmstudio' ? 'lms' : e;
+          } else if (tok === '--gpu' && i + 1 < tokens.length) {
+            gpu = tokens[++i];
+          } else if (tok === '--threads' && i + 1 < tokens.length) {
+            threads = Number(tokens[++i]);
+          } else if (tok === '--split-mode' && i + 1 < tokens.length) {
+            splitMode = tokens[++i].toLowerCase();
+          } else if ((tok === '--tensor-split' || tok === '-ts') && i + 1 < tokens.length) {
+            tensorSplit = tokens[++i];
+          } else if ((tok === '--main-gpu' || tok === '-mg') && i + 1 < tokens.length) {
+            mainGpu = Number(tokens[++i]);
+          } else if (tok === '--fa' || tok === '--flash-attn') {
+            flashAttn = true;
+          } else if (tok === '--no-fa' || tok === '--no-flash-attn') {
+            flashAttn = false;
+          } else if ((tok === '-b' || tok === '--batch-size') && i + 1 < tokens.length) {
+            batchSize = Number(tokens[++i]);
+          } else if ((tok === '-ub' || tok === '--ubatch-size') && i + 1 < tokens.length) {
+            ubatchSize = Number(tokens[++i]);
+          } else if ((tok === '--ctk' || tok === '--kv-cache') && i + 1 < tokens.length) {
+            kvCacheDtype = tokens[++i].toLowerCase();
+          } else if ((tok === '--mem-util' || tok === '--gpu-mem-util') && i + 1 < tokens.length) {
+            memUtil = Number(tokens[++i]);
+          } else if (tok === '--max-model-len' && i + 1 < tokens.length) {
+            maxModelLen = Number(tokens[++i]);
+          } else if (tok === '--tp' && i + 1 < tokens.length) {
+            tp = Number(tokens[++i]);
+          } else if (tok === '--dtype' && i + 1 < tokens.length) {
+            dtype = tokens[++i].toLowerCase();
+          } else if (tok === '--enforce-eager') {
+            enforceEager = true;
+          } else if (tok === '--no-enforce-eager') {
+            enforceEager = false;
+          } else if (tok === '--prefix-caching') {
+            enablePrefixCaching = true;
+          } else if (tok === '--no-prefix-caching') {
+            enablePrefixCaching = false;
+          }
+        }
+
+        const updatePayload = {};
+        if (engine !== undefined) updatePayload.activeEngine = engine;
+        if (gpu !== undefined) updatePayload.gpuOffload = gpu;
+        if (threads !== undefined) updatePayload.cpuThreads = threads;
+        if (splitMode !== undefined) updatePayload.splitMode = splitMode;
+        if (tensorSplit !== undefined) updatePayload.tensorSplit = tensorSplit;
+        if (mainGpu !== undefined) updatePayload.mainGpu = mainGpu;
+        if (flashAttn !== undefined) updatePayload.flashAttn = flashAttn;
+        if (batchSize !== undefined) updatePayload.batchSize = batchSize;
+        if (ubatchSize !== undefined) updatePayload.ubatchSize = ubatchSize;
+        if (kvCacheDtype !== undefined) updatePayload.kvCacheDtype = kvCacheDtype;
+
+        if (memUtil !== undefined || maxModelLen !== undefined || tp !== undefined || dtype !== undefined || enforceEager !== undefined || enablePrefixCaching !== undefined || (kvCacheDtype !== undefined && updatePayload.activeEngine === 'vllm')) {
+          updatePayload.vllm = {};
+          if (memUtil !== undefined) updatePayload.vllm.gpuMemoryUtilization = memUtil;
+          if (maxModelLen !== undefined) updatePayload.vllm.maxModelLen = maxModelLen;
+          if (tp !== undefined) updatePayload.vllm.tensorParallelSize = tp;
+          if (dtype !== undefined) updatePayload.vllm.dtype = dtype;
+          if (enforceEager !== undefined) updatePayload.vllm.enforceEager = enforceEager;
+          if (enablePrefixCaching !== undefined) updatePayload.vllm.enablePrefixCaching = enablePrefixCaching;
+          if (kvCacheDtype !== undefined) updatePayload.vllm.kvCacheDtype = kvCacheDtype;
+        }
+
+        savePersistedModelLoadSettings(updatePayload);
+        console.log(`\n  ${C.emerald}[OK] Model load parameters updated successfully.${C.reset}\n`);
+      }
+
+      const activeEngine = getActiveLocalEngine() || 'lms';
+      const settings = getPersistedModelLoadSettings();
+
+      printSolidPanel({
+        title: 'Local Inference Engine Parameters',
+        lines: [
+          `${C.gold}Active Engine:${C.reset} ${C.bold}${C.white}${activeEngine.toUpperCase()}${C.reset}`,
+          '',
+          `${C.bold}${C.lavender}LM Studio & Multi-GPU Configuration (llama.cpp):${C.reset}`,
+          `  ${C.dim}• GPU Offload (--gpu):${C.reset}       ${C.white}${settings.gpuOffload || 'auto'}${C.reset}`,
+          `  ${C.dim}• CPU Threads (--threads):${C.reset}   ${C.white}${settings.cpuThreads !== null ? settings.cpuThreads : 'auto (4)'}${C.reset}`,
+          `  ${C.dim}• Flash Attention (--fa):${C.reset}    ${settings.flashAttn !== false ? C.emerald + 'Enabled' : C.amber + 'Disabled'}${C.reset}`,
+          `  ${C.dim}• Split Mode (--split-mode):${C.reset} ${C.white}${settings.splitMode || 'layer'}${C.reset}`,
+          `  ${C.dim}• Tensor Split (-ts):${C.reset}        ${C.white}${settings.tensorSplit || 'auto (equal)'}${C.reset}`,
+          `  ${C.dim}• Main GPU (--main-gpu):${C.reset}      ${C.white}${settings.mainGpu ?? 0}${C.reset}`,
+          `  ${C.dim}• Batch / uBatch (-b / -ub):${C.reset}  ${C.white}${settings.batchSize || 2048} / ${settings.ubatchSize || 512}${C.reset}`,
+          `  ${C.dim}• KV Cache Type (--ctk):${C.reset}      ${C.white}${settings.kvCacheDtype || 'auto'}${C.reset}`,
+          '',
+          `${C.bold}${C.lavender}vLLM Configuration (PagedAttention):${C.reset}`,
+          `  ${C.dim}• GPU Memory Util (--mem-util):${C.reset} ${C.white}${settings.vllm.gpuMemoryUtilization} (${Math.round(settings.vllm.gpuMemoryUtilization * 100)}%)${C.reset}`,
+          `  ${C.dim}• Max Model Len (--max-model-len):${C.reset} ${C.white}${settings.vllm.maxModelLen || 'auto (model default)'}${C.reset}`,
+          `  ${C.dim}• Tensor Parallel (--tp):${C.reset}     ${C.white}${settings.vllm.tensorParallelSize}${C.reset}`,
+          `  ${C.dim}• Dtype (--dtype):${C.reset}             ${C.white}${settings.vllm.dtype || 'auto'}${C.reset}`,
+          `  ${C.dim}• Enforce Eager:${C.reset}                 ${settings.vllm.enforceEager ? C.emerald + 'Enabled' : C.dim + 'Disabled'}${C.reset}`,
+          `  ${C.dim}• Prefix Caching:${C.reset}               ${settings.vllm.enablePrefixCaching ? C.emerald + 'Enabled' : C.dim + 'Disabled'}${C.reset}`,
+          '',
+          `${C.dim}Update: /model config --gpu max --threads 8 | /model config --split-mode layer --tensor-split 20,12 --fa | /model config --reset${C.reset}`,
+        ],
+        headerBg: '\x1b[48;2;40;48;68m',
+        bg: '\x1b[48;2;28;34;48m',
+      });
+      return 'HANDLED';
+    }
+
+    if (action === 'preset' || action === 'presets') {
+      const {
+        savePersistedProviderBaseUrl,
+      } = await import('./config.js');
+
+      const PRESETS = [
+        { id: 'gemma4', name: 'Local LM Studio (Gemma 4 E4B)', provider: 'lmstudio', model: 'google/gemma-4-e4b', baseUrl: 'http://127.0.0.1:1234/v1', desc: 'Universal local inference via llama.cpp (Port 1234)' },
+        { id: 'vllm', name: 'vLLM WSL2 (Gemma 4 E4B)', provider: 'vllm', model: 'google/gemma-4-e4b', baseUrl: 'http://127.0.0.1:8000/v1', desc: 'Enterprise PagedAttention engine on WSL2/Linux (Port 8000)' },
+        { id: 'qwen', name: 'Ollama Local (Qwen 2.5 7B)', provider: 'custom', model: 'qwen2.5:7b', baseUrl: 'http://127.0.0.1:11434/v1', desc: 'Local Ollama instance on port 11434' },
+        { id: 'gemini', name: 'Google Gemini 3.7 Flash', provider: 'gemini', model: 'gemini-3.7-flash', baseUrl: '', desc: 'High-speed cloud multimodal reasoning' },
+        { id: 'groq', name: 'Groq GPT-OSS 120B', provider: 'groq', model: 'openai/gpt-oss-120b', baseUrl: '', desc: 'Ultra-fast LPU inference' },
+        { id: 'deepseek', name: 'DeepSeek V4 Flash', provider: 'deepseek', model: 'deepseek-v4-flash', baseUrl: '', desc: 'State-of-the-art cost-effective reasoning' },
+        { id: 'luna', name: 'OpenAI GPT-5.6 Luna', provider: 'openai', model: 'gpt-5.6-luna', baseUrl: '', desc: 'Flagship reasoning model' },
+        { id: 'openrouter', name: 'OpenRouter Auto', provider: 'openrouter', model: 'openrouter/auto', baseUrl: '', desc: 'Unified multi-provider fallback gateway' },
+      ];
+
+      const targetPresetId = (ctx.extra || '').trim().toLowerCase();
+      if (targetPresetId) {
+        const found = PRESETS.find(p => p.id === targetPresetId || p.id.includes(targetPresetId) || p.provider === targetPresetId);
+        if (!found) {
+          printRichCard({
+            title: 'Preset Not Found',
+            status: 'error',
+            lines: [
+              `${C.red}Unknown preset "${targetPresetId}".${C.reset}`,
+              `${C.dim}Available presets: ${PRESETS.map(p => p.id).join(', ')}${C.reset}`,
+            ],
+          });
+          return 'HANDLED';
+        }
+
+        try {
+          if (found.baseUrl) {
+            savePersistedProviderBaseUrl(found.provider, found.baseUrl);
+          }
+          if (ctx.client.switchProvider) {
+            ctx.client.switchProvider(found.provider, { model: found.model, baseUrl: found.baseUrl || undefined });
+          }
+          if (ctx.agent?.client?.switchProvider) {
+            ctx.agent.client.switchProvider(found.provider, { model: found.model, baseUrl: found.baseUrl || undefined });
+          }
+          if (ctx.modelManager) {
+            ctx.modelManager.select(found.model, [found.model]);
+          }
+          ctx.setCatalogOnlyMode?.(false);
+          if (ctx.tuiPrompt) {
+            ctx.tuiPrompt.modelName = found.model;
+            ctx.tuiPrompt.isConnected = true;
+            ctx.tuiPrompt.render();
+          }
+
+          printSolidPanel({
+            title: `Preset Applied • ${found.name}`,
+            lines: [
+              `${C.gold}Provider:${C.reset} ${C.white}${found.provider}${C.reset}`,
+              `${C.gold}Model:${C.reset}    ${C.bold}${C.emerald}${found.model}${C.reset}`,
+              `${C.gold}Endpoint:${C.reset} ${found.baseUrl ? C.cyberCyan + found.baseUrl : C.dim + '(Cloud Default)'}${C.reset}`,
+              `${C.gold}Notes:${C.reset}    ${C.dim}${found.desc}${C.reset}`,
+              '',
+              `${C.dim}Tip: Run "/model ping" or "/chat" to start.${C.reset}`,
+            ],
+            headerBg: '\x1b[48;2;30;60;50m',
+            bg: '\x1b[48;2;20;35;30m',
+          });
+        } catch (err) {
+          console.log(`\n  ${C.red}[PRESET ERROR] ${err.message || String(err)}${C.reset}\n`);
+        }
+        return 'HANDLED';
+      }
+
+      printSolidPanel({
+        title: 'Curated Model Presets',
+        lines: [
+          `${C.dim}Quick 1-click model and provider setups matching Web Chat:${C.reset}`,
+          '',
+          ...PRESETS.map(p => {
+            const isCurrent = ctx.client.provider === p.provider && (ctx.client.model === p.model || (ctx.client.model && ctx.client.model.includes(p.model)));
+            const marker = isCurrent ? `${C.gold}[x]${C.reset}` : `${C.dim}[ ]${C.reset}`;
+            return `  ${marker} ${C.bold}${C.white}${p.id.padEnd(12)}${C.reset} ${C.emerald}${p.model.padEnd(26)}${C.reset} ${C.dim}${p.desc}${C.reset}`;
+          }),
+          '',
+          `${C.dim}Apply preset: /model preset <id> (e.g. /model preset gemma4, /model preset luna)${C.reset}`,
+        ],
+        headerBg: '\x1b[48;2;48;40;60m',
+        bg: '\x1b[48;2;34;28;42m',
+      });
+      return 'HANDLED';
+    }
+
+    if (action === 'files' || action === 'gguf') {
+      const { listInstalledGgufs } = await import('./modelConfig.js');
+      ctx.setIsProcessing?.(true, 'Scanning local storage for installed GGUF models…');
+      const models = listInstalledGgufs(true);
+
+      if (models.length === 0) {
+        printRichCard({
+          title: 'Installed GGUF Models (0 Discovered)',
+          status: 'info',
+          lines: [
+            `${C.amber}No local .gguf models discovered.${C.reset}`,
+            '',
+            `${C.dim}Searched standard directories:${C.reset}`,
+            `  • ~/.lmstudio/models`,
+            `  • ~/.cache/lm-studio/models`,
+            `  • Custom LM Studio model directory`,
+            '',
+            `${C.dim}Tip: Download models via LM Studio or copy .gguf files to ~/.lmstudio/models${C.reset}`,
+          ],
+        });
+        return 'HANDLED';
+      }
+
+      const lines = models.slice(0, 30).map((m, idx) => {
+        const num = String(idx + 1).padStart(2, ' ');
+        const isCurrent = ctx.client.model && ctx.client.model.toLowerCase().includes(m.fileName.toLowerCase());
+        const marker = isCurrent ? `${C.gold}[x]${C.reset}` : `${C.dim}[ ]${C.reset}`;
+        return `  ${marker} ${C.dim}${num}.${C.reset} ${C.bold}${C.white}${m.fileName}${C.reset} ${C.slate}${m.quant || 'GGUF'}${C.reset} ${C.cyberCyan}${m.sizeGb} GB${C.reset}`;
+      });
+
+      printSolidPanel({
+        title: `Installed GGUF Models (${models.length} on disk)`,
+        lines: [
+          ...lines,
+          '',
+          `${C.dim}Load model: /model load <filename> (e.g. /model load ${models[0]?.fileName || 'model.gguf'})${C.reset}`,
+        ],
+        headerBg: '\x1b[48;2;36;52;68m',
+        bg: '\x1b[48;2;24;36;48m',
+      });
+      return 'HANDLED';
+    }
+
+    if (action === 'temp' || action === 'temperature') {
+      const { getPersistedInferenceSettings, savePersistedInferenceSettings } = await import('./config.js');
+      const valArg = (ctx.extra || '').trim();
+      if (valArg) {
+        const num = Number(valArg);
+        if (Number.isFinite(num) && num >= 0 && num <= 2) {
+          savePersistedInferenceSettings({ temperature: num });
+          console.log(`\n  ${C.emerald}[OK] Inference Temperature updated to ${num.toFixed(2)}.${C.reset}\n`);
+        } else {
+          console.log(`\n  ${C.amber}[NOTICE] Temperature must be between 0.0 and 2.0 (e.g. /model temp 0.7).${C.reset}\n`);
+        }
+      }
+      const current = getPersistedInferenceSettings();
+      console.log(`  ${C.gold}Current Temperature:${C.reset} ${C.bold}${C.white}${current.temperature}${C.reset} ${C.dim}(0.20 Precise, 0.70 Balanced, 0.95 Creative)${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    if (action === 'topp') {
+      const { getPersistedInferenceSettings, savePersistedInferenceSettings } = await import('./config.js');
+      const valArg = (ctx.extra || '').trim();
+      if (valArg) {
+        const num = Number(valArg);
+        if (Number.isFinite(num) && num >= 0.01 && num <= 1) {
+          savePersistedInferenceSettings({ topP: num });
+          console.log(`\n  ${C.emerald}[OK] Inference Top-P updated to ${num.toFixed(2)}.${C.reset}\n`);
+        } else {
+          console.log(`\n  ${C.amber}[NOTICE] Top-P must be between 0.01 and 1.0 (e.g. /model topp 0.95).${C.reset}\n`);
+        }
+      }
+      const current = getPersistedInferenceSettings();
+      console.log(`  ${C.gold}Current Top-P:${C.reset} ${C.bold}${C.white}${current.topP}${C.reset} ${C.dim}(Nucleus Sampling cutoff)${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    if (action === 'minp') {
+      const { getPersistedInferenceSettings, savePersistedInferenceSettings } = await import('./config.js');
+      const valArg = (ctx.extra || '').trim();
+      if (valArg) {
+        const num = Number(valArg);
+        if (Number.isFinite(num) && num >= 0 && num <= 1) {
+          savePersistedInferenceSettings({ minP: num });
+          console.log(`\n  ${C.emerald}[OK] Inference Min-P updated to ${num.toFixed(2)}.${C.reset}\n`);
+        } else {
+          console.log(`\n  ${C.amber}[NOTICE] Min-P must be between 0.00 and 1.00 (e.g. /model minp 0.08).${C.reset}\n`);
+        }
+      }
+      const current = getPersistedInferenceSettings();
+      console.log(`  ${C.gold}Current Min-P:${C.reset} ${C.bold}${C.white}${current.minP}${C.reset} ${C.dim}(Dynamic probability threshold filter, recommended: 0.05 - 0.10)${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    if (action === 'repeat' || action === 'repeatpenalty' || action === 'rep') {
+      const { getPersistedInferenceSettings, savePersistedInferenceSettings } = await import('./config.js');
+      const valArg = (ctx.extra || '').trim();
+      if (valArg) {
+        const num = Number(valArg);
+        if (Number.isFinite(num) && num >= 1.0 && num <= 2.0) {
+          savePersistedInferenceSettings({ repeatPenalty: num });
+          console.log(`\n  ${C.emerald}[OK] Inference Repeat Penalty updated to ${num.toFixed(2)}.${C.reset}\n`);
+        } else {
+          console.log(`\n  ${C.amber}[NOTICE] Repeat Penalty must be between 1.00 and 2.00 (e.g. /model repeat 1.10).${C.reset}\n`);
+        }
+      }
+      const current = getPersistedInferenceSettings();
+      console.log(`  ${C.gold}Current Repeat Penalty:${C.reset} ${C.bold}${C.white}${current.repeatPenalty}${C.reset} ${C.dim}(1.00 Disabled, 1.10 Balanced, 1.20 Strong suppression)${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    if (action === 'ctx' || action === 'context') {
+      const { getPersistedInferenceSettings, savePersistedInferenceSettings } = await import('./config.js');
+      const valArg = (ctx.extra || '').trim().toLowerCase();
+      if (valArg) {
+        let parsed = Number(valArg);
+        if (valArg === '4k') parsed = 4096;
+        else if (valArg === '8k') parsed = 8192;
+        else if (valArg === '16k') parsed = 16384;
+        else if (valArg === '32k') parsed = 32768;
+        else if (valArg === '64k') parsed = 65536;
+        else if (valArg === '128k') parsed = 131072;
+
+        if (Number.isFinite(parsed) && parsed >= 1024 && parsed <= 131072) {
+          savePersistedInferenceSettings({ contextLimit: parsed });
+          console.log(`\n  ${C.emerald}[OK] Context Window Limit updated to ${parsed.toLocaleString()} tokens.${C.reset}\n`);
+        } else {
+          console.log(`\n  ${C.amber}[NOTICE] Context limit must be between 1024 and 131072 (e.g. 4k, 8k, 16k, 32k, 64k, 128k).${C.reset}\n`);
+        }
+      }
+      const current = getPersistedInferenceSettings();
+      console.log(`  ${C.gold}Current Context Window Limit:${C.reset} ${C.bold}${C.white}${current.contextLimit.toLocaleString()} tokens${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    if (action === 'thinking') {
+      const { getPersistedInferenceSettings, savePersistedInferenceSettings } = await import('./config.js');
+      const valArg = (ctx.extra || '').trim().toLowerCase();
+      if (valArg) {
+        if (['show', 'collapse', 'hide'].includes(valArg)) {
+          savePersistedInferenceSettings({ thinking: valArg });
+          console.log(`\n  ${C.emerald}[OK] Thinking mode updated to "${valArg}".${C.reset}\n`);
+        } else {
+          console.log(`\n  ${C.amber}[NOTICE] Thinking mode must be one of: show, collapse, hide.${C.reset}\n`);
+        }
+      }
+      const current = getPersistedInferenceSettings();
+      console.log(`  ${C.gold}Current Thinking Mode:${C.reset} ${C.bold}${C.white}${current.thinking}${C.reset} ${C.dim}(show: Full CoT, collapse: Compact, hide: Direct Answer)${C.reset}\n`);
+      return 'HANDLED';
+    }
+
     if (action === 'ping') {
       try {
         const start = Date.now();
@@ -2610,8 +3442,14 @@ export const handlers = {
       return 'HANDLED';
     }
 
+    const nonModelActions = new Set([
+      'status', 'diag', 'diagnostics', 'engine', 'config', 'params',
+      'preset', 'presets', 'files', 'gguf', 'temp', 'temperature',
+      'topp', 'minp', 'repeat', 'repeatpenalty', 'rep', 'ctx', 'context',
+      'thinking', 'unload', 'stop', 'ping', 'reconnect', 'recommend', 'rec', 'list'
+    ]);
     const isDirectUse = action === 'use';
-    const targetModel = isDirectUse ? (ctx.extra?.trim() || '') : (!['status', 'diag', 'diagnostics'].includes(action) ? rawSub : '');
+    const targetModel = isDirectUse ? (ctx.extra?.trim() || '') : (!nonModelActions.has(action) ? rawSub : '');
 
     if (targetModel) {
       try {
@@ -2665,17 +3503,31 @@ export const handlers = {
       return 'HANDLED';
     }
 
+    const {
+      getActiveLocalEngine,
+      getPersistedModelLoadSettings,
+      getPersistedInferenceSettings,
+    } = await import('./config.js');
+    const activeEngine = getActiveLocalEngine() || 'lms';
+    const loadSettings = getPersistedModelLoadSettings();
+    const infSettings = getPersistedInferenceSettings();
+
     printSolidPanel({
       title: `${providerName} Diagnostics`,
       lines: [
-        `${C.gold}Provider:${C.reset}  ${C.white}${ctx.client.providerName || 'LM Studio'}${C.reset}`,
-        `${C.gold}Status:${C.reset}    ${liveCheck.connected ? C.emerald + '● Online' : C.red + '○ Offline'}${C.reset}${liveCheck.latencyMs ? ` ${C.dim}(${liveCheck.latencyMs}ms)${C.reset}` : ''}`,
-        `${C.gold}State:${C.reset}     ${C.white}${liveCheck.state || 'ready'}${C.reset}`,
-        `${C.gold}Model:${C.reset}     ${C.bold}${C.white}${ctx.client.model || 'None'}${C.reset}`,
-        `${C.gold}Available:${C.reset} ${C.white}${liveCheck.models?.length || 0} model(s)${C.reset}`,
-        `${C.gold}URL:${C.reset}       ${C.cyberCyan}${ctx.baseUrl}${C.reset}`,
+        `${C.gold}Provider:${C.reset}      ${C.white}${ctx.client.providerName || 'LM Studio'}${C.reset}`,
+        `${C.gold}Status:${C.reset}        ${liveCheck.connected ? C.emerald + '● Online' : C.red + '○ Offline'}${C.reset}${liveCheck.latencyMs ? ` ${C.dim}(${liveCheck.latencyMs}ms)${C.reset}` : ''}`,
+        `${C.gold}State:${C.reset}         ${C.white}${liveCheck.state || 'ready'}${C.reset}`,
+        `${C.gold}Model:${C.reset}         ${C.bold}${C.white}${ctx.client.model || 'None'}${C.reset}`,
+        `${C.gold}Available:${C.reset}     ${C.white}${liveCheck.models?.length || 0} model(s)${C.reset}`,
+        `${C.gold}URL:${C.reset}           ${C.cyberCyan}${ctx.baseUrl}${C.reset}`,
         '',
-        `${C.dim}Commands: /model list | /model use <id> | /model recommend | /model reconnect${C.reset}`
+        `${C.bold}${C.lavender}Engine & Inference Settings:${C.reset}`,
+        `  ${C.dim}• Active Local Engine:${C.reset} ${C.white}${activeEngine.toUpperCase()}${C.reset} ${C.dim}(LM Studio :1234 | vLLM :8000)${C.reset}`,
+        `  ${C.dim}• Load Parameters:${C.reset}     ${activeEngine === 'lms' ? `GPU Offload=${loadSettings.gpuOffload}, Threads=${loadSettings.cpuThreads !== null ? loadSettings.cpuThreads : 'auto'}, SplitMode=${loadSettings.splitMode || 'layer'}, FlashAttn=${loadSettings.flashAttn !== false ? 'on' : 'off'}` : `Mem Util=${loadSettings.vllm.gpuMemoryUtilization}, MaxLen=${loadSettings.vllm.maxModelLen || 'auto'}, TP=${loadSettings.vllm.tensorParallelSize}`}`,
+        `  ${C.dim}• Inference Settings:${C.reset}  Temp=${infSettings.temperature}, Top-P=${infSettings.topP}, Min-P=${infSettings.minP}, RepeatPenalty=${infSettings.repeatPenalty}, CtxLimit=${infSettings.contextLimit.toLocaleString()}, Thinking=${infSettings.thinking}`,
+        '',
+        `${C.dim}Commands: /model engine | /model config | /model preset | /model files | /model list | /model use <id>${C.reset}`
       ],
       headerBg: '\x1b[48;2;48;54;70m', bg: '\x1b[48;2;36;40;52m'
     });
@@ -3107,6 +3959,55 @@ export const handlers = {
     return 'HANDLED';
   },
 
+  '/process': async (ctx) => {
+    const { listBackgroundProcesses, stopBackgroundProcess } = await import('./processManager.js');
+    const sub = (ctx.sub || 'list').toLowerCase();
+    if (sub === 'kill' || sub === 'stop') {
+      const target = (ctx.extra || '').trim();
+      if (!target) {
+        console.log(`\n  ${C.amber}Usage: /process kill <name|pid>${C.reset}\n`);
+        return 'HANDLED';
+      }
+      const res = stopBackgroundProcess(target);
+      if (res.ok) {
+        console.log(`\n  ${C.emerald}[OK] Process "${target}" (PID: ${res.pid}) terminated cleanly.${C.reset}\n`);
+      } else {
+        console.log(`\n  ${C.amber}[FAILED] ${res.reason || `Could not kill process "${target}"`}.${C.reset}\n`);
+      }
+      return 'HANDLED';
+    }
+
+    const procs = listBackgroundProcesses();
+    if (procs.length === 0) {
+      printSolidPanel({
+        title: 'Background Process Manager',
+        lines: [
+          `${C.dim}No background processes currently tracked.${C.reset}`,
+          `${C.slate}PIDs are automatically registered when starting engines (vLLM, LM Studio) or background tasks.${C.reset}`,
+        ],
+      });
+      return 'HANDLED';
+    }
+
+    const lines = [];
+    for (const p of procs) {
+      const statusStr = p.isAlive ? `${C.emerald}RUNNING${C.reset}` : `${C.roseGlow}STOPPED${C.reset}`;
+      lines.push(`${C.gold}Name:${C.reset}    ${C.white}${p.name}${C.reset} (PID: ${C.bold}${p.pid}${C.reset}) • ${statusStr}`);
+      lines.push(`${C.gold}Uptime:${C.reset}  ${p.uptimeSeconds}s`);
+      if (p.command) lines.push(`${C.gold}Command:${C.reset} ${C.dim}${p.command}${C.reset}`);
+      lines.push('');
+    }
+    if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+
+    printSolidPanel({
+      title: `Tracked Background Processes (${procs.length})`,
+      lines,
+      headerBg: '\x1b[48;2;48;54;70m',
+      bg: '\x1b[48;2;36;40;52m',
+    });
+    return 'HANDLED';
+  },
+
   '/gpu': async (ctx) => {
     ctx.setIsProcessing?.(true, 'Probing hardware…');
     const gpuData = await getGpuMetrics().catch(() => ({ available: false }));
@@ -3226,14 +4127,15 @@ export const handlers = {
       const argTokens = String(sub === 'check' ? (extra || '') : [sub, extra].filter(Boolean).join(' '))
         .trim().split(/\s+/).filter(Boolean);
       const { overrides, positional, force } = parseVramArgs(argTokens);
-      const target = positional.join(' ');
+      const target = positional.join(' ').trim();
       let modelName = null;
       let modelPath = null;
-      if (target) {
+      const isPlaceholder = !target || /^<.*>$/.test(target);
+      if (!isPlaceholder) {
         if (/\.gguf$/i.test(target)) modelPath = target;
         else modelName = target;
       } else {
-        modelName = ctx.agent?.client?.model || null;
+        modelName = ctx.agent?.client?.model || 'google/gemma-4-e4b';
       }
 
       const result = await computeVramEstimate({ model: modelName, modelPath, ...overrides });
@@ -3603,11 +4505,21 @@ export const handlers = {
 
   '/quiz': async (ctx) => {
     const { sub, extra } = ctx;
-    const langArg = (sub === 'lang' ? extra : sub || '').toLowerCase().trim();
+    const rawArgs = [sub, extra].filter(Boolean).join(' ').toLowerCase();
+    const isMcp = rawArgs.includes('mcp');
+    const langTokens = rawArgs.split(/\s+/).filter(t => ['th', 'en', 'zh'].includes(t));
+    const langArg = (sub === 'lang' ? extra : langTokens[0] || 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);
+    const i18n = isMcp ? (MCP_QUIZ_I18N[quizLang] || MCP_QUIZ_I18N.en) : (QUIZ_I18N[quizLang] || QUIZ_I18N.en);
+    const questionsSource = isMcp ? MCP_QUIZ_QUESTIONS : QUIZ_QUESTIONS;
+    const shuffled = isMcp ? shuffleMcpQuizQuestions(MCP_QUIZ_QUESTIONS) : shuffleQuizQuestions(QUIZ_QUESTIONS);
+    const targetScore = questionsSource.length;
+    const challengeEndpoint = isMcp ? '/api/v1/mcp/quiz/challenge' : '/api/v1/quiz/challenge';
+    const claimEndpoint = isMcp ? '/api/v1/mcp/keys/claim' : '/api/v1/keys/claim';
+    const keyPref = isMcp ? 'mcpKey' : 'vipKey';
+    const keyPrefix = isMcp ? 'kiku_mcp_sk_' : 'kiku_vip_sk_';
+
     let score = 0;
     let challengeToken = null;
     let isOnline = false;
@@ -3616,17 +4528,16 @@ export const handlers = {
       title: i18n.title,
       lines: [
         `${C.bold}${C.white}${i18n.subtitle}${C.reset}`,
-        `${C.dim}Language: ${quizLang.toUpperCase()} | Questions: 15 | Target: 15/15${C.reset}`,
+        `${C.dim}Language: ${quizLang.toUpperCase()} | Questions: ${targetScore} | Target: ${targetScore}/${targetScore}${C.reset}`,
       ],
-      bg: '\x1b[48;2;48;40;60m'
+      bg: isMcp ? '\x1b[48;2;60;36;68m' : '\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 });
+      const res = await fetch(`${baseUrl}${challengeEndpoint}`, { signal: controller.signal });
       if (res.ok) {
         const json = await res.json();
         challengeToken = json.data?.challengeToken;
@@ -3662,8 +4573,8 @@ export const handlers = {
     const askQuestion = () => {
       if (typeof ctx.readInput === 'function') {
         return ctx.readInput({
-          prompt: i18n.answerPrompt,
-          placeholder: i18n.answerPlaceholder,
+          prompt: i18n.answerPrompt || 'Answer ❯ ',
+          placeholder: i18n.answerPlaceholder || 'A, B, C, D (or h for hint)',
           history: false,
           cancelValue: 'q',
         });
@@ -3676,7 +4587,7 @@ export const handlers = {
       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 qText = typeof numberedText === 'string' ? numberedText.replace(/^\s*\d+[.)]\s*/, '') : numberedText;
         const opts = q.options[quizLang] || q.options.en;
 
         printSolidPanel({
@@ -3686,7 +4597,7 @@ export const handlers = {
             '',
             ...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'
+          bg: isMcp ? '\x1b[48;2;48;32;58m' : '\x1b[48;2;36;40;52m'
         });
 
         let answeredCorrectly = false;
@@ -3708,7 +4619,7 @@ export const handlers = {
           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}`);
+            console.log(`  ${C.amber}${i18n.invalidAnswer || 'Please answer A, B, C, or D (or h for hint)'}${C.reset}`);
             continue;
           }
 
@@ -3737,17 +4648,17 @@ export const handlers = {
     }
 
     if (cancelled) {
-      console.log(`  ${C.amber}${i18n.cancelled}${C.reset}`);
+      console.log(`  ${C.amber}${i18n.cancelled || 'Quiz 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}`],
+      lines: [`${C.bold}${score === targetScore ? C.emerald : C.amber}${score === targetScore ? 'Perfect Score!' : `${score}/${targetScore} — Need ${targetScore}/${targetScore} to claim a ${isMcp ? 'MCP' : '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`);
+    if (score < targetScore) {
+      console.log(`\n  ${C.dim}Run ${C.cyberCyan}/quiz${isMcp ? ' mcp' : ''}${C.reset}${C.dim} to try again.${C.reset}\n`);
       return 'HANDLED';
     }
 
@@ -3755,10 +4666,9 @@ export const handlers = {
 
     let key = null;
 
-
     if (isOnline && challengeToken) {
       try {
-        const res = await fetch(`${baseUrl}/api/v1/keys/claim`, {
+        const res = await fetch(`${baseUrl}${claimEndpoint}`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({ score, answers, challengeToken })
@@ -3772,17 +4682,24 @@ export const handlers = {
       }
     }
 
-
     if (!key) {
       const token = crypto.randomBytes(16).toString('hex');
-      key = `kiku_vip_sk_${token}`;
+      key = `${keyPrefix}${token}`;
     }
 
-    ctx.agent?.memory?.setPreference('vipKey', key);
+    ctx.agent?.memory?.setPreference(keyPref, key);
 
     printSolidPanel({
       title: `${i18n.congratsTitle}`,
-      lines: [
+      lines: isMcp ? [
+        `${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 'Authorization: Bearer ${key}' on POST /mcp${C.reset}`,
+        `${C.dim}Key saved. Run ${C.cyberCyan}/mcp-key config${C.reset}${C.dim} to view Claude Desktop & Cursor JSON configuration.${C.reset}`,
+      ] : [
         `${C.bold}${C.white}${i18n.congratsDesc}${C.reset}`,
         '',
         `${C.bold}${C.roseGlow}${i18n.keyLabel}:${C.reset}`,
@@ -3791,7 +4708,7 @@ export const handlers = {
         `${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'
+      bg: isMcp ? '\x1b[48;2;60;36;68m' : '\x1b[48;2;48;40;60m'
     });
 
     return 'HANDLED';
@@ -3809,7 +4726,7 @@ export const handlers = {
     }
 
     if (action === 'apply') {
-      const key = extra.trim();
+      const key = (extra || '').trim();
       if (!key) {
         console.log(`\n  ${C.amber}Usage: /key apply <kiku_vip_sk_...>${C.reset}\n`);
         return 'HANDLED';
@@ -3843,6 +4760,68 @@ export const handlers = {
     return 'HANDLED';
   },
 
+  '/mcp-key': async (ctx) => {
+    const { sub, extra } = ctx;
+    const action = (sub || 'show').toLowerCase();
+    const mem = ctx.agent?.memory;
+
+    if (action === 'clear') {
+      mem?.setPreference('mcpKey', null);
+      console.log(`\n  ${C.emerald}[OK] MCP API Key cleared from preferences.${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    if (action === 'apply') {
+      const key = (extra || '').trim();
+      if (!key) {
+        console.log(`\n  ${C.amber}Usage: /mcp-key apply <kiku_mcp_sk_...>${C.reset}\n`);
+        return 'HANDLED';
+      }
+      mem?.setPreference('mcpKey', key);
+      printSolidPanel({
+        title: 'MCP API Key Applied',
+        lines: [
+          `${C.emerald}[OK] MCP Key saved and ready to use!${C.reset}`,
+          `${C.gold}Key:${C.reset} ${C.white}${key}${C.reset}`,
+        ],
+      });
+      return 'HANDLED';
+    }
+
+    const storedKey = mem?.preferences?.mcpKey;
+    if (storedKey) {
+      printSolidPanel({
+        title: 'Ju Jingyi MCP API Key',
+        lines: [
+          `${C.gold}Key:${C.reset}    ${C.bold}${C.white}${storedKey}${C.reset}`,
+          `${C.gold}Tier:${C.reset}   ${C.emerald}MCP VIP (1,000 req/min)${C.reset}`,
+          `${C.gold}Usage:${C.reset}  ${C.dim}X-API-Key: ${storedKey} or Authorization: Bearer ${storedKey}${C.reset}`,
+          `${C.gold}Config:${C.reset} ${C.dim}Run /mcp-key config to view Claude Desktop & Cursor JSON${C.reset}`,
+          '',
+          `${C.dim}Clear: /mcp-key clear | Apply new: /mcp-key apply <key>${C.reset}`,
+        ],
+      });
+      if (action === 'config') {
+        const baseUrl = ctx.baseUrl || process.env.KIKU_API_URL || 'http://localhost:3000';
+        const configJson = JSON.stringify({
+          mcpServers: {
+            "kiku-remote": {
+              url: `${baseUrl}/mcp`,
+              headers: {
+                "X-API-Key": storedKey
+              }
+            }
+          }
+        }, null, 2);
+        console.log(`\n${C.bold}${C.cyberCyan}Claude Desktop & Cursor Config:${C.reset}`);
+        console.log(configJson + '\n');
+      }
+    } else {
+      console.log(`\n  ${C.amber}No MCP API Key stored. Run ${C.cyberCyan}/quiz mcp${C.amber} to complete the Ju Jingyi challenge and claim one.${C.reset}\n`);
+    }
+    return 'HANDLED';
+  },
+
   '/env': async (ctx) => {
     const sub = String(ctx.sub || '').toLowerCase().trim();
 
@@ -3957,7 +4936,7 @@ export const handlers = {
           });
           return 'HANDLED';
         }
-        const answer = await askEnvQuestion(`.env already exists at ${targetPath}. Overwrite? (y/N)`, 'N');
+        const answer = await askEnvQuestion(ctx, `.env already exists at ${targetPath}. Overwrite? (y/N)`, 'N');
         if (!/^y(es)?$/i.test(answer)) {
           console.log(`\n  ${C.dim}Aborted — file left untouched.${C.reset}\n`);
           return 'HANDLED';
@@ -3971,18 +4950,18 @@ export const handlers = {
         ctx.setIsProcessing?.(false);
         console.log(`\n  ${C.bold}${C.cyberCyan}Kiku environment setup${C.reset} ${C.dim}— Enter accepts the default; everything not asked stays optional.${C.reset}\n`);
         values = {};
-        const baseUrl = await askEnvQuestion('LM Studio endpoint URL', 'http://127.0.0.1:1234/v1');
+        const baseUrl = await askEnvQuestion(ctx, 'LM Studio endpoint URL', 'http://127.0.0.1:1234/v1');
         values.LMSTUDIO_BASE_URL = baseUrl || 'http://127.0.0.1:1234/v1';
         if (detected.loadedModel) {
           console.log(`  ${C.dim}Detected loaded model: ${detected.loadedModel}${C.reset}`);
         }
-        const contextAnswer = await askEnvQuestion('Context window for token telemetry (tokens)', detected.contextLength ? String(detected.contextLength) : '');
+        const contextAnswer = await askEnvQuestion(ctx, 'Context window for token telemetry (tokens)', detected.contextLength ? String(detected.contextLength) : '');
         if (contextAnswer && Number(contextAnswer) > 0) values.KIKU_CONTEXT_LIMIT = String(Math.trunc(Number(contextAnswer)));
-        const dirAnswer = await askEnvQuestion('LM Studio models directory', detected.modelsDir || '');
+        const dirAnswer = await askEnvQuestion(ctx, 'LM Studio models directory', detected.modelsDir || '');
         if (dirAnswer) values.LMSTUDIO_MODELS_DIR = dirAnswer;
-        const wantCloud = await askEnvQuestion('Configure a cloud provider API key now? (y/N)', 'N');
+        const wantCloud = await askEnvQuestion(ctx, 'Configure a cloud provider API key now? (y/N)', 'N');
         if (/^y(es)?$/i.test(wantCloud)) {
-          const provider = (await askEnvQuestion('Provider (openai/gemini/groq/deepseek/openrouter)', 'openai')).toUpperCase();
+          const provider = (await askEnvQuestion(ctx, 'Provider (openai/gemini/groq/deepseek/openrouter)', 'openai')).toUpperCase();
           const keyMap = {
             OPENAI: 'OPENAI_API_KEY',
             GEMINI: 'GEMINI_API_KEY',
@@ -3992,7 +4971,7 @@ export const handlers = {
           };
           const keyName = keyMap[provider];
           if (keyName) {
-            const apiKey = await askEnvQuestion(`${provider} API key`, '');
+            const apiKey = await askEnvQuestion(ctx, `${provider} API key`, '');
             if (apiKey) values[keyName] = apiKey;
           }
         }
@@ -4321,55 +5300,7 @@ export const handlers = {
   },
 };
 
-const ALIASES = {
-  '/quit': '/exit', '/q': '/exit',
-  '/web-chat': '/web',
-  '/abort': '/cancel',
-  '/cp': '/copy', '/clip': '/copy', '/clipboard': '/copy',
-  '/?': '/help', '/commands': '/help', '/menu': '/help',
-  '/hist': '/history', '/h': '/history',
-  '/sess': '/session', '/sessions': '/session',
-  '/load-session': '/session', '/load': '/session', '/restore': '/session',
-  '/think': '/thinking', '/th': '/thinking',
-  '/detail': '/details', '/d': '/details',
-  '/language': '/lang',
-  '/themes': '/theme',
-  '/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',
-  '/settings': '/config', '/conf': '/config',
-  '/persona': '/prompt', '/sysprompt': '/prompt',
-  '/ver': '/about', '/v': '/about', '/version': '/about',
-  '/sys': '/system', '/os': '/system',
-  '/gpus': '/gpu',
-  '/resource': '/vram',
-  '/benchmark': '/eval', '/evaluation': '/eval',
-  '/center': '/hub',
-  '/app': '/portal', '/webportal': '/portal',
-  '/info': '/about',
-  '/sponsor': '/ads', '/ad': '/ads',
-  '/image': '/gallery', '/photo': '/gallery',
-  '/cls': '/clear', '/reset': '/clear',
-  '/export': '/save', '/markdown': '/save',
-  '/src': '/sources', '/srcs': '/sources',
-  '/r': '/retry',
-  '/kvip': '/key',
-  '/switch': '/provider',
-  '/providers': '/provider',
-  '/profiles': '/profile',
-  '/preset': '/profile',
-  '/presets': '/profile',
-  '/ingestion': '/ingest',
-};
+const ALIASES = COMMAND_ALIASES;
 
 export async function routeCommand(rawInput, ctx) {
   const trimmed = rawInput.trim();