kiku-agent 1.3.1 → 1.3.3

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

@@ -0,0 +1,209 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  ContextCompactor,
+  alignChatMessageRoles,
+  estimateTextTokens,
+  estimateTokenCount,
+  prepareChatMessagesForDispatch,
+  sanitizePromptString,
+  truncatePromptString,
+} from '../contextCompactor.js';
+import { KikuAgent } from '../agentCore.js';
+
+function bareAgent() {
+  const agent = Object.create(KikuAgent.prototype);
+  agent.mcpManager = null;
+  agent.allowedToolNames = null;
+  agent.conversationHistory = [];
+  return agent;
+}
+
+test('context window split never orphans a tool result from its owning assistant message', () => {
+  const compactor = new ContextCompactor({ keepRecentMessages: 3 });
+  const history = [
+    { role: 'system', content: 'sys' },
+    { role: 'user', content: 'u1' },
+    { role: 'assistant', content: null, tool_calls: [{ id: 'c1', function: { name: 'web_search', arguments: '{}' } }] },
+    { role: 'tool', tool_call_id: 'c1', name: 'web_search', content: 'result1' },
+    { role: 'user', content: 'u2' },
+    { role: 'assistant', content: 'answer2' },
+  ];
+
+  const out = compactor.compact(history, { keepRecentMessages: 3 });
+
+  assert.equal(out[0].role, 'system');
+  const firstKept = out.find(m => m.role !== 'system');
+ 
+  assert.equal(firstKept.role, 'assistant');
+  assert.ok(Array.isArray(firstKept.tool_calls));
+  assert.ok(out.some(m => m.role === 'tool' && m.tool_call_id === 'c1'));
+});
+
+test('compaction never keeps a dangling tool result at the window boundary', () => {
+  const compactor = new ContextCompactor({ keepRecentMessages: 3 });
+  const history = [
+    { role: 'system', content: 'sys' },
+    { role: 'tool', name: 'web_search', content: 'dangling' },
+    { role: 'user', content: 'u1' },
+    { role: 'assistant', content: 'answer1' },
+    { role: 'user', content: 'u2' },
+    { role: 'assistant', content: 'answer2' },
+  ];
+
+  const out = compactor.compact(history, { keepRecentMessages: 3 });
+  const firstKept = out.find(m => m.role !== 'system');
+  assert.equal(firstKept.role, 'assistant');
+  assert.ok(!out.some(m => m.role === 'tool' && m.content === 'dangling'));
+});
+
+test('compactAsync prefers the LLM summarizer and falls back to the heuristic on failure', async () => {
+  const compactor = new ContextCompactor({ keepRecentMessages: 3 });
+  const history = [
+    { role: 'system', content: 'sys' },
+    { role: 'user', content: 'who won the 2026 election of nowhere?' },
+    { role: 'assistant', content: 'no verified data' },
+    { role: 'user', content: 'u2' },
+    { role: 'assistant', content: 'a2' },
+    { role: 'user', content: 'u3' },
+    { role: 'assistant', content: 'a3' },
+  ];
+
+  const llmOut = await compactor.compactAsync(history, {
+    keepRecentMessages: 3,
+    summarizer: async (older) => `LLM summary of ${older.length} messages`,
+  });
+  assert.equal(llmOut.filter(message => message.role === 'system').length, 1);
+  assert.match(llmOut.findLast(message => message.role === 'user').content, /LLM summary of 3 messages/);
+
+  const fallbackOut = await compactor.compactAsync(history, {
+    keepRecentMessages: 3,
+    summarizer: async () => { throw new Error('provider down'); },
+  });
+  assert.match(fallbackOut.findLast(message => message.role === 'user').content, /User asked: "who won the 2026 election of nowhere\?"/);
+});
+
+test('prompt sanitation removes orphaned surrogates and truncates only at grapheme boundaries', () => {
+  assert.equal(sanitizePromptString(`Cafe\u0301\uD800 ok\uDC00`), 'Café ok');
+  assert.equal(truncatePromptString('A👩‍💻B', 2), 'A');
+  assert.doesNotMatch(JSON.stringify({ value: truncatePromptString('😀'.repeat(20), 7) }), /\\ud[89ab][0-9a-f]{2}(?!\\ud[c-f][0-9a-f]{2})/i);
+});
+
+test('chat role alignment keeps one leading system role and moves directives into the latest user turn', () => {
+  const aligned = alignChatMessageRoles([
+    { role: 'system', content: 'immutable persona' },
+    { role: 'user', content: 'first question' },
+    { role: 'assistant', content: 'first answer' },
+    { role: 'system', content: 'reply in Thai' },
+    { role: 'user', content: 'latest question' },
+    { role: 'system', content: 'verify dates' },
+  ]);
+  assert.equal(aligned[0].role, 'system');
+  assert.equal(aligned.filter(message => message.role === 'system').length, 1);
+  assert.match(aligned.findLast(message => message.role === 'user').content, /reply in Thai[\s\S]*verify dates[\s\S]*latest question/);
+});
+
+test('dispatch budget subtracts system, generation, and tool definitions before pruning history', () => {
+  const history = [
+    { role: 'system', content: 'system '.repeat(80) },
+    ...Array.from({ length: 8 }, (_, index) => [
+      { role: 'user', content: `question ${index} ` + 'x'.repeat(300) },
+      { role: 'assistant', content: `answer ${index} ` + 'y'.repeat(300) },
+    ]).flat(),
+  ];
+  const result = prepareChatMessagesForDispatch(history, {
+    maxContextTokens: 2048,
+    generationReserve: 512,
+    tools: [{ type: 'function', function: { name: 'search', description: 'z'.repeat(500) } }],
+  });
+  assert.equal(result.budget.allocation, 2048 - result.budget.systemTokens - 512 - result.budget.toolDefinitionTokens);
+  assert.equal(result.budget.pruned, true);
+  assert.ok(estimateTokenCount(result.messages.slice(1)) <= result.budget.threshold);
+});
+
+test('_enforceContextBudget trims oldest tool results when KIKU_CONTEXT_LIMIT is exceeded', () => {
+  const agent = bareAgent();
+  agent.conversationHistory = [
+    { role: 'system', content: 'x'.repeat(50) },
+    { role: 'user', content: 'y'.repeat(50) },
+    { role: 'tool', name: 'web_search', content: JSON.stringify({ payload: 'z'.repeat(2000) }) },
+    { role: 'tool', name: 'get_awards', content: JSON.stringify({ payload: 'q'.repeat(2000) }) },
+  ];
+
+  const previousLimit = process.env.KIKU_CONTEXT_LIMIT;
+  process.env.KIKU_CONTEXT_LIMIT = '100';
+  try {
+    assert.equal(agent._enforceContextBudget(), true);
+    assert.match(agent.conversationHistory[2].content, /omitted/);
+    assert.match(agent.conversationHistory[3].content, /omitted/);
+    assert.equal(agent.conversationHistory[0].content, 'x'.repeat(50));
+    assert.equal(agent.conversationHistory[1].content, 'y'.repeat(50));
+
+  
+    assert.equal(agent._enforceContextBudget(), false);
+  } finally {
+    if (previousLimit === undefined) delete process.env.KIKU_CONTEXT_LIMIT;
+    else process.env.KIKU_CONTEXT_LIMIT = previousLimit;
+  }
+});
+
+test('_enforceContextBudget is inert without KIKU_CONTEXT_LIMIT', () => {
+  const agent = bareAgent();
+  const previousLimit = process.env.KIKU_CONTEXT_LIMIT;
+  delete process.env.KIKU_CONTEXT_LIMIT;
+  try {
+    agent.conversationHistory = [{ role: 'user', content: 'hi' }];
+    assert.equal(agent._enforceContextBudget(), false);
+    assert.equal(agent.conversationHistory[0].content, 'hi');
+  } finally {
+    if (previousLimit !== undefined) process.env.KIKU_CONTEXT_LIMIT = previousLimit;
+  }
+});
+
+test('session restore summarizes prior tool evidence instead of dropping it silently', () => {
+  const agent = bareAgent();
+  agent.session = {
+    messages: [
+      { role: 'user', parts: [{ type: 'text', content: 'เธอได้รางวัลอะไรบ้าง?' }] },
+      {
+        role: 'assistant',
+        parts: [
+          { type: 'tool', name: 'get_awards', status: 'ok', result: { count: 3 } },
+          { type: 'text', content: 'เธอได้รางวัล Forbes 30 Under 30 Asia (2019)' },
+        ],
+      },
+      { role: 'user', parts: [{ type: 'text', content: 'ขอบคุณ' }] },
+      { role: 'assistant', parts: [{ type: 'text', content: 'ด้วยความยินดีจ้ะ' }] },
+    ],
+  };
+
+  const lines = agent._rehydrateSessionMessages();
+  assert.equal(lines.length, 1);
+  assert.match(lines[0], /get_awards\(ok, 3\)/);
+  assert.match(lines[0], /Forbes 30 Under 30/);
+  assert.match(lines[0], /เธอได้รางวัลอะไรบ้าง\?/);
+
+  agent.conversationHistory = [{ role: 'system', content: 'sys' }];
+  agent._pushRestoredToolContext();
+  assert.equal(agent.conversationHistory.length, 2);
+  assert.match(agent.conversationHistory[1].content, /RESTORED SESSION TOOL CONTEXT/);
+});
+
+test('estimateTokenCount accounts for native tool_calls payloads', () => {
+  const withCalls = estimateTokenCount([
+    { role: 'assistant', content: '', tool_calls: [{ function: { name: 'x', arguments: 'a'.repeat(350) } }] },
+  ]);
+  const withoutCalls = estimateTokenCount([{ role: 'assistant', content: '' }]);
+  assert.ok(withCalls > withoutCalls);
+  assert.ok(withCalls >= 100);
+});
+
+test('Thai and CJK text is no longer under-counted by the flat chars/3.5 rule', () => {
+  const thai = 'จวีจิ้งอีแสดงเป็นหยางไฉ่เวยในเรื่อง In Blossom ปี สองพันยี่สิบสี่ ตัวละครมีความลึกล้ำและซับซ้อนมาก';
+  const asciiEquivalent = 'x'.repeat(thai.length);
+
+ 
+  assert.ok(estimateTextTokens(thai) > estimateTextTokens(asciiEquivalent) * 2);
+  assert.ok(estimateTokenCount([{ role: 'user', content: thai }]) > thai.length / 7);
+});

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

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  detectConversationDomain,
+  resolveConversationContext
+} from '../../web-chat/core/conversationContext.js';
+import { applyFutureEventGuard, findFutureDates } from '../../web-chat/core/futureEventGuard.js';
+import { executeDirectCatalogKnowledge } from '../../web-chat/core/directCatalogEngine.js';
+
+test('ambiguous Thai follow-up inherits the Vogue Gala topic instead of the artist default', () => {
+  const context = resolveConversationContext('ทำไมน่าจับตามอง?', [
+    { role: 'user', text: 'เล่าเรื่อง Vogue Gala 2026 ให้ฟังหน่อย' },
+    { role: 'bot', text: 'Vogue Gala เป็นงานแฟชั่นที่มีธีมและรายชื่อแขกรับเชิญประจำปี' }
+  ], new Date('2026-09-03T00:00:00Z'));
+
+  assert.equal(context.contextual, true);
+  assert.equal(context.domain, 'fashion_event');
+  assert.match(context.resolvedQuery, /Vogue Gala 2026/);
+  assert.match(context.resolvedQuery, /Do not switch the subject/);
+});
+
+test('domain detection gives the active fashion event priority over stray drama mentions', () => {
+  assert.equal(
+    detectConversationDomain('Vogue Gala 2026 ไม่ใช่การคุยเรื่อง Legend of Yunxi'),
+    'fashion_event'
+  );
+});
+
+test('future-event guard marks and softens unverified invitation claims', () => {
+  const now = new Date('2026-09-03T00:00:00Z');
+  const answer = 'งานจะจัดวันที่ 23 ตุลาคม 2026 และเธอได้รับเชิญเข้าร่วมงานแน่นอน';
+  assert.equal(findFutureDates(answer, now).length > 0, true);
+
+  const guarded = applyFutureEventGuard(answer, { now, tools: [] });
+  assert.match(guarded, /สถานะข้อมูลล่วงหน้า/);
+  assert.doesNotMatch(guarded, /ได้รับเชิญเข้าร่วมงานแน่นอน/);
+  assert.doesNotMatch(guarded, /23 ตุลาคม 2026/);
+  assert.match(guarded, /วันที่ในอนาคตที่ยังไม่ยืนยัน/);
+});
+
+test('direct catalog fallback preserves an inherited event topic', async () => {
+  const conversationContext = resolveConversationContext('ทำไมน่าจับตามอง?', [
+    { role: 'user', text: 'Vogue Gala 2026 มีอะไรน่าสนใจ' },
+    { role: 'bot', text: 'ประเด็นหลักคือธีมของงานแฟชั่นและกำหนดการ' }
+  ]);
+  const result = await executeDirectCatalogKnowledge('ทำไมน่าจับตามอง?', 'default', { conversationContext });
+
+  assert.match(result.answer, /อ้างอิงหัวข้อเดิม/);
+  assert.doesNotMatch(result.answer, /ข้อมูลสรุป จวีจิ้งอี/);
+  assert.doesNotMatch(result.answer, /หยุนซี|Yunxi/i);
+  assert.equal(result.tools.length, 0);
+});

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

@@ -0,0 +1,101 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { getCpuMetrics, resolveOptimalThreadBudget, clearCpuMetricsCache } from '../cpuMetrics.js';
+import { resolveParallelSlotBudget, buildLmsLoadArgs } from '../lmStudioWakeup.js';
+import { normalizeModelLoadSettings } from '../config.js';
+
+test('getCpuMetrics detects CPU topology and returns structured hardware metrics', async () => {
+  clearCpuMetricsCache();
+  const metrics = await getCpuMetrics();
+  assert.ok(metrics, 'Metrics object must be defined');
+  assert.ok(typeof metrics.model === 'string' && metrics.model.length > 0, 'CPU model must be non-empty string');
+  assert.ok(Number.isFinite(metrics.physicalCores) && metrics.physicalCores >= 1, 'Physical cores must be >= 1');
+  assert.ok(Number.isFinite(metrics.logicalCores) && metrics.logicalCores >= metrics.physicalCores, 'Logical cores must be >= physical cores');
+  assert.equal(typeof metrics.hyperThreading, 'boolean');
+  assert.ok(Number.isFinite(metrics.smtMultiplier) && metrics.smtMultiplier >= 1);
+  assert.ok(typeof metrics.statusText === 'string');
+  assert.ok(metrics.recommendedComputeThreads >= 1);
+});
+
+test('resolveOptimalThreadBudget calculates thread counts for physical, smt, auto, and custom modes', () => {
+  const mockCpu = {
+    physicalCores: 6,
+    logicalCores: 12,
+    hyperThreading: true,
+  };
+
+  const phys = resolveOptimalThreadBudget({ mode: 'physical', cpuInfo: mockCpu });
+  assert.equal(phys.threads, 6);
+  assert.equal(phys.mode, 'physical');
+  assert.match(phys.explanation, /physical cores/i);
+
+  const smt = resolveOptimalThreadBudget({ mode: 'smt', cpuInfo: mockCpu });
+  assert.equal(smt.threads, 12);
+  assert.equal(smt.mode, 'smt');
+  assert.match(smt.explanation, /logical threads/i);
+
+  const autoDefault = resolveOptimalThreadBudget({ mode: 'auto', cpuInfo: mockCpu });
+  assert.equal(autoDefault.threads, 6);
+  assert.equal(autoDefault.mode, 'auto');
+
+  const autoWithReq = resolveOptimalThreadBudget({ mode: 'auto', requested: 8, cpuInfo: mockCpu });
+  assert.equal(autoWithReq.threads, 8);
+  assert.equal(autoWithReq.mode, 'custom');
+
+  const custom = resolveOptimalThreadBudget({ mode: 'custom', requested: 4, cpuInfo: mockCpu });
+  assert.equal(custom.threads, 4);
+  assert.equal(custom.mode, 'custom');
+});
+
+test('resolveParallelSlotBudget enforces physical core ceiling when htMode is physical', () => {
+  const budgetPhysical = resolveParallelSlotBudget(12, 12, { htMode: 'physical', physicalCores: 6 });
+  assert.equal(budgetPhysical.value, 6);
+  assert.equal(budgetPhysical.ceiling, 6);
+  assert.equal(budgetPhysical.capped, true);
+
+  const budgetSmt = resolveParallelSlotBudget(12, 12, { htMode: 'smt', physicalCores: 6 });
+  assert.equal(budgetSmt.value, 12);
+  assert.equal(budgetSmt.ceiling, 12);
+  assert.equal(budgetSmt.capped, false);
+
+  const budgetAuto = resolveParallelSlotBudget(8, 12, { htMode: 'auto', physicalCores: 6 });
+  assert.equal(budgetAuto.value, 8);
+  assert.equal(budgetAuto.ceiling, 12);
+});
+
+test('buildLmsLoadArgs applies HT-aware parallel allocation flags', () => {
+  const argsPhys = buildLmsLoadArgs('test-model', {
+    cpuThreads: 12,
+    availableCpus: 12,
+    physicalCores: 6,
+    htMode: 'physical'
+  });
+  assert.ok(argsPhys.includes('--parallel'));
+  assert.equal(argsPhys[argsPhys.indexOf('--parallel') + 1], '6');
+
+  const argsSmt = buildLmsLoadArgs('test-model', {
+    cpuThreads: 12,
+    availableCpus: 12,
+    physicalCores: 6,
+    htMode: 'smt'
+  });
+  assert.ok(argsSmt.includes('--parallel'));
+  assert.equal(argsSmt[argsSmt.indexOf('--parallel') + 1], '12');
+});
+
+test('normalizeModelLoadSettings persists and validates htMode', () => {
+  const def = normalizeModelLoadSettings({});
+  assert.equal(def.htMode, 'auto');
+
+  const phys = normalizeModelLoadSettings({ htMode: 'physical' });
+  assert.equal(phys.htMode, 'physical');
+
+  const smt = normalizeModelLoadSettings({ htMode: 'smt' });
+  assert.equal(smt.htMode, 'smt');
+
+  const allAlias = normalizeModelLoadSettings({ htMode: 'all' });
+  assert.equal(allAlias.htMode, 'smt');
+
+  const invalid = normalizeModelLoadSettings({ htMode: 'invalid_mode' });
+  assert.equal(invalid.htMode, 'auto');
+});

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

@@ -0,0 +1,167 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { executeTool } from '../tools.js';
+import { compactToolResultForContext } from '../contextCompactor.js';
+import { scoreCoverage } from '../eval/modules/evaluation/scoring.js';
+import { dynamicToolRouter } from '../toolRouter.js';
+import { buildCatalogIndex, CATEGORY_ALIASES, resolveQueryEntities } from '../catalogEntityResolver.js';
+
+test('get_brand_endorsements resolves French high jewelry and commercial aliases', async () => {
+  const fredRes = await executeTool('get_brand_endorsements', { query: 'French high jewelry' }, { noCache: true });
+  assert.equal(fredRes.status, 'success');
+  assert.ok(fredRes.count > 0);
+  assert.ok(fredRes.brands.some(b => b.brand.toLowerCase().includes('fred')));
+
+  const tutuRes = await executeTool('get_brand_endorsements', { query: 'TuTuCare' }, { noCache: true });
+  assert.equal(tutuRes.status, 'success');
+  assert.ok(tutuRes.count > 0);
+  assert.ok(tutuRes.brands.some(b => b.brand.toLowerCase().includes('tutu') || b.brand.includes('凸凸棉')));
+
+  const lafangRes = await executeTool('get_brand_endorsements', { query: 'Lafang' }, { noCache: true });
+  assert.equal(lafangRes.status, 'success');
+  assert.ok(lafangRes.count > 0);
+  assert.ok(lafangRes.brands.some(b => b.brand.toLowerCase().includes('lafang') || b.brand.includes('拉芳')));
+});
+
+test('search_discography and get_music_videos resolve 0.2s and Dewdrops without numeric confusion', async () => {
+  const zeroTwoRes = await executeTool('search_discography', { query: '0.2s' }, { noCache: true });
+  assert.equal(zeroTwoRes.status, 'success');
+  assert.ok(zeroTwoRes.count > 0);
+  assert.ok(zeroTwoRes.songs.some(s => s.titleEn === '0.2s' || s.titleCn === '0.2s' || s.title?.includes('0.2s')));
+
+  const dewdropsRes = await executeTool('search_discography', { query: 'Dewdrops' }, { noCache: true });
+  assert.equal(dewdropsRes.status, 'success');
+  assert.ok(dewdropsRes.count > 0);
+  assert.ok(dewdropsRes.songs.some(s => s.id?.includes('dewdrop') || s.titleEn?.toLowerCase().includes('dew') || s.title?.includes('露珠')));
+
+  const dewdropsMv = await executeTool('get_music_videos', { query: 'Dewdrops' }, { noCache: true });
+  assert.equal(dewdropsMv.status, 'success');
+  assert.ok(dewdropsMv.count > 0);
+  assert.ok(dewdropsMv.videos.some(v => v.youtubeId === 'D-vEPdasbLo' || v.titleCn?.includes('露珠')));
+});
+
+test('compactToolResultForContext projects essential keys and eliminates decorative URLs', () => {
+  const brandResult = {
+    status: 'success',
+    count: 1,
+    brands: [
+      {
+        brand: 'FRED Paris (斐登珠宝)',
+        brandNameEn: 'FRED Paris',
+        brandNameCn: '斐登珠宝',
+        year: 2025,
+        title: 'China Brand Ambassador',
+        category: 'French High Jewelry',
+        isGlobal: false,
+        highlight: 'Force 10 High Jewelry editorial for PORT Magazine',
+        tier: 'LVMH High Jewelry',
+        youtubeCommercialSearch: 'https://youtube.com/results?search_query=FRED',
+        bilibiliSearchUrl: 'https://search.bilibili.com/all?keyword=FRED'
+      }
+    ]
+  };
+
+  const compacted = compactToolResultForContext(brandResult, { maxTokens: 800 });
+  assert.equal(compacted.brands.length, 1);
+  const b = compacted.brands[0];
+  assert.equal(b.brandNameEn, 'FRED Paris');
+  assert.equal(b.year, 2025);
+  assert.equal(b.youtubeCommercialSearch, undefined);
+  assert.equal(b.bilibiliSearchUrl, undefined);
+});
+
+test('compactToolResultForContext preserves image evidence links and relevance scores', () => {
+  const longImageUrl = `https://example.com/images/${'a'.repeat(300)}.jpg`;
+  const imageResult = {
+    status: 'success',
+    query: '鞠婧祎 万花世界 路透',
+    normalizedQuery: '鞠婧祎 万花世界 电视剧 路透',
+    count: 1,
+    results: [
+      {
+        title: '鞠婧祎 万花世界 路透照',
+        snippet: 'on-set stills from 万花世界 filming',
+        url: 'https://example.com/article',
+        source: 'Baidu Images',
+        imageUrl: longImageUrl,
+        thumbUrl: longImageUrl,
+        sourcePageUrl: longImageUrl,
+        width: 1080,
+        height: 1440,
+        relevanceScore: 42.5,
+      }
+    ]
+  };
+
+  const compacted = compactToolResultForContext(imageResult, { maxTokens: 60 });
+  assert.equal(compacted.results.length, 1);
+  const item = compacted.results[0];
+  assert.equal(item.imageUrl, longImageUrl);
+  assert.equal(item.thumbUrl, longImageUrl);
+  assert.equal(item.sourcePageUrl, longImageUrl);
+  assert.equal(item.relevanceScore, 42.5);
+});
+
+test('scoreCoverage normalizes Buddhist Era years and minute-second durations', () => {
+  const caseBe = {
+    groups: [
+      ['2017', 'ค.ศ. 2017']
+    ]
+  };
+  const answerBe = 'จวีจิ้งอีจัดงานคอนเสิร์ตเดี่ยวครั้งสำคัญใน พ.ศ. 2560 อย่างยิ่งใหญ่';
+  const scoreBeResult = scoreCoverage(caseBe, answerBe);
+  assert.equal(scoreBeResult.allMatched, true, 'พ.ศ. 2560 should cover 2017');
+
+  const caseDuration = {
+    groups: [
+      ['5:01', '05:01']
+    ]
+  };
+  const answerDuration = 'เพลง Still Searching (仍寻) มีความยาว 5 minutes and 1 second พอดี';
+  const scoreDurationResult = scoreCoverage(caseDuration, answerDuration);
+  assert.equal(scoreDurationResult.allMatched, true, '5 minutes and 1 second should cover 5:01');
+});
+
+test('tool router routes timeline era queries to get_career_timeline', () => {
+  const tools = dynamicToolRouter.routeToolsForQuery('Ju Jingyi career journey and variety show milestones in 2015-2016');
+  const toolNames = tools.map(t => t.function?.name || t.name);
+  assert.ok(toolNames.includes('get_career_timeline'), 'should route to get_career_timeline');
+});
+
+test('refusal regex intercepts premature commercial secret and mindset refusals', () => {
+  const refusalRegex = /(ไม่มี(การ)?บันทึก|ไม่มี(อยู่ใน)?ระบบ|ไม่มีข้อมูล|ไม่มีรายละเอียด|ไม่พบ|ข้อมูลทางธุรกิจ|ข้อมูลธุรกิจ|ข้อมูลเชิงพาณิชย์|ความลับทางการค้า|ความลับ|ความลับเชิงพาณิชย์|ปรัชญาการทำงาน|ตัวตนของฉัน|นอกเหนือขอบเขต|ไม่สามารถระบุ|ไม่ได้ระบุ|not found|no verified record|no record|could not find|unable to find|outside the scope|confidential|internal business|trade secret|business secret|commercial secret|proprietary|internal statistics?|operational philosophy|my own mindset|without querying|没有找到|未找到|暂无|没有记录|无法查询|商业机密|内部数据|机密)/i;
+
+  assert.ok(refusalRegex.test('ข้อมูลยอดขายของ TuTuCare เป็นความลับเชิงพาณิชย์'));
+  assert.ok(refusalRegex.test('This is confidential commercial secret information.'));
+  assert.ok(refusalRegex.test('This is internal business statistics not publicly shared.'));
+  assert.ok(refusalRegex.test('I do not have access to internal trade secrets.'));
+  assert.ok(refusalRegex.test('นี่เป็นปรัชญาการทำงานและตัวตนของฉันเอง'));
+  assert.ok(refusalRegex.test('This is outside the scope of public records.'));
+});
+
+test('resolveQueryEntities detects timeline and brand intents with recommendedTools', () => {
+  const timelineQuery = resolveQueryEntities('ในปี 2018 ละครเรื่องอะไรที่จวีจิ้งอีแสดงร่วมกับ ไมค์ พิรัชต์');
+  assert.equal(timelineQuery.isTimelineIntent, true);
+  assert.ok(timelineQuery.recommendedTools.includes('get_career_timeline'));
+
+  const brandQuery = resolveQueryEntities('ยอดขายกล่องของขวัญ TuTuCare ของจวีจิ้งอีเป็นอย่างไร');
+  assert.equal(brandQuery.isBrandIntent, true);
+  assert.ok(brandQuery.recommendedTools.includes('get_brand_endorsements'));
+});
+
+test('compactToolResultForContext preserves salesHighlights in brands data', () => {
+  const brandPayload = {
+    brands: [
+      { id: 'tutucare', brand: 'TuTuCare', brandNameEn: 'TuTuCare', year: 2026, title: 'Global Ambassador' }
+    ],
+    salesHighlights: [
+      { brand: 'TuTuCare (凸凸棉)', brandId: 'tutucare', stat: '20,000 ชุด หมดใน 1 วินาที!', revenue: 'GMV เกิน 10.3 ล้านหยวนใน 1 ชั่วโมง', detail: 'กล่องของขวัญลิมิเต็ด' }
+    ]
+  };
+
+  const compacted = compactToolResultForContext(brandPayload);
+  assert.ok(compacted.salesHighlights, 'salesHighlights should be preserved');
+  assert.equal(compacted.salesHighlights.length, 1);
+  assert.equal(compacted.salesHighlights[0].stat, '20,000 ชุด หมดใน 1 วินาที!');
+});

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

@@ -0,0 +1,73 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { executeTool } from '../tools.js';
+import { resolveConversationContext } from '../../web-chat/core/conversationContext.js';
+import { executeDirectCatalogKnowledge } from '../../web-chat/core/directCatalogEngine.js';
+import { assessDramaAnswerQuality } from '../../web-chat/core/dramaKnowledge.js';
+
+test('2024-versus-past analysis compares concrete role demands without unsupported rankings', async () => {
+  const query = 'ดำเนินการต่อ: อยากให้วิเคราะห์เปรียบเทียบบทบาทของเธอในซีรีส์ยุคใหม่ (2024) กับผลงานไอดอลในอดีต ว่ามีจุดเปลี่ยนด้านการแสดงอย่างไรบ้างคะ?';
+  const result = await executeDirectCatalogKnowledge(query);
+
+  assert.match(result.answer, /วิวัฒนาการต่อเนื่อง/);
+  assert.match(result.answer, /ตัวตนหยางไฉ่เวย.*รูปลักษณ์.*ซ่างกวนจื่อ/s);
+  assert.match(result.answer, /Sword and Fairy 4/);
+  assert.match(result.answer, /Novoland: The Castle in the Sky/);
+  assert.doesNotMatch(result.answer, /★\s*9\.|ระดับแนวหน้า|ไม่มีใครเทียบได้/);
+  assert.doesNotMatch(result.answer, /ประวัติและข้อมูลส่วนตัว/);
+  assert.ok(result.tools.every(tool => tool.name === 'get_work_detail'));
+});
+
+test('White Snake story keeps Bai Suzhen and Xu Xian species and genders correct', async () => {
+  const result = await executeDirectCatalogKnowledge('เล่าเรื่องราวและเกร็ดของ ตำนานนางพญางูขาว (The Legend of White Snake) ให้ฟังหน่อย');
+
+  assert.match(result.answer, /ไป๋ซู่เจินเป็นวิญญาณ\/ปีศาจงูขาว/);
+  assert.match(result.answer, /สวี่เซียนเป็นมนุษย์ชาย/);
+  assert.match(result.answer, /iQIYI \/ WeTV/);
+  assert.doesNotMatch(result.answer, /มนุษย์สาวผู้มีความงดงาม.*พญางูขาว/s);
+  assert.doesNotMatch(result.answer, /ไม่มีใครเทียบได้|ระดับแนวหน้า/);
+  assert.equal(result.tools[0]?.name, 'get_work_detail');
+});
+
+test('explicit long continuation keeps the previous topic and forbids repetition', () => {
+  const query = 'ดำเนินการต่อ: อยากให้วิเคราะห์เปรียบเทียบบทบาทของเธอในซีรีส์ยุคใหม่ปี 2024 กับผลงานไอดอลในอดีต โดยเน้นเฉพาะสิ่งที่ต่างจากคำตอบก่อนหน้า';
+  const context = resolveConversationContext(query, [
+    { role: 'user', text: 'ช่วยวิเคราะห์ซีรีส์ปี 2024 กับอดีตของจวีจิ้งอี' },
+    { role: 'assistant', text: 'คำตอบก่อนหน้ากล่าวถึง In Blossom และ The Legend of White Snake' }
+  ]);
+
+  assert.equal(context.contextual, true);
+  assert.match(context.resolvedQuery, /do not copy or restate/i);
+});
+
+test('search_works exposes synopsis and highlights needed for grounded synthesis', async () => {
+  const result = await executeTool('search_works', { query: 'The Legend of White Snake' });
+  const work = result.works[0];
+
+  assert.match(work.synopsis, /ปีศาจงูขาว/);
+  assert.ok(Array.isArray(work.highlights));
+  assert.ok(work.highlights.length > 0);
+});
+
+test('quality assessment rejects the observed hallucinated White Snake answer', () => {
+  const answer = 'ตัวละครเอกเป็นมนุษย์สาวผู้มีความงดงาม และเธอได้พบกับสิ่งมีชีวิตลึกลับ ซึ่งในตำนานคือพญางูขาว';
+  const assessment = assessDramaAnswerQuality('เล่าเรื่องราวและเกร็ดของ The Legend of White Snake', answer);
+
+  assert.equal(assessment.applicable, true);
+  assert.equal(assessment.valid, false);
+  assert.ok(assessment.issues.includes('reversed-species-or-gender'));
+});
+
+test('quality assessment rejects repeated generic comparison and false dual-role framing', () => {
+  const answer = 'In Blossom แสดงพัฒนาการสลับเล่น 2 คาแรคเตอร์ได้อย่างน่าทึ่ง ส่วน Sword and Fairy 4 เป็นงานปี 2024 ★ 9.5 / 10';
+  const assessment = assessDramaAnswerQuality(
+    'ดำเนินการต่อ: เปรียบเทียบซีรีส์ปี 2024 กับผลงานไอดอลในอดีต',
+    answer
+  );
+
+  assert.equal(assessment.valid, false);
+  assert.ok(assessment.issues.includes('false-dual-role-framing'));
+  assert.ok(assessment.issues.includes('unattributed-rating'));
+  assert.ok(assessment.issues.includes('missing-past-work-evidence'));
+});