kiku-agent 1.3.1 → 1.3.3

package/server/agent/tests/modelManager.test.js

@@ -0,0 +1,141 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { ModelManager } from '../modelManager.js';
+
+function clientWith(models, connected = true) {
+  return {
+    model: 'requested/model',
+    async checkConnection() {
+      return connected ? { connected: true, models } : { connected: false, models: [], error: 'offline' };
+    },
+  };
+}
+
+test('model manager keeps an explicitly requested loaded model', async () => {
+  const client = clientWith(['requested/model', 'google/gemma-4-e4b']);
+  const result = await new ModelManager(client).resolve();
+  assert.equal(result.state, 'ready');
+  assert.equal(result.usedFallback, false);
+  assert.equal(client.model, 'requested/model');
+});
+
+test('model manager selects a chat fallback when the requested model is missing', async () => {
+  const client = clientWith(['text-embedding-model', 'google/gemma-4-e4b']);
+  const result = await new ModelManager(client).resolve();
+  assert.equal(result.state, 'fallback_selected');
+  assert.equal(result.selectedModel, 'google/gemma-4-e4b');
+  assert.equal(client.model, 'google/gemma-4-e4b');
+});
+
+test('model manager fails closed for an explicitly requested unavailable model', async () => {
+  const client = clientWith(['google/gemma-4-e4b']);
+  const result = await new ModelManager(client, { requestedModel: 'Qwen/Qwen3-8B', strictModel: true }).resolve();
+  assert.equal(result.state, 'requested_model_missing');
+  assert.equal(result.selectedModel, null);
+  assert.equal(client.model, 'requested/model');
+});
+
+test('model manager prefers the provider recommendation over an arbitrary catalog model', async () => {
+  const client = clientWith(['random/chat-model', 'gpt-5.6-luna']);
+  client.provider = 'openai';
+  client.getProviderInfo = () => ({ recommendedModels: [{ id: 'gpt-5.6-luna' }] });
+  const result = await new ModelManager(client).resolve();
+  assert.equal(result.state, 'fallback_selected');
+  assert.equal(result.selectedModel, 'gpt-5.6-luna');
+  assert.equal(client.model, 'gpt-5.6-luna');
+});
+
+test('model manager reports online server with no loaded model', async () => {
+  const result = await new ModelManager(clientWith([])).resolve();
+  assert.equal(result.state, 'server_online_no_models');
+  assert.equal(result.selectedModel, undefined);
+});
+
+test('model manager rejects unavailable and non-chat manual selections', () => {
+  const manager = new ModelManager(clientWith([]));
+  assert.throws(() => manager.select('missing', ['chat']), /not available/);
+  assert.throws(() => manager.select('embedding-model', ['embedding-model']), /does not appear to support chat/);
+});
+
+test('model manager normalizes legacy model aliases before availability checks', () => {
+  const client = clientWith([]);
+  client.provider = 'deepseek';
+  const manager = new ModelManager(client);
+  const selected = manager.select('deepseek-chat', ['deepseek-v4-flash']);
+  assert.equal(selected, 'deepseek-v4-flash');
+  assert.equal(client.model, 'deepseek-v4-flash');
+});
+
+test('model manager matches Q8_0 quantization with GGUF file paths and publishers in LM Studio', async () => {
+  const client = {
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b-Q8_0',
+    async checkConnection() {
+      return {
+        connected: true,
+        models: [
+          'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q4_K_M.gguf',
+          'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf'
+        ],
+        activeLoadedModel: 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf'
+      };
+    }
+  };
+
+  const manager = new ModelManager(client, { requestedModel: 'google/gemma-4-e4b-Q8_0' });
+  const result = await manager.resolve();
+  assert.equal(result.state, 'ready');
+  assert.equal(result.selectedModel, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf');
+  assert.equal(client.model, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf');
+
+  const inspection = await manager.inspect();
+  assert.equal(inspection.state, 'ready');
+});
+
+test('model manager allows selecting shorthand quantizations like Q8_0, q8, Q6_K in LM Studio', () => {
+  const client = {
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b',
+  };
+  const available = [
+    'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q4_K_M.gguf',
+    'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf'
+  ];
+  const manager = new ModelManager(client);
+
+  const selectedQ8 = manager.select('Q8_0', available);
+  assert.equal(selectedQ8, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf');
+  assert.equal(client.model, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf');
+
+  const selectedQ8Short = manager.select('q8', available);
+  assert.equal(selectedQ8Short, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q8_0.gguf');
+
+  const selectedQ4 = manager.select('q4_k_m', available);
+  assert.equal(selectedQ4, 'bartowski/gemma-4-e4b-GGUF/gemma-4-e4b-Q4_K_M.gguf');
+});
+
+test('model manager reports server_online_model_not_loaded when LM Studio has models on disk but none in VRAM', async () => {
+  const client = {
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b',
+    async checkConnection() {
+      return {
+        connected: true,
+        models: ['google/gemma-4-e4b'],
+        activeLoadedModel: null,
+        loadedModels: []
+      };
+    }
+  };
+
+  const manager = new ModelManager(client);
+  const result = await manager.resolve();
+  assert.equal(result.connected, true);
+  assert.equal(result.state, 'server_online_model_not_loaded');
+  assert.equal(result.isModelLoaded, false);
+  assert.equal(result.activeLoadedModel, null);
+  assert.equal(result.selectedModel, 'google/gemma-4-e4b');
+});
+
+

package/server/agent/tests/multilingualScenarios.test.js

@@ -0,0 +1,69 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { detectDominantLanguage } from '../agentCore.js';
+import { DynamicToolRouter } from '../toolRouter.js';
+import { executeTool } from '../tools.js';
+
+export const MULTILINGUAL_QUERIES = Object.freeze([
+  {
+    lang: 'th',
+    text: 'จวีจิ้งอี เกิดวันที่เท่าไหร่ และมีผลงานเพลงอะไรบ้างค่ะ',
+    expectedLanguage: 'th'
+  },
+  {
+    lang: 'zh',
+    text: '请问鞠婧祎在2026年有哪些新剧待播？',
+    expectedLanguage: 'zh'
+  },
+  {
+    lang: 'en',
+    text: 'What are the main awards won by Ju Jingyi in her solo career?',
+    expectedLanguage: 'en'
+  },
+  {
+    lang: 'th',
+    text: 'Ju Jingyi (鞠婧祎) ผลงานละครเรื่อง ฮวาเจียนลิ่ง (In Blossom) ฉายปีไหนคะ',
+    expectedLanguage: 'th'
+  },
+  {
+    lang: 'zh',
+    text: '鞠婧祎 Ju Jingyi 个人单曲《每一天》的发行年份和MV',
+    expectedLanguage: 'zh'
+  },
+  {
+    lang: 'en',
+    text: 'Ju Jingyi Chinese name 鞠婧祎 and fandom name Miju 蜜橘 details',
+    expectedLanguage: 'en'
+  },
+  {
+    lang: 'ja',
+    text: '鞠婧祎（ジュ・ジンイー）の最新ドラマと代表曲を教えてください',
+    expectedLanguage: 'ja'
+  },
+  {
+    lang: 'ko',
+    text: '쥐징이의 최신 드라마와 대표곡을 알려주세요',
+    expectedLanguage: 'ko'
+  }
+]);
+
+test('Multilingual Suite: Accurately detects primary language in mixed bilingual queries', () => {
+  for (const item of MULTILINGUAL_QUERIES) {
+    const detected = detectDominantLanguage(item.text);
+    assert.equal(detected, item.expectedLanguage);
+  }
+});
+
+test('Multilingual Suite: Universal and domain search tools find records across Chinese, Thai, and English titles', async () => {
+  const cnRes = await executeTool('search_works', { query: '花间令' });
+  assert.equal(cnRes.status, 'success');
+  assert.ok(cnRes.count > 0);
+
+  const thRes = await executeTool('search_works', { query: 'ฮวาเจียนลิ่ง' });
+  assert.equal(thRes.status, 'success');
+  assert.ok(thRes.count > 0);
+
+  const enRes = await executeTool('search_works', { query: 'In Blossom' });
+  assert.equal(enRes.status, 'success');
+  assert.ok(enRes.count > 0);
+});

package/server/agent/tests/musicControlUiBridge.test.js

@@ -0,0 +1,113 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { Readable } from 'node:stream';
+import { collectMusicControlActions, createMusicControlAction } from '../../web-chat/core/musicControlAction.js';
+import { handleChatRoute } from '../../web-chat/routes/chatRoute.js';
+import { getWebChatHtml } from '../../webChatHtml.js';
+
+function request(body) {
+  const req = Readable.from([JSON.stringify(body)]);
+  req.socket = { remoteAddress: '127.0.0.1' };
+  req.headers = {};
+  return req;
+}
+
+function response() {
+  const res = new EventEmitter();
+  res.chunks = '';
+  res.writeHead = (code) => { res.statusCode = code; res.headersSent = true; };
+  res.write = (data) => { res.chunks += data; };
+  res.end = (data = '') => { res.chunks += data; res.writableEnded = true; res.emit('finish'); };
+  return res;
+}
+
+function musicAgent(toolName, result) {
+  return {
+    session: { id: 'music-test', messages: [] },
+    memory: { getStatus: () => ({}) },
+    run: async (_query, options) => {
+      options.onToolStart(toolName, {});
+      options.onToolResult(toolName, result, 3);
+      options.onTokenDelta?.('done');
+      return { answer: 'done' };
+    },
+  };
+}
+
+test('music tool results normalize to a bounded dedicated UI action', () => {
+  const event = createMusicControlAction('play_music', {
+    status: 'success',
+    action: 'pause',
+    playing: 'Heartbeat Alert',
+    song: { title: '恋爱告急', youtubeId: '5MLPdCmnlmE', extra: 'not-forwarded' },
+  });
+
+  assert.deepEqual(event, {
+    type: 'ui_action',
+    target: 'music_player',
+    tool: 'play_music',
+    action: 'play',
+    playing: 'Heartbeat Alert',
+    song: {
+      id: undefined,
+      title: '恋爱告急',
+      titleTh: undefined,
+      titleCn: undefined,
+      titleEn: undefined,
+      youtubeId: '5MLPdCmnlmE',
+      duration: undefined,
+      category: undefined,
+      dramaName: undefined,
+    },
+  });
+  assert.equal(createMusicControlAction('search_discography', { status: 'success' }), null);
+  assert.deepEqual(createMusicControlAction('pause_music', { status: 'error' }), {
+    type: 'ui_action',
+    target: 'music_player',
+    tool: 'pause_music',
+    action: 'pause',
+  });
+  assert.equal(collectMusicControlActions([
+    { name: 'set_volume', result: { status: 'success', volume: 140 } },
+    { name: 'seek_music', result: { status: 'success', seconds: -5 } },
+  ]).length, 2);
+});
+
+test('streaming chat emits music UI actions independently from tool inspector events', async () => {
+  const res = response();
+  await handleChatRoute(request({ query: 'pause music', provider: 'lmstudio', stream: true }), res, null, {
+    resolveConnection: async () => ({
+      ready: true,
+      agent: musicAgent('pause_music', { status: 'success', action: 'pause', message: 'paused' }),
+    }),
+  });
+
+  const events = res.chunks
+    .split('\n')
+    .filter((line) => line.startsWith('data: {'))
+    .map((line) => JSON.parse(line.slice(6)));
+  assert.ok(events.some((event) => event.type === 'tool_result' && event.name === 'pause_music'));
+  assert.ok(events.some((event) => event.type === 'ui_action' && event.target === 'music_player' && event.action === 'pause'));
+});
+
+test('non-streaming chat returns music UI actions and both client stream paths consume them', async () => {
+  const res = response();
+  await handleChatRoute(request({ query: 'volume 60', provider: 'lmstudio', stream: false }), res, null, {
+    resolveConnection: async () => ({
+      ready: true,
+      agent: musicAgent('set_volume', { status: 'success', action: 'set_volume', volume: 60 }),
+    }),
+  });
+
+  const body = JSON.parse(res.chunks);
+  assert.equal(body.uiActions[0].action, 'set_volume');
+  assert.equal(body.uiActions[0].volume, 60);
+
+  const html = getWebChatHtml();
+  assert.equal((html.match(/event\.type === 'ui_action' && event\.target === 'music_player'/g) || []).length, 2);
+  assert.equal((html.match(/const uiActions = Array\.isArray\(data\.uiActions\)/g) || []).length, 2);
+  assert.match(html, /miniPlayerState\.isPlaying = false;\s*sendMiniPlayerCommand\('pauseVideo'\)/);
+  assert.match(html, /miniPlayerState\.volume = vol;\s*miniPlayerState\.isMuted = vol === 0;/);
+  assert.match(html, /sendMiniPlayerCommand\(vol === 0 \? 'mute' : 'unMute'\)/);
+});

package/server/agent/tests/newCommands.test.js

@@ -0,0 +1,347 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { routeCommand } from '../commands.js';
+import { AgentMemory } from '../memory.js';
+import { AgentJobManager } from '../jobManager.js';
+
+const RECENT_DATE = new Date(Date.now() - 3 * 86_400_000).toISOString().slice(0, 10);
+
+async function captureOutput(run) {
+  const originalLog = console.log;
+  const output = [];
+  console.log = (...args) => output.push(args.join(' '));
+  try {
+    const result = await run();
+    return { result, output: output.join('\n') };
+  } finally {
+    console.log = originalLog;
+  }
+}
+
+function catalogExecutor(name, args = {}) {
+  if (name === 'search_works' && (!args.query || /in blossom/i.test(args.query))) return Promise.resolve({ works: [{ id: 'in-blossom', titleTh: 'In Blossom', year: 2024, role: 'Yang Caiwei', platform: 'Youku', episodes: 32 }] });
+  if (name === 'search_discography' && (!args.query || /rain love/i.test(args.query))) return Promise.resolve({ songs: [{ id: 'rain-love', title: 'Rain Love', year: 2024, type: 'Single', duration: '3:45' }] });
+  return Promise.resolve({ works: [], songs: [], roles: [], brands: [], awards: [], photos: [], videos: [] });
+}
+
+test('/find validates flags and renders normalized catalog results', async () => {
+  const found = await captureOutput(() => routeCommand('/find "In Blossom" --type work --limit 2', { executeTool: catalogExecutor }));
+  assert.equal(found.result, 'HANDLED');
+  assert.match(found.output, /Catalog Search/);
+  assert.match(found.output, /In Blossom/);
+
+  const invalid = await captureOutput(() => routeCommand('/find test --type file', { executeTool: catalogExecutor }));
+  assert.equal(invalid.result, 'HANDLED');
+  assert.match(invalid.output, /COMMAND ERROR/);
+});
+
+test('/compare resolves both sides around the separator', async () => {
+  const output = await captureOutput(() => routeCommand('/compare "In Blossom" -- "Rain Love"', { executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Compare/);
+  assert.match(output.output, /In Blossom/);
+  assert.match(output.output, /Rain Love/);
+});
+
+test('/favorites adds, lists, removes, and exports resolved entries', async () => {
+  const memory = new AgentMemory();
+  memory.save = async () => true;
+  memory.exportFavorites = async format => ({ filePath: `C:\\safe\\favorites.${format === 'markdown' ? 'md' : 'json'}`, count: memory.getFavorites().length });
+  const agent = { memory };
+
+  const added = await captureOutput(() => routeCommand('/favorites add work "In Blossom"', { agent, executeTool: catalogExecutor }));
+  assert.equal(added.result, 'HANDLED');
+  assert.equal(memory.getFavorites().length, 1);
+  assert.match(added.output, /Favorite Added/);
+
+  const listed = await captureOutput(() => routeCommand('/favorites list --type work', { agent }));
+  assert.match(listed.output, /In Blossom/);
+
+  const id = memory.getFavorites()[0].id;
+  await captureOutput(() => routeCommand(`/favorites remove ${id}`, { agent }));
+  assert.equal(memory.getFavorites().length, 0);
+
+  const exported = await captureOutput(() => routeCommand('/favorites export markdown', { agent }));
+  assert.match(exported.output, /Favorites Exported/);
+});
+
+test('/news filters unsafe URLs and honors official-only hosts', async () => {
+  let query = '';
+  const executeTool = async () => ({
+    results: [
+      { title: `Official update ${RECENT_DATE}`, url: 'https://weibo.com/example', snippet: 'Studio update\u001b[31m' },
+      { title: 'Unsafe', url: 'javascript:alert(1)', snippet: 'Ignore' },
+      { title: 'Blog', url: 'https://example.com/news', snippet: 'Unofficial' },
+    ],
+  });
+  const output = await captureOutput(() => routeCommand('/news drama --days 7 --official-only', { executeTool: async (name, args) => {
+    query = args.query;
+    return executeTool(name, args);
+  } }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(query, /after:\d{4}-\d{2}-\d{2} before:\d{4}-\d{2}-\d{2}/);
+  assert.match(output.output, /requested 7-day window/);
+  assert.match(output.output, /weibo\.com/);
+  assert.doesNotMatch(output.output, /javascript:/);
+  assert.doesNotMatch(output.output, /example\.com/);
+  assert.doesNotMatch(output.output, /\u001b\[31m/);
+});
+
+test('/news labels results without dates as recency unverified', async () => {
+  const executeTool = async () => ({ results: [{ title: 'Drama update', url: 'https://example.com/update', snippet: 'No publication date' }] });
+  const output = await captureOutput(() => routeCommand('/news drama --days 7', { executeTool }));
+  assert.match(output.output, /date unavailable • recency unverified/);
+});
+
+test('/jobs lists, shows, cancels, and clears through the agent contract', async () => {
+  const manager = new AgentJobManager();
+  const job = manager.create('research', 'Current drama news');
+  const agent = {
+    getJobs: () => manager.list(),
+    getJob: id => manager.get(id),
+    cancelJob: id => manager.cancel(id),
+    clearJobs: () => manager.clear(),
+  };
+  const listed = await captureOutput(() => routeCommand('/jobs', { agent }));
+  assert.match(listed.output, new RegExp(job.id));
+  const shown = await captureOutput(() => routeCommand(`/jobs show ${job.id}`, { agent }));
+  assert.match(shown.output, /Current drama news/);
+  await captureOutput(() => routeCommand(`/jobs cancel ${job.id}`, { agent }));
+  assert.equal(manager.get(job.id).state, 'cancelled');
+  await captureOutput(() => routeCommand('/jobs clear', { agent }));
+  assert.equal(manager.list().length, 0);
+});
+
+test('/discover returns one catalog recommendation with deterministic selection', async () => {
+  const output = await captureOutput(() => routeCommand('/discover song --mood calm', { executeTool: catalogExecutor, random: () => 0 }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Discover/);
+  assert.match(output.output, /Rain Love/);
+});
+
+test('/discover renders an AI rationale when a chat client is available', async () => {
+  const agent = {
+    memory: new AgentMemory(),
+    client: {
+      chat: async () => ({ content: 'A dreamy choice to end the day.' }),
+    },
+  };
+  const output = await captureOutput(() => routeCommand('/discover song --mood calm', { agent, executeTool: catalogExecutor, random: () => 0 }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /A dreamy choice to end the day/);
+});
+
+test('/discover falls back gracefully when the chat client fails', async () => {
+  const agent = {
+    memory: new AgentMemory(),
+    client: {
+      chat: async () => { throw new Error('model unavailable'); },
+    },
+  };
+  const output = await captureOutput(() => routeCommand('/discover drama', { agent, executeTool: catalogExecutor, random: () => 0 }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Discover/);
+  assert.match(output.output, /In Blossom/);
+  assert.doesNotMatch(output.output, /COMMAND ERROR/);
+});
+
+function fakeAgent(narration) {
+  const memory = new AgentMemory();
+  memory.save = async () => true;
+  return {
+    memory,
+    client: { chat: async () => ({ content: narration }) },
+  };
+}
+
+test('/compare renders an AI natural-language summary when a client is available', async () => {
+  const output = await captureOutput(() => routeCommand('/compare "In Blossom" -- "Rain Love"', { agent: fakeAgent('In Blossom is a drama while Rain Love is a single.'), executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /In Blossom is a drama while Rain Love is a single/);
+});
+
+test('/compare falls back gracefully when the chat client fails', async () => {
+  const agent = { client: { chat: async () => { throw new Error('boom'); } } };
+  const output = await captureOutput(() => routeCommand('/compare "In Blossom" -- "Rain Love"', { agent, executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Differences/);
+  assert.doesNotMatch(output.output, /COMMAND ERROR/);
+});
+
+test('/find renders an AI explanation when a client is available', async () => {
+  const output = await captureOutput(() => routeCommand('/find "In Blossom" --type work', { agent: fakeAgent('In Blossom matches because the query matches its title.'), executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /matches because/);
+});
+
+test('/find falls back gracefully when no client is available', async () => {
+  const output = await captureOutput(() => routeCommand('/find "In Blossom" --type work', { executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Catalog Search/);
+  assert.match(output.output, /In Blossom/);
+  assert.doesNotMatch(output.output, /COMMAND ERROR/);
+});
+
+test('/favorites suggest renders an AI recommendation from saved taste', async () => {
+  const agent = fakeAgent('Rain Love — a gentle companion piece\nIn Blossom encore');
+  await captureOutput(() => routeCommand('/favorites add work "In Blossom"', { agent, executeTool: catalogExecutor }));
+  const output = await captureOutput(() => routeCommand('/favorites suggest', { agent, executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Favorites Suggest/);
+  assert.match(output.output, /Rain Love/);
+});
+
+test('/favorites suggest explains when there are no favorites yet', async () => {
+  const output = await captureOutput(() => routeCommand('/favorites suggest', { agent: fakeAgent('ignored'), executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /No favorites yet/);
+  assert.doesNotMatch(output.output, /COMMAND ERROR/);
+});
+
+test('/news renders an AI summary of results when a client is available', async () => {
+  const executeTool = async () => ({ results: [{ title: `Studio update ${RECENT_DATE}`, url: 'https://weibo.com/example', snippet: 'New single released' }] });
+  const output = await captureOutput(() => routeCommand('/news drama --days 7', { agent: fakeAgent('The studio announced a new single this week.'), executeTool }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /announced a new single/);
+});
+
+test('/news falls back gracefully when no client is available', async () => {
+  const executeTool = async () => ({ results: [{ title: `Studio update ${RECENT_DATE}`, url: 'https://weibo.com/example', snippet: 'New single released' }] });
+  const output = await captureOutput(() => routeCommand('/news drama --days 7', { executeTool }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /News Search/);
+  assert.doesNotMatch(output.output, /COMMAND ERROR/);
+});
+
+test('/history summary delegates to /session summary and renders an AI summary when messages and client exist', async () => {
+  const agent = fakeAgent('Discussed In Blossom release details and music.');
+  agent.session = {
+    messages: [
+      { role: 'user', parts: [{ type: 'text', content: 'Tell me about In Blossom' }] },
+      { role: 'assistant', parts: [{ type: 'text', content: 'In Blossom was released in 2024.' }] },
+    ],
+  };
+  const output = await captureOutput(() => routeCommand('/history summary', { agent }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Session Summary/);
+  assert.match(output.output, /Discussed In Blossom/);
+});
+
+test('/history summary handles empty history gracefully', async () => {
+  const agent = fakeAgent('ignored');
+  agent.session = { messages: [] };
+  const output = await captureOutput(() => routeCommand('/history summary', { agent }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /No messages in the active session/);
+});
+
+test('/session summary synthesizes an AI session analysis when messages exist', async () => {
+  const agent = fakeAgent('Session focused on 2024 filmography research with 2 tool calls.');
+  agent.session = {
+    id: 'sess_test_123',
+    messages: [
+      { role: 'user', parts: [{ type: 'text', content: 'Who did Ju Jingyi play in In Blossom?' }] },
+      { role: 'assistant', parts: [{ type: 'text', content: 'She played Yang Caiwei.' }] },
+    ],
+    stats: { totalQueries: 1, totalToolCalls: 2 },
+  };
+  const output = await captureOutput(() => routeCommand('/session summary', { agent }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Session Summary/);
+  assert.match(output.output, /Session focused on 2024/);
+});
+
+test('/session summary handles empty session messages gracefully', async () => {
+  const agent = fakeAgent('ignored');
+  agent.session = { id: 'sess_empty', messages: [], stats: {} };
+  const output = await captureOutput(() => routeCommand('/session summary', { agent }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /No messages in the active session/);
+});
+
+test('/mem summary synthesizes an AI persona profile when facts exist', async () => {
+  const agent = fakeAgent('User is an avid fan tracking Ju Jingyi dramas and OST releases.');
+  agent.memory.addFact('Loves In Blossom (2024)', { source: 'user' });
+  const output = await captureOutput(() => routeCommand('/mem summary', { agent }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Memory Profile Summary/);
+  assert.match(output.output, /avid fan tracking/);
+});
+
+test('/mem summary handles empty memory gracefully', async () => {
+  const agent = fakeAgent('ignored');
+  const output = await captureOutput(() => routeCommand('/mem summary', { agent }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /No long-term memories/);
+});
+
+test('/stats renders AI data narration alongside summary counts', async () => {
+  const agent = fakeAgent('Ju Jingyi has a rich discography and television portfolio.');
+  const output = await captureOutput(() => routeCommand('/stats', { agent, executeTool: async () => ({ stats: { totalWorks: 15, totalUniqueSongs: 40, brandEndorsements: 12, totalAwards: 25, timelineMilestones: 30 } }) }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Database Overview/);
+  assert.match(output.output, /rich discography/);
+});
+
+test('job manager records completion, failure, and cancellation states', async () => {
+  const manager = new AgentJobManager();
+  await manager.run('research', 'done', async () => ({ ok: true }));
+  assert.equal(manager.list()[0].state, 'completed');
+
+  await assert.rejects(manager.run('research', 'failed', async () => { throw new Error('failed'); }), /failed/);
+  assert.equal(manager.list()[0].state, 'failed');
+
+  let release;
+  const pending = manager.run('research', 'cancel me', ({ signal }) => new Promise((resolve, reject) => {
+    release = resolve;
+    signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+  }));
+  const active = manager.list()[0];
+  assert.equal(manager.cancel(active.id), true);
+  await assert.rejects(pending, /Cancelled by user/);
+  assert.equal(manager.get(active.id).state, 'cancelled');
+  release?.();
+});
+
+test('/session load and /resume restore archived sessions into memory', async () => {
+  let restoredTarget = null;
+  const mockAgent = {
+    session: {
+      id: 'sess_active',
+      messages: [],
+      stats: { totalQueries: 0, totalToolCalls: 0, totalDurationMs: 0 },
+      thinkingMode: 'hide',
+    },
+    memory: {
+      getArchivedSessions: (limit) => [
+        { id: 'sess_arch_1', createdAt: new Date(), messageCount: 4, stats: { totalQueries: 2, totalToolCalls: 3, totalDurationMs: 1500 } },
+        { id: 'sess_arch_2', createdAt: new Date(), messageCount: 2, stats: { totalQueries: 1, totalToolCalls: 1, totalDurationMs: 800 } },
+      ],
+    },
+    restoreSession: async (target) => {
+      restoredTarget = target;
+      return {
+        id: 'sess_arch_1',
+        createdAt: new Date(),
+        messages: [{ role: 'user' }, { role: 'assistant' }, { role: 'user' }, { role: 'assistant' }],
+        stats: { totalQueries: 2, totalToolCalls: 3, totalDurationMs: 1500 },
+      };
+    },
+  };
+
+  const usageOutput = await captureOutput(() => routeCommand('/session load', { agent: mockAgent, sub: 'load', extra: '' }));
+  assert.equal(usageOutput.result, 'HANDLED');
+  assert.match(usageOutput.output, /Load Session Usage/);
+
+  const loadOutput = await captureOutput(() => routeCommand('/session load sess_arch_1', { agent: mockAgent, sub: 'load', extra: 'sess_arch_1' }));
+  assert.equal(loadOutput.result, 'HANDLED');
+  assert.equal(restoredTarget, 'sess_arch_1');
+  assert.match(loadOutput.output, /Session Restored Successfully/);
+
+  const resumeOutput = await captureOutput(() => routeCommand('/resume 1', { agent: mockAgent, sub: '1', extra: '' }));
+  assert.equal(resumeOutput.result, 'HANDLED');
+  assert.equal(restoredTarget, '1');
+  assert.match(resumeOutput.output, /Session Restored Successfully/);
+});
+