kiku-agent 1.3.2 → 1.3.4

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

@@ -0,0 +1,197 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  buildSystemPrompt,
+  buildOpenDomainSystemPrompt,
+  buildInDomainSystemPrompt,
+  buildDynamicRoutingDirective
+} from '../prompts.js';
+import {
+  classifyQuerySpectrum,
+  classifyQueryDomain,
+  isQueryInDomain
+} from '../catalogEntityResolver.js';
+import { KikuAgent } from '../agentCore.js';
+
+test('buildOpenDomainSystemPrompt includes coding, math, science, and awakening directives', () => {
+  const prompt = buildOpenDomainSystemPrompt(['web_search', 'search_encyclopedia']);
+
+
+  assert.ok(prompt.includes('SOFTWARE ENGINEERING & CODING EXCELLENCE'));
+  assert.ok(prompt.includes('markdown fenced code blocks'));
+  assert.ok(prompt.includes('time complexity $O(N)$'));
+
+
+  assert.ok(prompt.includes('MATHEMATICS & SCIENTIFIC RIGOR'));
+  assert.ok(prompt.includes('LaTeX / KaTeX'));
+  assert.ok(prompt.includes('$ ... $'));
+  assert.ok(prompt.includes('$$ ... $$'));
+  assert.ok(prompt.includes('step-by-step reasoning'));
+
+
+  assert.ok(prompt.includes('CONTEXT AWAKENING PROTOCOL'));
+  assert.ok(prompt.includes('ตื่นรู้เข้าสู่บริบท'));
+  assert.ok(prompt.includes('search_works'));
+  assert.ok(prompt.includes('search_discography'));
+
+
+  assert.ok(prompt.includes('OPEN-DOMAIN TOOL RETRIEVAL & INTEGRITY'));
+  assert.ok(prompt.includes('web_search'));
+
+
+  assert.ok(prompt.includes('Fibonacci'));
+  assert.ok(prompt.includes('แคลคูลัส'));
+  assert.ok(prompt.includes('เทอร์โมไดนามิกส์'));
+  assert.ok(prompt.includes('[CONTEXT AWAKENING ACTIVATED]'));
+});
+
+test('buildInDomainSystemPrompt retains full Ju Jingyi concierge persona', () => {
+  const prompt = buildInDomainSystemPrompt(['search_works', 'search_discography']);
+
+  assert.ok(prompt.includes('KIKU AGENT (菊)'));
+  assert.ok(prompt.includes('authoritative AI encyclopedia agent and concierge for international artist Ju Jingyi'));
+  assert.ok(prompt.includes('MANDATORY RETRIEVAL RULE'));
+  assert.ok(prompt.includes('DUAL-TIER RETRIEVAL ARCHITECTURE'));
+  assert.ok(prompt.includes('ENTITY & UNIT DISAMBIGUATION'));
+});
+
+test('buildSystemPrompt dispatcher honors options and maintains backward compatibility', () => {
+
+  const defaultPrompt = buildSystemPrompt();
+  assert.ok(defaultPrompt.includes('concierge for international artist Ju Jingyi'));
+
+  const inDomainPrompt = buildSystemPrompt([], { inDomain: true });
+  assert.ok(inDomainPrompt.includes('concierge for international artist Ju Jingyi'));
+
+  const inDomainExplicit = buildSystemPrompt([], { domain: 'IN_DOMAIN' });
+  assert.ok(inDomainExplicit.includes('concierge for international artist Ju Jingyi'));
+
+ 
+  const openDomainPrompt = buildSystemPrompt([], { inDomain: false });
+  assert.ok(openDomainPrompt.includes('OPEN-DOMAIN TECHNICAL & PROBLEM-SOLVING MODE'));
+  assert.ok(openDomainPrompt.includes('CONTEXT AWAKENING PROTOCOL'));
+
+
+  const openDomainExplicit = buildSystemPrompt([], { domain: 'OPEN_DOMAIN' });
+  assert.ok(openDomainExplicit.includes('OPEN-DOMAIN TECHNICAL & PROBLEM-SOLVING MODE'));
+});
+
+test('buildDynamicRoutingDirective includes open-domain and general tools', () => {
+  const directive = buildDynamicRoutingDirective([
+    'web_search',
+    'search_encyclopedia',
+    'get_weather',
+    'search_location_map',
+    'read_local_file',
+  ]);
+
+  assert.ok(directive.includes('Web Search & News -> web_search'));
+  assert.ok(directive.includes('Encyclopedia & General Knowledge -> search_encyclopedia'));
+  assert.ok(directive.includes('Real-time Weather & Location -> get_weather'));
+  assert.ok(directive.includes('Maps & Navigation -> search_location_map'));
+  assert.ok(directive.includes('System & Files -> read_local_file'));
+});
+
+test('classifyQuerySpectrum identifies coding, mathematics, and science as OPEN_DOMAIN', () => {
+  const testCases = [
+   
+    'ช่วยเขียนโค้ด Python เชื่อมต่อ WebSocket ให้หน่อย',
+    'สอนเขียนโปรแกรม Golang จัดการ Goroutines',
+    'แก้บั๊ก React useEffect infinite loop',
+    'เขียนฟังก์ชัน TypeScript สำหรับ debounce',
+    'Write a quicksort algorithm in C++',
+
+
+    'ช่วยแก้โจทย์คณิตศาสตร์หน่อย อินทิกรัล 2x dx',
+    'แก้สมการ x^2 - 5x + 6 = 0 ให้ดูทีละขั้นตอน',
+    'ช่วยคำนวณแคลคูลัสหาอนุพันธ์ของ f(x) = sin(x)*e^x',
+    'อธิบายทฤษฎีบทพีทาโกรัสและวิธีพิสูจน์',
+    'Calculate the eigenvalues of a 2x2 matrix',
+
+ 
+    'อธิบายกฎข้อที่ 2 ของเทอร์โมไดนามิกส์',
+    'กระบวนการสังเคราะห์ด้วยแสงในพืช light reaction กับ dark reaction แตกต่างกันอย่างไร',
+    'ทำไมน้ำถึงมีพันธะไฮโดรเจนและมีความจุความร้อนสูง',
+    'Explain the structure of an atom and electron orbitals',
+    'ความแตกต่างระหว่างแรงโน้มถ่วงและแรงแม่เหล็กไฟฟ้า'
+  ];
+
+  for (const query of testCases) {
+    const domain = classifyQueryDomain(query);
+    const inDomain = isQueryInDomain(query);
+    assert.strictEqual(domain, 'OPEN_DOMAIN', `Expected OPEN_DOMAIN for query: "${query}"`);
+    assert.strictEqual(inDomain, false, `Expected inDomain=false for query: "${query}"`);
+  }
+});
+
+test('classifyQuerySpectrum awakens to IN_DOMAIN when Ju Jingyi or catalog entities are mentioned', () => {
+  const awakeningCases = [
+   
+    'ช่วยเขียนโค้ด Python ดึงรายชื่อผลงานซีรีส์ของจวีจิ้งอี',
+    'คำนวณว่าจวีจิ้งอีเดบิวต์ในวงการมากี่ปีแล้ว',
+    'เพลง 0.2s ของจวีจิ้งอีมีความยาวกี่นาที',
+    'ซีรีส์เรื่อง In Blossom จวีจิ้งอีแสดงเป็นตัวละครอะไร',
+    'จวีจิ้งอีเป็นแอมบาสเดอร์ของแบรนด์ FRED Paris ตั้งแต่ปีไหน',
+    'ยอดขายกล่องของขวัญ TuTuCare ของจวีจิ้งอีขายหมดในกี่วินาที',
+    'เพลง Dewdrops ประกอบซีรีส์เรื่องอะไร',
+    'What dramas has Ju Jingyi starred in?'
+  ];
+
+  for (const query of awakeningCases) {
+    const domain = classifyQueryDomain(query);
+    const inDomain = isQueryInDomain(query);
+    assert.strictEqual(domain, 'IN_DOMAIN', `Expected IN_DOMAIN awakening for query: "${query}"`);
+    assert.strictEqual(inDomain, true, `Expected inDomain=true for query: "${query}"`);
+  }
+});
+
+test('KikuAgent dynamically adapts systemPrompt between open-domain and in-domain turns', async () => {
+  const agent = new KikuAgent();
+  await agent.ready();
+
+ 
+  const inDomainPrompt = agent.buildSystemPrompt(null, { inDomain: true });
+  assert.ok(inDomainPrompt.includes('concierge for international artist Ju Jingyi'));
+
+  const openDomainPrompt = agent.buildSystemPrompt(null, { inDomain: false });
+  assert.ok(openDomainPrompt.includes('OPEN-DOMAIN TECHNICAL & PROBLEM-SOLVING MODE'));
+  assert.ok(openDomainPrompt.includes('CONTEXT AWAKENING PROTOCOL'));
+});
+
+test('KikuAgent ask() triggers Context Awakening in multi-turn transition', async () => {
+  const capturedMessagesList = [];
+  const mockClient = {
+    model: 'mock-kiku',
+    baseUrl: 'http://127.0.0.1:1234',
+    provider: 'lmstudio',
+    providerName: 'lmstudio',
+    chat: async ({ messages }) => {
+      capturedMessagesList.push([...messages]);
+      return {
+        content: 'Response from mock LLM'
+      };
+    }
+  };
+
+  const agent = new KikuAgent({ client: mockClient });
+  await agent.ready();
+
+  
+  await agent.ask('ช่วยเขียนฟังก์ชัน Python สำหรับคำนวณ Fibonacci หน่อย');
+  assert.strictEqual(capturedMessagesList.length, 1);
+  const turn1Messages = capturedMessagesList[0];
+  const turn1SystemPrompt = turn1Messages[0].content;
+  assert.ok(turn1SystemPrompt.includes('OPEN-DOMAIN TECHNICAL & PROBLEM-SOLVING MODE'), 'Turn 1 must use open-domain system prompt');
+  const turn1OpenDirective = turn1Messages.find(m => typeof m.content === 'string' && m.content.includes('OPEN-DOMAIN EXPERT DIRECTIVE'));
+  assert.ok(turn1OpenDirective, 'Turn 1 must include OPEN-DOMAIN EXPERT DIRECTIVE');
+
+ 
+  await agent.ask('แล้วจวีจิ้งอีมีผลงานซีรีส์เรื่องล่าสุดอะไรบ้าง?');
+  assert.strictEqual(capturedMessagesList.length, 2);
+  const turn2Messages = capturedMessagesList[1];
+  const turn2SystemPrompt = turn2Messages[0].content;
+  assert.ok(turn2SystemPrompt.includes('concierge for international artist Ju Jingyi'), 'Turn 2 must awaken to Ju Jingyi concierge persona');
+  const turn2AwakeningDirective = turn2Messages.find(m => typeof m.content === 'string' && m.content.includes('CONTEXT AWAKENING ACTIVATED'));
+  assert.ok(turn2AwakeningDirective, 'Turn 2 must include CONTEXT AWAKENING ACTIVATED directive');
+});
+

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

@@ -0,0 +1,121 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  classifyQueryDomain,
+  isQueryInDomain,
+  QUERY_DOMAINS,
+  getContextualizedSearchQuery
+} from '../catalogEntityResolver.js';
+import { dynamicToolRouter } from '../toolRouter.js';
+import { buildImageSearchQuery } from '../webSearch.js';
+import { createCatalogMatcher, toolHandlers } from '../tools.js';
+
+test('classifyQueryDomain and isQueryInDomain correctly classify in-domain and open-domain queries', () => {
+ 
+  const inDomainQueries = [
+    'จวีจิ้งอี มีผลงานอะไรบ้าง',
+    'Ju Jingyi dramas 2026',
+    '鞠婧祎 花间令',
+    'เพลง 0.2s ใครร้อง',
+    'เสี่ยวจวี เป็นแบรนด์แอมบาสเดอร์อะไรบ้าง',
+    'Veil of Shadows พระเอกคือใคร',
+    'ตำนานรักนางพญางูขาว เล่นเป็นใคร',
+    'Kiku fanclub',
+    'แบรนด์ FRED Paris จวีจิ้งอี'
+  ];
+
+  for (const q of inDomainQueries) {
+    assert.equal(
+      isQueryInDomain(q),
+      true,
+      `Expected "${q}" to be recognized as in-domain`
+    );
+  }
+
+ 
+  const openDomainQueries = [
+    'วิธีทำต้มยำกุ้งน้ำข้น',
+    'สภาพอากาศ โตเกียว วันนี้',
+    'What is quantum computing?',
+    'Who won the 2022 FIFA World Cup?',
+    'Bitcoin price history and future outlook',
+    'Taylor Swift The Eras Tour setlist',
+    'ทฤษฎีสัมพัทธภาพของไอน์สไตน์คืออะไร',
+    'ประวัติศาสตร์อยุธยาตอนต้น',
+    'How to fix TypeError in JavaScript',
+    'สูตรทำข้าวมันไก่'
+  ];
+
+  for (const q of openDomainQueries) {
+    assert.equal(
+      classifyQueryDomain(q),
+      QUERY_DOMAINS.OPEN_DOMAIN,
+      `Expected "${q}" to be classified as OPEN_DOMAIN`
+    );
+    assert.equal(
+      isQueryInDomain(q),
+      false,
+      `Expected "${q}" to NOT be in-domain`
+    );
+  }
+});
+
+test('getContextualizedSearchQuery preserves open-domain queries without injecting artist tokens', () => {
+  const openQuery = 'วิธีทำแกงเขียวหวานไก่';
+  const result = getContextualizedSearchQuery(openQuery, 'chinese_web');
+  assert.equal(result, openQuery, 'Open-domain query should not have artist injected');
+  assert.equal(result.includes('鞠婧祎'), false);
+  assert.equal(result.includes('จวีจิ้งอี'), false);
+
+  const inDomainQuery = 'ผลงานเพลง 0.2s';
+  const inDomainResult = getContextualizedSearchQuery(inDomainQuery, 'chinese_web');
+  assert.ok(
+    inDomainResult.includes('鞠婧祎') || inDomainResult.includes('0.2s') || inDomainResult.includes('0.2秒'),
+    'In-domain query should be contextualized'
+  );
+});
+
+test('buildImageSearchQuery does not prepend artist tokens for open-domain queries', () => {
+  const openQuery = 'Eiffel Tower at night';
+  const imgQuery = buildImageSearchQuery(openQuery);
+  assert.equal(imgQuery, 'Eiffel Tower at night');
+  assert.equal(imgQuery.includes('鞠婧祎'), false);
+
+  const inDomainQuery = 'In Blossom drama poster';
+  const inDomainImgQuery = buildImageSearchQuery(inDomainQuery);
+  assert.ok(inDomainImgQuery.includes('鞠婧祎'), 'In-domain query should include artist name');
+});
+
+test('toolRouter detects OPEN_DOMAIN intent and routes general web/encyclopedia search tools', () => {
+  const openQuery = 'ทำไมท้องฟ้าถึงเป็นสีฟ้า';
+  const intents = dynamicToolRouter.detectIntents(openQuery).map(p => p.type);
+  assert.ok(
+    intents.includes('OPEN_DOMAIN'),
+    'Should detect OPEN_DOMAIN intent for general science query'
+  );
+
+  const tools = dynamicToolRouter.routeToolsForQuery(openQuery);
+  const toolNames = tools.map(t => t.function?.name || t.name);
+  assert.ok(toolNames.includes('web_search'), 'Should include web_search for open-domain queries');
+  assert.ok(
+    !toolNames.includes('search_discography'),
+    'Should not force search_discography on open-domain science question'
+  );
+});
+
+test('search_works matches plot concepts and synopses in Thai', async () => {
+ 
+  const res = await toolHandlers.search_works({ query: 'แฟนตาซี' });
+  assert.equal(res.status, 'success');
+  assert.ok(res.count > 0);
+  assert.ok(
+    res.works.some(w => (w.synopsis || '').includes('แฟนตาซี') || (w.titleEn || '').includes('Veil of Shadows'))
+  );
+});
+
+test('createCatalogMatcher handles unspaced Thai queries with stop phrases', () => {
+  const matcher = createCatalogMatcher('อยากดูซีรีส์แนวสืบคดี');
+ 
+  const haystack = 'ซีรีส์แฟนตาซีฟอร์มยักษ์ นำไปสู่การสืบคดีสไตล์หักเหลี่ยมซ่อนเงื่อน';
+  assert.equal(matcher(haystack), true);
+});

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

@@ -0,0 +1,144 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import {
+  isPidAlive,
+  killProcessTreeSync,
+  registerBackgroundProcess,
+  unregisterBackgroundProcess,
+  getBackgroundProcess,
+  listBackgroundProcesses,
+  stopBackgroundProcess,
+  stopAllBackgroundProcessesSync,
+  initProcessExitHooks,
+  clearProcessRegistry,
+  killWslProcessByName,
+} from '../processManager.js';
+
+test('isPidAlive correctly identifies running and dead processes', () => {
+  assert.equal(isPidAlive(process.pid), true, 'Current node process should be alive');
+  assert.equal(isPidAlive(0), false, 'PID 0 should not be alive');
+  assert.equal(isPidAlive(-1), false, 'Negative PID should not be alive');
+  assert.equal(isPidAlive(null), false, 'Null PID should return false');
+  assert.equal(isPidAlive(99999999), false, 'Arbitrary high PID should not be alive');
+});
+
+test('processManager registers, queries, and unregisters background processes', () => {
+  clearProcessRegistry();
+
+  const dummyPid = process.pid;
+  const rec = registerBackgroundProcess('test-proc', dummyPid, {
+    command: 'node',
+    args: ['test.js'],
+    metadata: { test: true },
+  });
+
+  assert.equal(rec.name, 'test-proc');
+  assert.equal(rec.pid, dummyPid);
+  assert.equal(rec.status, 'running');
+
+  const fetched = getBackgroundProcess('test-proc');
+  assert.ok(fetched);
+  assert.equal(fetched.name, 'test-proc');
+  assert.equal(fetched.pid, dummyPid);
+  assert.equal(fetched.isAlive, true);
+
+  const list = listBackgroundProcesses();
+  assert.ok(list.some(p => p.name === 'test-proc' && p.pid === dummyPid));
+
+  const removed = unregisterBackgroundProcess('test-proc');
+  assert.equal(removed, true);
+  assert.equal(getBackgroundProcess('test-proc'), null);
+
+  clearProcessRegistry();
+});
+
+test('processManager tracks real child process and terminates it cleanly via tree kill', async () => {
+  clearProcessRegistry();
+
+  const child = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 20000)'], {
+    stdio: 'ignore',
+    windowsHide: true,
+  });
+
+  assert.ok(child.pid > 0);
+  assert.equal(isPidAlive(child.pid), true);
+
+  registerBackgroundProcess('sleep-job', child, {
+    command: process.execPath,
+    metadata: { job: 'timeout' },
+  });
+
+  const procInfo = getBackgroundProcess('sleep-job');
+  assert.equal(procInfo.isAlive, true);
+  assert.equal(procInfo.pid, child.pid);
+
+  const stopResult = stopBackgroundProcess('sleep-job');
+  assert.equal(stopResult.ok, true);
+  assert.equal(stopResult.status, 'stopped');
+
+  await new Promise(r => setTimeout(r, 200));
+  assert.equal(isPidAlive(child.pid), false, 'Child process should be terminated');
+
+  clearProcessRegistry();
+});
+
+test('processManager validates input arguments defensively', () => {
+  assert.throws(() => registerBackgroundProcess('', 1234), /must be a non-empty string/);
+  assert.throws(() => registerBackgroundProcess('bad-pid', -5), /Invalid PID/);
+  assert.throws(() => registerBackgroundProcess('bad-null', null), /Invalid PID/);
+});
+
+test('initProcessExitHooks is idempotent and safe', () => {
+  assert.doesNotThrow(() => {
+    initProcessExitHooks();
+    initProcessExitHooks();
+  });
+});
+
+test('killWslProcessByName handles safe fallback', () => {
+  assert.equal(killWslProcessByName(null, 'test'), false);
+  assert.equal(killWslProcessByName('Ubuntu', null), false);
+});
+
+test('stopAllBackgroundProcessesSync cleanly stops all registered processes', () => {
+  clearProcessRegistry();
+
+  const child1 = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 20000)'], { stdio: 'ignore' });
+  const child2 = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 20000)'], { stdio: 'ignore' });
+
+  registerBackgroundProcess('worker-1', child1);
+  registerBackgroundProcess('worker-2', child2);
+
+  const stopped = stopAllBackgroundProcessesSync();
+  assert.equal(stopped.length, 2);
+
+  assert.equal(isPidAlive(child1.pid), false);
+  assert.equal(isPidAlive(child2.pid), false);
+
+  clearProcessRegistry();
+});
+
+test('stopAllBackgroundProcessesSync preserves persistOnExit processes on exit unless force is passed', () => {
+  clearProcessRegistry();
+
+  const persistentChild = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 20000)'], { stdio: 'ignore' });
+  const ephemeralChild = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 20000)'], { stdio: 'ignore' });
+
+  registerBackgroundProcess('daemon-service', persistentChild, { persistOnExit: true });
+  registerBackgroundProcess('worker-job', ephemeralChild);
+
+  const normalExitStopped = stopAllBackgroundProcessesSync({ force: false });
+  assert.equal(normalExitStopped.length, 1);
+  assert.equal(normalExitStopped[0].name, 'worker-job');
+  assert.equal(isPidAlive(ephemeralChild.pid), false);
+  assert.equal(isPidAlive(persistentChild.pid), true, 'Persistent daemon should remain alive on standard exit');
+
+  const forcedStopped = stopAllBackgroundProcessesSync({ force: true });
+  assert.equal(forcedStopped.length, 1);
+  assert.equal(forcedStopped[0].name, 'daemon-service');
+  assert.equal(isPidAlive(persistentChild.pid), false, 'Persistent daemon stops when forced');
+
+  clearProcessRegistry();
+});
+

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

@@ -1,15 +1,20 @@
-import test from 'node:test';
+import test, { after } from 'node:test';
+import os from 'node:os';
+import path from 'node:path';
 import assert from 'node:assert/strict';
+const isolatedSettingsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kiku-provider-test-'));
+process.env.KIKU_DATA_DIR = isolatedSettingsDir;
+after(() => fs.rmSync(isolatedSettingsDir, { recursive: true, force: true }));
 import fs from 'node:fs';
-import { SETTINGS_FILE } from '../appPaths.js';
-import {
+const { SETTINGS_FILE } = await import("../appPaths.js");
+const {
   savePersistedActiveProvider,
   savePersistedProviderModel,
   getPersistedActiveProvider,
   loadPersistedSettings,
   CLOUD_PROVIDERS,
-} from '../config.js';
-import { LLMClient } from '../llmClient.js';
+} = await import("../config.js");
+const { LLMClient } = await import("../llmClient.js");
 
 test('Provider and Model settings persist across restarts', () => {
   const originalGroqModel = CLOUD_PROVIDERS.groq.defaultModel;

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

@@ -0,0 +1,180 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readFileSync } from 'node:fs';
+import { Readable } from 'node:stream';
+import { EventEmitter } from 'node:events';
+import { getWebChatHtml } from '../../webChatHtml.js';
+import { handleChatRoute } from '../../web-chat/routes/chatRoute.js';
+
+test('Web Chat HTML contains timeline-modal, research-modal, and verify-modal', () => {
+  const html = getWebChatHtml();
+  assert.match(html, /id="timeline-modal"/, 'timeline-modal must exist');
+  assert.match(html, /id="timeline-body"/, 'timeline-body must exist inside modal');
+  assert.match(html, /id="research-modal"/, 'research-modal must exist');
+  assert.match(html, /id="research-modal-input"/, 'research-modal-input textarea must exist');
+  assert.match(html, /id="verify-modal"/, 'verify-modal must exist');
+  assert.match(html, /id="verify-modal-input"/, 'verify-modal-input textarea must exist');
+
+  // Verify quick action menu items call modal openers
+  assert.match(html, /onclick="openResearchModal\(\); closeQuickActions\(\)"/);
+  assert.match(html, /onclick="openVerifyModal\(\); closeQuickActions\(\)"/);
+  assert.match(html, /onclick="openTimelineModal\(\); closeQuickActions\(\)"/);
+});
+
+test('client.js parses timeline data correctly whether wrapped in data array or milestones', () => {
+  const src = readFileSync(new URL('../../web-chat/ui/scripts/client.js', import.meta.url), 'utf8');
+
+  // Verify loadTimelineData parses array from json.data
+  assert.ok(src.includes('const items = Array.isArray(json)'));
+  assert.ok(src.includes('Array.isArray(json.data) ? json.data'));
+
+  // Test parsing logic with actual API responses
+  const apiFormat = {
+    status: 'success',
+    code: 200,
+    data: [
+      { id: '1', year: '2013', era: 'snh48', title: 'Debut' },
+      { id: '2', year: '2024', era: 'solo', title: 'In Blossom' }
+    ]
+  };
+
+  const parseItems = (json) => {
+    return Array.isArray(json)
+      ? json
+      : (Array.isArray(json.data) ? json.data : (json.data?.milestones || json.milestones || []));
+  };
+
+  const parsed = parseItems(apiFormat);
+  assert.equal(parsed.length, 2);
+  assert.equal(parsed[0].title, 'Debut');
+  assert.equal(parsed[1].title, 'In Blossom');
+});
+
+test('chatRoute streams /research queries via agent.runResearch with subagent_progress SSE', async () => {
+  const progressEvents = [];
+  let calledQuery = '';
+  let calledOptions = null;
+
+  const mockAgent = {
+    async runResearch(question, options = {}) {
+      calledQuery = question;
+      calledOptions = options;
+      options.onProgress?.({ type: 'worker-start', id: 'worker-1', label: 'Local Catalog Explorer' });
+      options.onProgress?.({ type: 'worker-complete', id: 'worker-1', label: 'Local Catalog Explorer' });
+      return {
+        id: 'res_test_123',
+        answer: 'จวีจิ้งอีได้รับรางวัลมากมายตั้งแต่ยุค SNH48 จนถึงศิลปินเดี่ยว',
+        sources: ['https://weibo.com/jujingyi'],
+        reports: [{ toolCalls: [{ name: 'get_awards', args: {}, result: { count: 5 }, duration: 12 }] }]
+      };
+    },
+    session: {
+      createUserMessage: () => {},
+      createAssistantMessage: () => {}
+    },
+    conversationHistory: []
+  };
+
+  const mockResolve = async () => ({
+    ready: true,
+    agent: mockAgent,
+    client: { provider: 'lmstudio' },
+    provider: 'lmstudio'
+  });
+
+  const req = Readable.from([JSON.stringify({ query: '/research รางวัลทั้งหมดของจวีจิ้งอี', stream: true })]);
+  req.headers = { accept: 'text/event-stream' };
+  req.socket = { remoteAddress: '127.0.0.1' };
+
+  const res = new EventEmitter();
+  res.chunks = '';
+  res.writeHead = (code, headers) => { res.statusCode = code; res.headers = headers; };
+  res.write = (chunk) => { res.chunks += chunk; };
+  res.end = (chunk = '') => { res.chunks += chunk; res.writableEnded = true; };
+
+  await handleChatRoute(req, res, new URL('http://localhost/api/chat'), { resolveConnection: mockResolve });
+
+  assert.equal(calledQuery, 'รางวัลทั้งหมดของจวีจิ้งอี');
+  assert.equal(calledOptions?.mode, 'research');
+
+  // Verify SSE stream contains subagent_progress and final answer
+  assert.ok(res.chunks.includes('subagent_progress'));
+  assert.ok(res.chunks.includes('Local Catalog Explorer'));
+  assert.ok(res.chunks.includes('จวีจิ้งอีได้รับรางวัลมากมาย'));
+  assert.ok(res.chunks.includes('"type":"final"'));
+  assert.ok(res.chunks.includes('[DONE]'));
+});
+
+test('chatRoute streams /verify queries via agent.runResearch with mode: verify', async () => {
+  let calledQuery = '';
+  let calledOptions = null;
+
+  const mockAgent = {
+    async runResearch(claim, options = {}) {
+      calledQuery = claim;
+      calledOptions = options;
+      options.onProgress?.({ type: 'worker-start', id: 'worker-verify', label: 'Fact Verification' });
+      return {
+        id: 'verify_test_123',
+        answer: 'VERIFIED: จวีจิ้งอีเป็น Brand Ambassador ของ FRED Paris จริง',
+        sources: ['https://fred.com'],
+        reports: []
+      };
+    },
+    session: {
+      createUserMessage: () => {},
+      createAssistantMessage: () => {}
+    },
+    conversationHistory: []
+  };
+
+  const mockResolve = async () => ({
+    ready: true,
+    agent: mockAgent,
+    client: { provider: 'lmstudio' },
+    provider: 'lmstudio'
+  });
+
+  const req = Readable.from([JSON.stringify({ query: '/verify จวีจิ้งอีเป็นแบรนด์แอมบาสเดอร์ของ FRED Paris', stream: true })]);
+  req.headers = { accept: 'text/event-stream' };
+  req.socket = { remoteAddress: '127.0.0.1' };
+
+  const res = new EventEmitter();
+  res.chunks = '';
+  res.writeHead = () => {};
+  res.write = (chunk) => { res.chunks += chunk; };
+  res.end = (chunk = '') => { res.chunks += chunk; res.writableEnded = true; };
+
+  await handleChatRoute(req, res, new URL('http://localhost/api/chat'), { resolveConnection: mockResolve });
+
+  assert.equal(calledQuery, 'จวีจิ้งอีเป็นแบรนด์แอมบาสเดอร์ของ FRED Paris');
+  assert.equal(calledOptions?.mode, 'verify');
+  assert.ok(res.chunks.includes('VERIFIED'));
+});
+
+test('chatRoute returns guidance when /research or /verify is sent with empty argument', async () => {
+  const mockAgent = {
+    runResearch: async () => assert.fail('should not call runResearch when empty')
+  };
+  const mockResolve = async () => ({
+    ready: true,
+    agent: mockAgent,
+    client: { provider: 'lmstudio' },
+    provider: 'lmstudio'
+  });
+
+  const req = Readable.from([JSON.stringify({ query: '/research', stream: true })]);
+  req.headers = { accept: 'text/event-stream' };
+  req.socket = { remoteAddress: '127.0.0.1' };
+
+  const res = new EventEmitter();
+  res.chunks = '';
+  res.writeHead = () => {};
+  res.write = (chunk) => { res.chunks += chunk; };
+  res.end = (chunk = '') => { res.chunks += chunk; res.writableEnded = true; };
+
+  await handleChatRoute(req, res, new URL('http://localhost/api/chat'), { resolveConnection: mockResolve });
+
+  assert.ok(res.chunks.includes('ระบบวิจัยเชิงลึก'));
+  assert.ok(res.chunks.includes('3 Subagent Workers'));
+});