kiku-agent 1.3.0 → 1.3.2

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);
+}
+

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

@@ -0,0 +1,251 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+
+import {
+  getCategoryBadge,
+  formatWorkerProgressMatrix,
+  formatExecutiveFindings,
+  stripAnsi,
+} from '../ui.js';
+import {
+  renderSuggestionStudioView,
+  promptInteractiveSuggestion,
+  SUGGESTION_STUDIO_TABS,
+} from '../suggestionTui.js';
+import { routeCommand } from '../commands.js';
+
+const SAMPLE_SUGGESTIONS = [
+  {
+    id: 1,
+    category: 'DRAMA',
+    question: "What are Ju Jingyi's upcoming 2026/2025 drama projects?",
+    description: "Detailed breakdown of upcoming dramas and broadcasting platforms.",
+    tools: ['search_works', 'web_search'],
+    depth: 'Deep Analysis',
+    estimatedSeconds: 3,
+  },
+  {
+    id: 2,
+    category: 'MUSIC',
+    question: "What are the most popular OSTs and solo singles released by Ju Jingyi?",
+    description: "Discography highlights from In Blossom and Legend of Yunxi.",
+    tools: ['search_discography', 'search_videos'],
+    depth: 'Media Scan',
+    estimatedSeconds: 2,
+  },
+  {
+    id: 3,
+    category: 'FASHION',
+    question: "What are Ju Jingyi's major luxury brand ambassadorships in 2025-2026?",
+    description: "Overview of Versace Global Brand Ambassador role and endorsements.",
+    tools: ['get_profile_and_fandom'],
+    depth: 'Portfolio Scan',
+    estimatedSeconds: 2,
+  },
+];
+
+test('getCategoryBadge returns distinctive icons and colors for all 6 categories', () => {
+  const drama = getCategoryBadge('DRAMA');
+  assert.equal(drama.icon, '🌸');
+  assert.equal(drama.label, 'DRAMA');
+  assert.ok(drama.color);
+
+  const music = getCategoryBadge('MUSIC');
+  assert.equal(music.icon, '🎵');
+  assert.equal(music.label, 'MUSIC');
+
+  const fashion = getCategoryBadge('FASHION');
+  assert.equal(fashion.icon, '✨');
+  assert.equal(fashion.label, 'FASHION');
+
+  const awards = getCategoryBadge('MILESTONE');
+  assert.equal(awards.icon, '🌸');
+  assert.equal(awards.label, 'AWARDS');
+
+  const analysis = getCategoryBadge('ANALYSIS');
+  assert.equal(analysis.icon, '📖');
+  assert.equal(analysis.label, 'ANALYSIS');
+
+  const trivia = getCategoryBadge('TRIVIA');
+  assert.equal(trivia.icon, '💬');
+  assert.equal(trivia.label, 'TRIVIA');
+
+  const unknown = getCategoryBadge('OTHER');
+  assert.equal(unknown.icon, '✨');
+  assert.equal(unknown.label, 'OTHER');
+});
+
+test('renderSuggestionStudioView renders complete interactive studio frame', () => {
+  const rows = renderSuggestionStudioView({
+    suggestions: SAMPLE_SUGGESTIONS,
+    selectedIndex: 0,
+    selectedIds: new Set([1]),
+    activeCategory: 'ALL',
+    termWidth: 80,
+  });
+
+  assert.ok(rows.length > 5);
+  const plainText = rows.map(r => stripAnsi(r)).join('\n');
+
+
+  assert.ok(plainText.includes('🌸 KIKU SUGGESTION STUDIO'));
+  assert.ok(plainText.includes('DRAMA'));
+  assert.ok(plainText.includes('MUSIC'));
+  assert.ok(plainText.includes('FASHION'));
+
+
+  assert.ok(plainText.includes('❯ [◉] 1.'));
+  assert.ok(plainText.includes('[ ] 2.'));
+
+
+  assert.ok(plainText.includes('Focus:'));
+  assert.ok(plainText.includes('Tools:'));
+  assert.ok(plainText.includes('Est:'));
+
+
+  assert.ok(plainText.includes('[↑/↓] Nav'));
+  assert.ok(plainText.includes('[Enter] Launch Batch (1)'));
+});
+
+test('renderSuggestionStudioView correctly filters suggestions by category tab', () => {
+  const dramaRows = renderSuggestionStudioView({
+    suggestions: SAMPLE_SUGGESTIONS,
+    selectedIndex: 0,
+    selectedIds: new Set(),
+    activeCategory: 'DRAMA',
+    termWidth: 100,
+  });
+
+  const plainText = dramaRows.map(r => stripAnsi(r)).join('\n');
+  assert.ok(plainText.includes('upcoming 2026/2025 drama'));
+  assert.ok(!plainText.includes('popular OSTs and solo singles'));
+
+
+  const emptyRows = renderSuggestionStudioView({
+    suggestions: SAMPLE_SUGGESTIONS,
+    selectedIndex: 0,
+    selectedIds: new Set(),
+    activeCategory: 'TRIVIA',
+    termWidth: 80,
+  });
+  const emptyText = emptyRows.map(r => stripAnsi(r)).join('\n');
+  assert.ok(emptyText.includes('No suggestions found under TRIVIA'));
+});
+
+test('promptInteractiveSuggestion exits immediately on non-TTY without hanging', async () => {
+  const mockStdin = new EventEmitter();
+  mockStdin.isTTY = false;
+  const mockStdout = { isTTY: false, columns: 80, write: () => {} };
+
+  const res = await promptInteractiveSuggestion(SAMPLE_SUGGESTIONS, {
+    stdin: mockStdin,
+    stdout: mockStdout,
+  });
+
+  assert.equal(res.action, 'display');
+  assert.equal(res.targets, null);
+});
+
+test('formatWorkerProgressMatrix renders unified concurrent progress table', () => {
+  const workers = [
+    { index: 1, category: 'DRAMA', state: 'running', currentTool: 'search_works', question: 'Upcoming dramas?' },
+    { index: 2, category: 'MUSIC', state: 'complete', currentTool: '', question: 'Popular OSTs?' },
+    { index: 3, category: 'FASHION', state: 'error', currentTool: '', question: 'Versace role?' },
+  ];
+
+  const rows = formatWorkerProgressMatrix({
+    workers,
+    batchId: 'batch_test_1',
+    elapsed: '1.8',
+    termWidth: 80,
+  });
+
+  assert.ok(rows.length >= 5);
+  const plainText = rows.map(r => stripAnsi(r)).join('\n');
+
+  assert.ok(plainText.includes('CONCURRENT RESEARCH SUBAGENTS'));
+  assert.ok(plainText.includes('3 Workers • 1.8s'));
+  assert.ok(plainText.includes('W1 [🌸 DRAMA]'));
+  assert.ok(plainText.includes('Working'));
+  assert.ok(plainText.includes('W2 [🎵 MUSIC]'));
+  assert.ok(plainText.includes('Done'));
+  assert.ok(plainText.includes('W3 [✨ FASHION]'));
+  assert.ok(plainText.includes('Error'));
+});
+
+test('formatExecutiveFindings synthesizes findings, takeaways, and grounded citations', () => {
+  const batchResult = {
+    tasksCount: 2,
+    successfulCount: 2,
+    elapsed: '2.4',
+    results: [
+      {
+        index: 1,
+        category: 'DRAMA',
+        question: 'Upcoming dramas?',
+        answer: 'Ju Jingyi has multiple upcoming drama productions announced.',
+        toolCalls: [{ name: 'search_works' }],
+        iterations: 2,
+      },
+      {
+        index: 2,
+        category: 'FASHION',
+        question: 'Versace role?',
+        answer: 'Ju Jingyi was named Versace Global Brand Ambassador.',
+        toolCalls: [{ name: 'get_profile_and_fandom' }],
+        iterations: 1,
+      },
+    ],
+  };
+
+  const rows = formatExecutiveFindings({ batchResult, termWidth: 80 });
+  assert.ok(rows.length > 5);
+  const plainText = rows.map(r => stripAnsi(r)).join('\n');
+
+  assert.ok(plainText.includes('KIKU EXECUTIVE RESEARCH FINDINGS'));
+  assert.ok(plainText.includes('2/2 Succeeded • 2.4s'));
+  assert.ok(plainText.includes('[Worker 1] DRAMA: Upcoming dramas?'));
+  assert.ok(plainText.includes('Grounded Evidence: 1 tool calls executed'));
+  assert.ok(plainText.includes('[Worker 2] FASHION: Versace role?'));
+  assert.ok(plainText.includes('/session export'));
+});
+
+test('Commands: /suggestion executes cleanly in non-interactive routeCommand', async () => {
+  let generateCalled = false;
+  let batchCalled = false;
+
+  const mockAgent = {
+    async generateSuggestions() {
+      generateCalled = true;
+      return SAMPLE_SUGGESTIONS;
+    },
+    async runSuggestionBatch(targets) {
+      batchCalled = true;
+      return {
+        batchId: 'batch_test',
+        tasksCount: 1,
+        successfulCount: 1,
+        elapsed: '0.5',
+        results: [
+          {
+            index: 1,
+            category: 'DRAMA',
+            question: 'Upcoming dramas?',
+            answer: 'Yang Caiwei in In Blossom received critical acclaim.',
+            toolCalls: [{ name: 'search_works', args: {} }],
+            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);
+});