kiku-agent 1.3.1 → 1.3.3

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

@@ -0,0 +1,216 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { ResearchSubagent } from '../subagent.js';
+import { AgentMemory } from '../memory.js';
+import { ResearchOrchestrator, uniqueUrls, cleanUrl, resolveTruncatedUrl, expandTruncatedUrlsInText } from '../research.js';
+
+test('research subagent executes only an allowed validated tool and returns evidence', async () => {
+  const responses = [
+    {
+      role: 'assistant',
+      content: '',
+      tool_calls: [{ id: 'call_1', function: { name: 'search_works', arguments: '{"query":"千香"}' } }],
+    },
+    { role: 'assistant', content: '千香 is listed in the verified Kiku catalog.' },
+  ];
+  const executed = [];
+  const client = { async chat() { return responses.shift(); } };
+  const subagent = new ResearchSubagent({
+    client,
+    allowedTools: ['search_works'],
+    executeTool: async (name, args) => {
+      executed.push({ name, args });
+      return { status: 'ok', works: [{ titleCn: '千香' }] };
+    },
+  });
+
+  const result = await subagent.run('Verify Ju Jingyi project 千香');
+  assert.deepEqual(executed, [{ name: 'search_works', args: { query: '千香' } }]);
+  assert.equal(result.toolCalls.length, 1);
+  assert.match(result.answer, /千香/);
+});
+
+test('research subagent denies tools outside its capability set', async () => {
+  let executed = false;
+  const client = {
+    calls: 0,
+    async chat() {
+      this.calls += 1;
+      if (this.calls === 1) {
+        return { role: 'assistant', tool_calls: [{ id: 'bad', function: { name: 'read_local_file', arguments: '{"path":".env"}' } }] };
+      }
+      return { role: 'assistant', content: 'The request was denied.' };
+    },
+  };
+  const subagent = new ResearchSubagent({
+    client,
+    allowedTools: ['search_works'],
+    executeTool: async () => { executed = true; },
+  });
+
+  const result = await subagent.run('Read secrets');
+  assert.equal(executed, false);
+  assert.match(result.answer, /denied/i);
+});
+
+test('user-taught skills are deduplicated and included in memory context', () => {
+  const memory = new AgentMemory();
+  memory.save = async () => true;
+  const first = memory.addUserSkill('ตอบภาษาไทยแบบสั้น กระชับ');
+  const duplicate = memory.addUserSkill('ตอบภาษาไทยแบบสั้น กระชับ');
+
+  assert.equal(first.id, duplicate.id);
+  assert.equal(memory.preferences.userSkills.length, 1);
+  assert.match(memory.buildMemoryContext(), /ตอบภาษาไทยแบบสั้น กระชับ/);
+
+  memory.setPreference('skillsEnabled', false);
+  assert.equal(memory.buildUserSkillContext(), '');
+});
+
+test('research orchestrator runs bounded workers concurrently and deduplicates sources', async () => {
+  const client = {
+    async chat({ messages }) {
+      if (messages[0].content.includes('Kiku research editor')) {
+        return { role: 'assistant', content: 'Synthesized verified answer https://example.com/official' };
+      }
+      const objective = messages[1].content;
+      if (objective.includes('local Kiku catalog')) {
+        return { role: 'assistant', content: 'Catalog evidence for 千香.' };
+      }
+      if (objective.includes('primary or authoritative')) {
+        return { role: 'assistant', content: 'Official source https://example.com/official' };
+      }
+      return { role: 'assistant', content: 'Corroborated at https://example.com/official and https://example.org/second.' };
+    },
+  };
+  const orchestrator = new ResearchOrchestrator({ client });
+  const progress = [];
+  const result = await orchestrator.run('ข้อมูล 千香', { onProgress: event => progress.push(event.type) });
+
+  assert.equal(result.reports.length, 3);
+  assert.deepEqual(result.sources, ['https://example.com/official', 'https://example.org/second']);
+  assert.match(result.answer, /Synthesized/);
+  assert.equal(orchestrator.getStatus().state, 'idle');
+  assert.ok(progress.includes('worker-start'));
+  assert.ok(progress.includes('complete'));
+});
+
+test('research orchestrator verification mode requests an explicit verdict', async () => {
+  let synthesisSystem = '';
+  const client = {
+    async chat({ messages }) {
+      if (messages[0].content.includes('Kiku research editor')) {
+        synthesisSystem = messages[0].content;
+        return { role: 'assistant', content: 'UNVERIFIED — no primary announcement.' };
+      }
+      return { role: 'assistant', content: 'No confirming source was found.' };
+    },
+  };
+  const result = await new ResearchOrchestrator({ client }).run('ข่าวลือนี้จริงไหม', { mode: 'verify' });
+  assert.match(synthesisSystem, /VERIFIED, UNVERIFIED, CONFLICTING, or FALSE/);
+  assert.match(result.answer, /UNVERIFIED/);
+});
+
+test('research orchestrator shares identical tool results between workers', async () => {
+  let executions = 0;
+  const client = {
+    async chat({ messages }) {
+      if (messages[0].content.includes('Kiku research editor')) return { role: 'assistant', content: 'Combined answer.' };
+      if (messages.length === 2 && !messages[1].content.includes('primary or authoritative')) {
+        return {
+          role: 'assistant',
+          tool_calls: [{ id: `call_${Math.random()}`, function: { name: 'global_search', arguments: '{"query":"千香"}' } }],
+        };
+      }
+      return { role: 'assistant', content: 'Evidence collected.' };
+    },
+  };
+  const orchestrator = new ResearchOrchestrator({
+    client,
+    executeTool: async () => {
+      executions += 1;
+      return { status: 'ok', results: [] };
+    },
+  });
+
+  await orchestrator.run('千香');
+  assert.equal(executions, 1);
+});
+
+test('research orchestrator cleans backticks, resolves truncated URLs, and expands in text', () => {
+  const knownUrls = [
+    'https://wetv.vip/en/play/q0034a7434d/z0034f7158a-Lai_Zhan%3A_The_Love-Hate_Entanglement.html',
+    'https://mydramalist.com/790246-lai-zhan',
+    'https://www.newsbreak.com/news/4155481784345-lai-zhan-official-release',
+    'https://www.facebook.com/groups/1983148261871766/posts/1174442684836506/',
+  ];
+
+  assert.equal(cleanUrl('`https://mydramalist.com/790246-lai-zhan`'), 'https://mydramalist.com/790246-lai-zhan');
+  assert.equal(cleanUrl('"https://mydramalist.com/790246-lai-zhan",'), 'https://mydramalist.com/790246-lai-zhan');
+
+  const truncatedWeTV = 'https://wetv.vip/en/play/...Lai_Zhan%3A_The_Love-Hate...';
+  const resolvedWeTV = resolveTruncatedUrl(truncatedWeTV, knownUrls);
+  assert.equal(resolvedWeTV, 'https://wetv.vip/en/play/q0034a7434d/z0034f7158a-Lai_Zhan%3A_The_Love-Hate_Entanglement.html');
+
+  const truncatedFB = 'https://www.facebook.com/groups/1983148261871766/posts/...';
+  const resolvedFB = resolveTruncatedUrl(truncatedFB, knownUrls);
+  assert.equal(resolvedFB, 'https://www.facebook.com/groups/1983148261871766/posts/1174442684836506/');
+
+  const truncatedNews = 'https://www.newsbreak.com/news/4155481784345-lai-zhan...';
+  const resolvedNews = resolveTruncatedUrl(truncatedNews, knownUrls);
+  assert.equal(resolvedNews, 'https://www.newsbreak.com/news/4155481784345-lai-zhan-official-release');
+
+  const markdownTable = [
+    '| Source | URL | Notes |',
+    '| --- | --- | --- |',
+    '| WeTV | https://wetv.vip/en/play/...Lai_Zhan%3A_The_Love-Hate... | Official stream |',
+    '| FB | https://www.facebook.com/groups/1983148261871766/posts/... | Updates |',
+    '| News | https://www.newsbreak.com/news/4155481784345-lai-zhan... | Article |',
+  ].join('\n');
+  const expanded = expandTruncatedUrlsInText(markdownTable, knownUrls);
+  assert.ok(expanded.includes('https://wetv.vip/en/play/q0034a7434d/z0034f7158a-Lai_Zhan%3A_The_Love-Hate_Entanglement.html'));
+  assert.ok(expanded.includes('https://www.facebook.com/groups/1983148261871766/posts/1174442684836506/'));
+  assert.ok(expanded.includes('https://www.newsbreak.com/news/4155481784345-lai-zhan-official-release'));
+  assert.equal(expanded.includes('...'), false, 'All truncated URLs in table must be expanded');
+
+  const sampleReport = `
+    Check out \`https://mydramalist.com/790246-lai-zhan\`
+    Also see https://wetv.vip/en/play/...Lai_Zhan%3A_The_Love-Hate...
+    Unresolvable source: https://unknown-domain.com/path/.../something
+  `;
+  const urls = uniqueUrls(sampleReport, knownUrls);
+  assert.ok(urls.includes('https://mydramalist.com/790246-lai-zhan'));
+  assert.ok(urls.includes('https://wetv.vip/en/play/q0034a7434d/z0034f7158a-Lai_Zhan%3A_The_Love-Hate_Entanglement.html'));
+  assert.equal(urls.some(u => u.endsWith('`')), false, 'No URL should end with a backtick');
+  assert.equal(urls.some(u => u.includes('...')), false, 'No URL in validated sources should contain ellipsis');
+});
+
+test('research orchestrator degrades gracefully when a worker times out', async () => {
+  const client = {
+    async chat({ messages, signal }) {
+      if (messages[0].content.includes('Kiku research editor')) {
+        return { role: 'assistant', content: 'Synthesized report based on available catalog evidence.' };
+      }
+      const objective = messages[1].content;
+      if (objective.includes('primary or authoritative') || objective.includes('web sources')) {
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => resolve({ role: 'assistant', content: 'late' }), 10000);
+          signal?.addEventListener('abort', () => {
+            clearTimeout(timeout);
+            reject(new DOMException('Aborted', 'AbortError'));
+          });
+        });
+      }
+      return { role: 'assistant', content: 'Catalog details for Lai Zhan 2026.' };
+    },
+  };
+
+  const orchestrator = new ResearchOrchestrator({ client });
+  const result = await orchestrator.run('Lai Zhan news', { workerTimeoutMs: 100 });
+  assert.ok(result.answer.includes('Synthesized report'));
+  const webWorker = result.reports.find(r => r.id === 'web');
+  assert.equal(webWorker.error ? true : false, true);
+  assert.equal(orchestrator.getStatus().state, 'idle');
+});
+

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

@@ -0,0 +1,109 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { ResearchSubagent } from '../subagent.js';
+import { executeTool } from '../tools.js';
+import { sanitizeSubagentProgress } from '../../web-chat/routes/chatRoute.js';
+
+test('research subagent emits iteration and tool progress events', async () => {
+  const responses = [
+    {
+      role: 'assistant',
+      content: '',
+      tool_calls: [{ id: 'call_1', function: { name: 'search_works', arguments: '{"query":"In Blossom"}' } }],
+    },
+    { role: 'assistant', content: 'In Blossom is listed in the verified Kiku catalog.' },
+  ];
+  const progress = [];
+  const subagent = new ResearchSubagent({
+    client: { async chat() { return responses.shift(); } },
+    allowedTools: ['search_works'],
+    executeTool: async () => ({ status: 'ok', works: [] }),
+  });
+
+  const result = await subagent.run('Verify In Blossom', { onProgress: (event) => progress.push(event) });
+
+  assert.ok(progress.some((event) => event.type === 'iteration' && event.iteration === 1));
+  assert.ok(progress.some((event) => event.type === 'tool' && event.name === 'search_works'));
+  assert.match(result.answer, /In Blossom/);
+});
+
+test('run_subagent tool handler forwards tagged progress without an LLM', async () => {
+  const seen = [];
+  const fakeAgent = {
+    async runSubagent(task, options = {}) {
+      options.onProgress?.({ type: 'iteration', iteration: 1, maxIterations: 3 });
+      options.onProgress?.({ type: 'tool', name: 'search_works' });
+      return { answer: 'Evidence: In Blossom (2024).', toolCalls: [{ name: 'search_works' }], iterations: 1 };
+    },
+  };
+
+  const result = await executeTool('run_subagent', { task: 'Verify In Blossom' }, {
+    agent: fakeAgent,
+    onSubagentProgress: (event) => seen.push(event),
+  });
+
+  assert.equal(result.status, 'success');
+  assert.match(result.answer, /In Blossom/);
+  assert.ok(seen.length >= 3, `expected start + progress events, got ${seen.length}`);
+  assert.ok(seen.every((event) => event.source === 'subagent'));
+  assert.ok(seen.some((event) => event.type === 'iteration'));
+  assert.ok(seen.some((event) => event.type === 'tool' && event.name === 'search_works'));
+});
+
+test('run_deep_research and verify_claim forward tagged research progress', async () => {
+  const seen = [];
+  const fakeAgent = {
+    async runResearch(question, options = {}) {
+      options.onProgress?.({ type: 'worker-start', id: 'w1', label: 'Catalog sweep' });
+      options.onProgress?.({ type: 'worker-complete', id: 'w1', label: 'Catalog sweep' });
+      options.onProgress?.({ type: 'complete', id: 'job1', sources: 2 });
+      return { answer: 'Synthesized answer.', sources: ['https://example.com/a'], reports: [] };
+    },
+  };
+
+  const research = await executeTool('run_deep_research', { question: 'Latest Ju Jingyi drama?' }, {
+    agent: fakeAgent,
+    onSubagentProgress: (event) => seen.push(event),
+  });
+  assert.equal(research.status, 'success');
+  assert.ok(seen.every((event) => event.source === 'research'));
+  assert.ok(seen.some((event) => event.type === 'worker-start'));
+  assert.ok(seen.some((event) => event.type === 'complete'));
+
+  seen.length = 0;
+  const verify = await executeTool('verify_claim', { claim: 'Ju Jingyi won an award in 2024' }, {
+    agent: fakeAgent,
+    onSubagentProgress: (event) => seen.push(event),
+  });
+  assert.equal(verify.status, 'success');
+  assert.ok(seen.every((event) => event.source === 'verify'));
+});
+
+test('sanitizeSubagentProgress allowlists coarse fields and drops internals', () => {
+  const dirty = {
+    source: 'research',
+    type: 'worker-start',
+    question: 'Latest drama?'.repeat(50),
+    id: 'w1',
+    label: 'Catalog sweep',
+    args: { secret: 'must-not-leak' },
+    content: 'raw evidence must not cross',
+    apiKey: 'must-not-leak',
+  };
+  const clean = sanitizeSubagentProgress(dirty);
+
+  assert.equal(clean.type, 'subagent_progress');
+  assert.equal(clean.source, 'research');
+  assert.equal(clean.kind, 'worker-start');
+  assert.equal(clean.workerId, 'w1');
+  assert.equal(clean.label, 'Catalog sweep');
+  assert.ok(clean.subject.length <= 200);
+  assert.ok(!('args' in clean));
+  assert.ok(!('content' in clean));
+  assert.ok(!('apiKey' in clean));
+
+  const unknown = sanitizeSubagentProgress({ source: 'hacker', type: 'exfiltrate', task: 'x' });
+  assert.equal(unknown.source, 'subagent');
+  assert.equal(unknown.kind, 'tool');
+});

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

@@ -0,0 +1,115 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { ResearchSubagent } from '../subagent.js';
+
+test('subagent parses Action blocks and executes tools when native calling is unavailable', async () => {
+  const executed = [];
+  const observed = [];
+  let chatCalls = 0;
+  const client = {
+    provider: 'deepseek',
+    providerName: 'DeepSeek',
+    model: 'deepseek-reasoner',
+    toolsWillBeOmitted() { return true; },
+    toolsDisabledReason: 'reasoning_model',
+    async chat(options) {
+      chatCalls++;
+      observed.push(options.messages.map(m => ({ role: m.role, content: typeof m.content === 'string' ? m.content : null })));
+      if (chatCalls === 1) {
+        return { role: 'assistant', content: 'Let me check the catalog.\nAction: get_quotes\nAction Input: {"tag": "mindset"}' };
+      }
+      return { role: 'assistant', content: 'Evidence report: one mindset quote found.' };
+    },
+  };
+
+  const subagent = new ResearchSubagent({
+    client,
+    executeTool: async (name, args) => {
+      executed.push({ name, args });
+      return { status: 'success', count: 1, quotes: [{ textTh: 'x' }] };
+    },
+    maxIterations: 3,
+    allowedTools: ['get_quotes', 'web_search'],
+  });
+
+  const result = await subagent.run('collect a mindset quote');
+
+  assert.equal(executed.length, 1);
+  assert.equal(executed[0].name, 'get_quotes');
+  assert.deepEqual(executed[0].args, { tag: 'mindset' });
+  assert.match(result.answer, /Evidence report/);
+  assert.equal(result.toolCalls.length, 1);
+
+  assert.match(observed[0][0].content, /TEXT TOOL PROTOCOL/);
+});
+
+test('malformed tool-call blocks are fed back instead of ending the run', async () => {
+  const executed = [];
+  let chatCalls = 0;
+  const client = {
+    provider: 'lmstudio',
+    providerName: 'LM Studio',
+    model: 'test-model',
+    async chat() {
+      chatCalls++;
+      if (chatCalls === 1) {
+        return { role: 'assistant', content: '```json\n{"action": "get_quotes", "parameters": {"tag": }}\n```' };
+      }
+      if (chatCalls === 2) {
+        return { role: 'assistant', content: 'Action: get_quotes\nAction Input: {"tag": "mindset"}' };
+      }
+      return { role: 'assistant', content: 'Done — evidence collected.' };
+    },
+  };
+
+  const subagent = new ResearchSubagent({
+    client,
+    executeTool: async (name) => {
+      executed.push(name);
+      return { status: 'success', count: 1 };
+    },
+    maxIterations: 4,
+    allowedTools: ['get_quotes'],
+  });
+
+  const result = await subagent.run('collect a quote');
+
+  assert.equal(executed.length, 1);
+  assert.equal(result.toolCalls.length, 1);
+  assert.ok(result.iterations >= 2);
+});
+
+test('native tool_calls path is unchanged', async () => {
+  const executed = [];
+  let chatCalls = 0;
+  const client = {
+    provider: 'lmstudio',
+    providerName: 'LM Studio',
+    model: 'test-model',
+    async chat() {
+      chatCalls++;
+      if (chatCalls === 1) {
+        return {
+          role: 'assistant',
+          content: '',
+          tool_calls: [{ id: 'call_1', type: 'function', function: { name: 'get_awards', arguments: '{}' } }],
+        };
+      }
+      return { role: 'assistant', content: 'final report' };
+    },
+  };
+
+  const subagent = new ResearchSubagent({
+    client,
+    executeTool: async (name) => {
+      executed.push(name);
+      return { status: 'success', count: 2 };
+    },
+    maxIterations: 3,
+  });
+
+  const result = await subagent.run('native path');
+  assert.equal(executed[0], 'get_awards');
+  assert.match(result.answer, /final report/);
+});

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

@@ -0,0 +1,199 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { SuggestionEngine, SUGGESTION_CATEGORIES } from '../suggestions.js';
+import { routeCommand } from '../commands.js';
+import { eventBus, Events } from '../eventBus.js';
+import { wrapText, formatRichCardLines, stripAnsi, C } from '../ui.js';
+
+test('SuggestionEngine generates catalog fallback suggestions cleanly', () => {
+  const engine = new SuggestionEngine();
+  const suggestions = engine.generateCatalogSuggestions({ limit: 4 });
+
+  assert.equal(suggestions.length, 4);
+  assert.ok(suggestions[0].id === 1);
+  assert.ok(suggestions[0].question.length > 5);
+  assert.ok(suggestions[0].category);
+  assert.ok(SUGESTION_CATEGORIES_SET().has(suggestions[0].category));
+  assert.equal(engine.getLastSuggestions().length, 4);
+});
+
+test('SuggestionEngine filters catalog suggestions by topic', () => {
+  const engine = new SuggestionEngine();
+  const dramaSuggestions = engine.generateCatalogSuggestions({ topic: 'drama', limit: 3 });
+
+  assert.ok(dramaSuggestions.length > 0);
+  assert.ok(dramaSuggestions.some(s => s.category === 'DRAMA' || s.question.toLowerCase().includes('drama')));
+});
+
+test('SuggestionEngine parses AI JSON suggestions when LLM is available', async () => {
+  const mockClient = {
+    async chat() {
+      return {
+        content: JSON.stringify([
+          {
+            category: 'DRAMA',
+            question: "What is Ju Jingyi's role in the 2026 drama In Blossom?",
+            description: "Deep dive into Yang Caiwei character."
+          },
+          {
+            category: 'MUSIC',
+            question: "What are Ju Jingyi's newest 2025-2026 OST releases?",
+            description: "Song list and video links."
+          }
+        ])
+      };
+    }
+  };
+
+  const engine = new SuggestionEngine({ client: mockClient });
+  const suggestions = await engine.generateSuggestions({ limit: 2 });
+
+  assert.equal(suggestions.length, 2);
+  assert.equal(suggestions[0].category, 'DRAMA');
+  assert.equal(suggestions[0].source, 'ai_model');
+  assert.equal(suggestions[1].category, 'MUSIC');
+});
+
+test('SuggestionEngine falls back to catalog when LLM outputs invalid JSON', async () => {
+  const mockClient = {
+    async chat() {
+      return { content: 'Sorry, I cannot output JSON right now.' };
+    }
+  };
+
+  const engine = new SuggestionEngine({ client: mockClient });
+  const suggestions = await engine.generateSuggestions({ limit: 3 });
+
+  assert.equal(suggestions.length, 3);
+  assert.equal(suggestions[0].source, 'catalog');
+});
+
+test('resolveTargetQuestions parses numeric indexes, all, and custom queries', () => {
+  const engine = new SuggestionEngine();
+  engine.generateCatalogSuggestions({ limit: 5 });
+
+  const all = engine.resolveTargetQuestions('all');
+  assert.equal(all.length, 5);
+
+  const single = engine.resolveTargetQuestions('2');
+  assert.equal(single.length, 1);
+  assert.equal(single[0].id, 2);
+
+  const multiple = engine.resolveTargetQuestions('1, 3');
+  assert.equal(multiple.length, 2);
+  assert.equal(multiple[0].id, 1);
+  assert.equal(multiple[1].id, 3);
+});
+
+test('runBatchSubagents executes multiple workers concurrently and collects results', async () => {
+  const mockClient = {
+    async chat({ messages }) {
+      const last = messages[messages.length - 1];
+      if (last.role === 'user' && typeof last.content === 'string') {
+        return {
+          content: `Evidence findings for task: ${last.content.slice(0, 30)}... (Verified via local catalog).`
+        };
+      }
+      return { content: 'Worker report complete.' };
+    }
+  };
+
+  const engine = new SuggestionEngine({ client: mockClient });
+  engine.generateCatalogSuggestions({ limit: 3 });
+
+  const progressEvents = [];
+  const planEvents = [];
+
+  const unsubStart = eventBus.on(Events.AGENT_PLAN_START, data => planEvents.push({ type: 'start', ...data }));
+  const unsubStep = eventBus.on(Events.AGENT_PLAN_STEP_UPDATE, data => planEvents.push({ type: 'step', ...data }));
+  const unsubComplete = eventBus.on(Events.AGENT_PLAN_COMPLETE, data => planEvents.push({ type: 'complete', ...data }));
+
+  try {
+    const batchResult = await engine.runBatchSubagents('1, 2', {
+      onProgress: evt => progressEvents.push(evt),
+    });
+
+    assert.equal(batchResult.tasksCount, 2);
+    assert.equal(batchResult.successfulCount, 2);
+    assert.equal(batchResult.results.length, 2);
+    assert.ok(batchResult.results[0].answer.includes('Evidence findings'));
+    assert.ok(progressEvents.some(e => e.type === 'batch-start'));
+    assert.ok(progressEvents.some(e => e.type === 'worker-start'));
+    assert.ok(progressEvents.some(e => e.type === 'worker-complete'));
+    assert.ok(progressEvents.some(e => e.type === 'batch-complete'));
+    assert.ok(planEvents.some(e => e.type === 'start'));
+    assert.ok(planEvents.some(e => e.type === 'complete'));
+  } finally {
+    unsubStart();
+    unsubStep();
+    unsubComplete();
+  }
+});
+
+test('/suggestion command routes list, run, and auto subcommands', async () => {
+  let batchCalled = false;
+  let generateCalled = false;
+
+  const mockAgent = {
+    async generateSuggestions() {
+      generateCalled = true;
+      return [
+        { id: 1, category: 'DRAMA', question: 'Test drama question?', description: 'Desc 1' },
+        { id: 2, category: 'MUSIC', question: 'Test music question?', description: 'Desc 2' }
+      ];
+    },
+    async runSuggestionBatch(targets) {
+      batchCalled = true;
+      return {
+        batchId: 'test_batch',
+        tasksCount: 1,
+        successfulCount: 1,
+        elapsed: '0.42',
+        results: [
+          {
+            index: 1,
+            category: 'DRAMA',
+            question: 'Test drama question?',
+            answer: 'Yang Caiwei is the female lead.',
+            toolCalls: [{ name: 'search_works', args: { query: 'In Blossom' } }],
+            iterations: 1
+          }
+        ]
+      };
+    }
+  };
+
+  const listRes = await routeCommand('/suggestion', { agent: mockAgent, sub: '', extra: '' });
+  assert.equal(listRes, 'HANDLED');
+  assert.equal(generateCalled, true);
+
+  const runRes = await routeCommand('/suggestion run 1', { agent: mockAgent, sub: 'run', extra: '1' });
+  assert.equal(runRes, 'HANDLED');
+  assert.equal(batchCalled, true);
+
+  const aliasRes = await routeCommand('/suggest auto', { agent: mockAgent, sub: 'auto', extra: '' });
+  assert.equal(aliasRes, 'HANDLED');
+});
+
+test('wrapText preserves indentation, hanging indents for list markers, and active ANSI styles', () => {
+  const wrappedArrow = wrapText('      \x1b[2m↳ Overview of Versace Global Brand Ambassador role, Maybelline, and top endorsements.\x1b[0m', 45);
+  assert.ok(wrappedArrow.length >= 2, 'Arrow line should wrap into at least 2 lines');
+  assert.ok(wrappedArrow[0].startsWith('      \x1b[2m↳'), 'First line must retain initial indent of 6 spaces');
+  assert.ok(wrappedArrow[1].startsWith('        \x1b[2m'), 'Continuation line must align under text with hanging indent of 8 spaces');
+  assert.ok(wrappedArrow[1].includes('\x1b[2m'), 'Continuation line must retain active dim ANSI style');
+
+  const wrappedBullet = wrapText('  • Run parallel batch with subagents for comprehensive research', 30);
+  assert.ok(wrappedBullet.length >= 2, 'Bullet line should wrap');
+  assert.ok(wrappedBullet[0].startsWith('  •'), 'First line should have bullet marker');
+  assert.ok(wrappedBullet[1].startsWith('    '), 'Continuation line should indent under bullet');
+
+  const wrappedNumber = wrapText('  [1] [FASHION] What are Ju Jingyi\'s major luxury brand ambassadorships and global fashion partnerships?', 40);
+  assert.ok(wrappedNumber.length >= 2, 'Numbered item should wrap');
+  assert.ok(wrappedNumber[0].startsWith('  [1]'), 'First line should have number marker');
+  assert.ok(wrappedNumber[1].startsWith('      '), 'Continuation line should indent with hanging indent');
+});
+
+function SUGESTION_CATEGORIES_SET() {
+  return new Set(SUGGESTION_CATEGORIES);
+}
+