kiku-agent 1.3.0 → 1.3.2

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

@@ -0,0 +1,417 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { COMMAND_NAMES } from '../commandRegistry.js';
+import { handlers, routeCommand } from '../commands.js';
+import { getThemeName } from '../theme.js';
+
+const HIDDEN_LEGACY_HANDLERS = ['/autoresearch', '/endpoint', '/ping', '/sources', '/url', '/version'].sort();
+
+test('every canonical slash command has exactly one handler', () => {
+  assert.equal(new Set(COMMAND_NAMES).size, COMMAND_NAMES.length);
+  for (const name of COMMAND_NAMES) {
+    assert.equal(typeof handlers[name], 'function', `${name} must have a handler`);
+  }
+  const hidden = Object.keys(handlers).filter(name => !COMMAND_NAMES.includes(name)).sort();
+  assert.deepEqual(hidden, HIDDEN_LEGACY_HANDLERS, 'hidden legacy handlers must stay minimal');
+});
+
+test('/ads receives the router context and displays one sponsor card', async () => {
+  let calls = 0;
+  const result = await routeCommand('/ads', {
+    printAd() { calls += 1; },
+  });
+
+  assert.equal(result, 'HANDLED');
+  assert.equal(calls, 1);
+});
+
+test('/gallery displays an image through the managed TUI callback and aliases work', async () => {
+  let calls = 0;
+  const ctx = {
+    showTerminalImage() { calls += 1; return true; },
+  };
+
+  assert.equal(await routeCommand('/gallery', ctx), 'HANDLED');
+  assert.equal(await routeCommand('/image', ctx), 'HANDLED');
+  assert.equal(await routeCommand('/photo', ctx), 'HANDLED');
+  assert.equal(calls, 3);
+});
+
+test('/quiz retries the current question after a wrong managed-TUI answer', async () => {
+  const originalFetch = global.fetch;
+  const originalRandom = Math.random;
+  const originalLog = console.log;
+  const prompts = [];
+  const output = [];
+  const preferences = {};
+  let claimBody = null;
+
+  global.fetch = async (_url, options = {}) => {
+    if (!options.method) {
+      return {
+        ok: true,
+        json: async () => ({ data: { challengeToken: 'kiku_chal_test' } }),
+      };
+    }
+    claimBody = JSON.parse(options.body);
+    return {
+      json: async () => ({ status: 'success', data: { apiKey: 'kiku_vip_sk_server_test' } }),
+    };
+  };
+  Math.random = () => 0;
+  console.log = (...args) => output.push(args.join(' '));
+
+  try {
+    const result = await routeCommand('/quiz lang en', {
+      sub: 'lang',
+      extra: 'en',
+      readInput: async options => {
+        prompts.push(options);
+        return prompts.length === 1 ? 'a' : 'd';
+      },
+      agent: {
+        memory: {
+          preferences,
+          setPreference(key, value) { preferences[key] = value; },
+        },
+      },
+    });
+
+    assert.equal(result, 'HANDLED');
+    assert.equal(prompts.length, 16);
+    assert.ok(prompts.every(prompt => prompt.prompt === 'Answer ❯ '));
+    assert.ok(prompts.every(prompt => prompt.history === false && prompt.cancelValue === 'q'));
+    assert.match(output.join('\n'), /Incorrect, try again!/);
+    assert.match(output.join('\n'), /Perfect Score!/);
+    assert.equal(preferences.vipKey, 'kiku_vip_sk_server_test');
+    assert.equal(claimBody.challengeToken, 'kiku_chal_test');
+    assert.equal(claimBody.answers.length, 15);
+    assert.ok(claimBody.answers.every(answer => answer.answerIndex === 0));
+  } finally {
+    global.fetch = originalFetch;
+    Math.random = originalRandom;
+    console.log = originalLog;
+  }
+});
+
+test('/quiz can be cancelled through the managed TUI input row', async () => {
+  const originalFetch = global.fetch;
+  const originalLog = console.log;
+  const output = [];
+
+  global.fetch = async () => ({ ok: false });
+  console.log = (...args) => output.push(args.join(' '));
+
+  try {
+    const result = await routeCommand('/quiz lang en', {
+      sub: 'lang',
+      extra: 'en',
+      readInput: async () => 'q',
+      agent: { memory: { preferences: {} } },
+    });
+
+    assert.equal(result, 'HANDLED');
+    assert.match(output.join('\n'), /Quiz cancelled/);
+  } finally {
+    global.fetch = originalFetch;
+    console.log = originalLog;
+  }
+});
+
+test('/skill list and learn commands update user skills', async () => {
+  const skills = [];
+  const preferences = { userSkills: skills, skillsEnabled: true };
+  const mockMemory = {
+    preferences,
+    addUserSkill(instruction) {
+      const skill = { id: 's_test', instruction, createdAt: Date.now() };
+      skills.push(skill);
+      return skill;
+    },
+    removeUserSkill(id) {
+      const idx = skills.findIndex(s => s.id === id);
+      if (idx !== -1) { skills.splice(idx, 1); return true; }
+      return false;
+    },
+    clearUserSkills() { skills.length = 0; },
+    setPreference(key, val) { preferences[key] = val; }
+  };
+
+  const agent = { memory: mockMemory };
+  assert.equal(await routeCommand('/skill list', { agent }), 'HANDLED');
+  assert.equal(await routeCommand('/skill learn always be kind', { agent, sub: 'learn', extra: 'always be kind' }), 'HANDLED');
+  assert.equal(skills.length, 1);
+  assert.equal(await routeCommand('/skill off', { agent, sub: 'off' }), 'HANDLED');
+  assert.equal(preferences.skillsEnabled, false);
+});
+
+test('/subagent status returns gracefully when no previous run', async () => {
+  const agent = {};
+  assert.equal(await routeCommand('/subagent status', { agent, sub: 'status' }), 'HANDLED');
+});
+
+test('/research status and sources return gracefully', async () => {
+  const agent = {
+    getResearchStatus() { return { state: 'idle', question: '', workers: [], lastResult: null }; }
+  };
+  assert.equal(await routeCommand('/research status', { agent, sub: 'status' }), 'HANDLED');
+  assert.equal(await routeCommand('/research sources', { agent, sub: 'sources' }), 'HANDLED');
+});
+
+test('/clear resets TUI viewport without appending duplicate banners', async () => {
+  let ended = false;
+  const agent = { endSession: async () => { ended = true; } };
+  const mockTuiPrompt = {
+    viewportLines: ['line1', 'line2'],
+    scrollOffset: 5,
+    rendered: false,
+    addViewportLines(line) { this.viewportLines.push(line); },
+    render() { this.rendered = true; }
+  };
+
+  const res = await routeCommand('/clear', { agent, tuiPrompt: mockTuiPrompt });
+  assert.equal(res, 'HANDLED');
+  assert.equal(ended, true);
+  assert.equal(mockTuiPrompt.scrollOffset, 0);
+  assert.equal(mockTuiPrompt.rendered, true);
+  assert.ok(mockTuiPrompt.viewportLines.some(l => l.includes('Fresh start')));
+});
+
+test('/gpu and /system return handled status and display hardware information', async () => {
+  assert.equal(await routeCommand('/gpu', {}), 'HANDLED');
+  assert.equal(await routeCommand('/vram', {}), 'HANDLED');
+  assert.equal(await routeCommand('/system', {}), 'HANDLED');
+});
+
+test('/mcp status includes every connected tool command in one panel output', async () => {
+  const tools = Array.from({ length: 18 }, (_, index) => ({
+    function: {
+      name: `mcp_kiku_tool_${index + 1}`,
+      description: `Tool ${index + 1}`,
+      parameters: { type: 'object', properties: {} },
+    },
+  }));
+  const agent = {
+    mcpManager: {
+      getStatus() {
+        return {
+          activeServersCount: 1,
+          totalToolsCount: tools.length,
+          servers: [{ name: 'kiku', type: 'streamable-http', toolsCount: tools.length, resourcesCount: 5 }],
+        };
+      },
+      getToolsSchema() { return tools; },
+    },
+  };
+  const originalLog = console.log;
+  const output = [];
+  console.log = (...args) => output.push(args.join(' '));
+  try {
+    assert.equal(await routeCommand('/mcp', { agent }), 'HANDLED');
+  } finally {
+    console.log = originalLog;
+  }
+  const rendered = output.join('\n');
+  for (const tool of tools) assert.match(rendered, new RegExp(`@${tool.function.name}`));
+  assert.equal(output.length, 1, 'the panel should be emitted as one TUI batch');
+});
+
+test('/update is no longer registered or routed', async () => {
+  const originalLog = console.log;
+  console.log = () => {};
+  try {
+    assert.equal(COMMAND_NAMES.includes('/update'), false);
+    assert.equal(await routeCommand('/update check', {}), 'UNKNOWN');
+  } finally {
+    console.log = originalLog;
+  }
+});
+
+test('audioPlayer tracks playback offset and resumes from saved position', async () => {
+  const { audioPlayer } = await import('../audioPlayer.js');
+  const originalCreateStream = audioPlayer._createStream;
+  audioPlayer._createStream = async () => {};
+  try {
+    audioPlayer.isPlaying = true;
+    audioPlayer.isPaused = false;
+    audioPlayer.currentTrack = 'Test Track';
+    audioPlayer._playbackStartedAt = Date.now() - 35000;
+    audioPlayer._currentOffsetSeconds = 10;
+
+    const pauseMsg = audioPlayer.pause();
+    assert.ok(pauseMsg.includes('Paused: Test Track'));
+    assert.ok(pauseMsg.includes('0:45'));
+    assert.equal(audioPlayer.isPaused, true);
+    assert.equal(audioPlayer._playbackStartedAt, 0);
+    assert.ok(audioPlayer._currentOffsetSeconds >= 44 && audioPlayer._currentOffsetSeconds <= 46);
+
+    const resumeMsg = audioPlayer.resume();
+    assert.ok(resumeMsg.includes('Resumed: Test Track'));
+    assert.ok(resumeMsg.includes('from 0:45'));
+    assert.equal(audioPlayer.isPaused, false);
+    assert.ok(audioPlayer._playbackStartedAt > 0);
+
+    audioPlayer.stop();
+    assert.equal(audioPlayer._currentOffsetSeconds, 0);
+    assert.equal(audioPlayer._playbackStartedAt, 0);
+  } finally {
+    audioPlayer._createStream = originalCreateStream;
+    audioPlayer.stop();
+  }
+});
+
+test('getCommandDetails returns structured metadata, subcommands, and examples', async () => {
+  const { getCommandDetails } = await import('../commandRegistry.js');
+
+  const suggestionDetails = getCommandDetails('/suggestion');
+  assert.ok(suggestionDetails, 'Should have details for /suggestion');
+  assert.ok(suggestionDetails.subcommands.length >= 4);
+  assert.ok(suggestionDetails.subcommands.some(s => s.cmd === 'list'));
+  assert.ok(suggestionDetails.subcommands.some(s => s.cmd.startsWith('run')));
+  assert.ok(suggestionDetails.subcommands.some(s => s.cmd.startsWith('topic')));
+  assert.ok(suggestionDetails.examples.length >= 3);
+
+  const mcpDetails = getCommandDetails('mcp');
+  assert.ok(mcpDetails, 'Should normalize command without leading slash');
+  assert.ok(mcpDetails.subcommands.some(s => s.cmd.startsWith('connect')));
+  assert.ok(mcpDetails.subcommands.some(s => s.cmd.startsWith('save')));
+  assert.ok(mcpDetails.subcommands.some(s => s.cmd.startsWith('remove')));
+
+  const providerDetails = getCommandDetails('/provider');
+  assert.ok(providerDetails);
+  assert.ok(providerDetails.subcommands.some(s => s.cmd.startsWith('use')));
+});
+
+test('/<cmd> help and /help <cmd> route to help handler with subcommands', async () => {
+  let printedCmd = null;
+  const ctx = {
+    printHelp(cmd) { printedCmd = cmd; },
+  };
+
+  assert.equal(await routeCommand('/help suggestion', ctx), 'HANDLED');
+  assert.equal(printedCmd, 'suggestion');
+
+  assert.equal(await routeCommand('/suggestion help', ctx), 'HANDLED');
+  assert.equal(printedCmd, '/suggestion');
+});
+
+test('/cancel command aborts running query and returns handled', async () => {
+  let cancelled = false;
+  const ctx = {
+    cancelActiveQuery: () => {
+      cancelled = true;
+      return true;
+    },
+  };
+
+  assert.equal(await routeCommand('/cancel', ctx), 'HANDLED');
+  assert.equal(cancelled, true);
+
+  assert.equal(await routeCommand('/abort', ctx), 'HANDLED');
+  assert.equal(cancelled, true);
+});
+
+test('/copy command routes to copyQueryDetails context method and aliases work', async () => {
+  let copiedRef = null;
+  const ctx = {
+    copyQueryDetails: (ref) => {
+      copiedRef = ref;
+      return true;
+    },
+  };
+
+  assert.equal(await routeCommand('/copy', ctx), 'HANDLED');
+  assert.equal(copiedRef, '');
+
+  assert.equal(await routeCommand('/copy thinking', ctx), 'HANDLED');
+  assert.equal(copiedRef, 'thinking');
+
+  assert.equal(await routeCommand('/cp Q2 answer', ctx), 'HANDLED');
+  assert.equal(copiedRef, 'Q2 answer');
+
+  assert.equal(await routeCommand('/clipboard tool 1', ctx), 'HANDLED');
+  assert.equal(copiedRef, 'tool 1');
+});
+
+test('/stats renders an AI insight when a chat client is available', async () => {
+  const originalLog = console.log;
+  const output = [];
+  console.log = (...args) => output.push(args.join(' '));
+  const ctx = {
+    agent: {
+      memory: { preferences: { language: null } },
+      client: { chat: async () => ({ content: 'Dramas dominate the catalog.' }) },
+    },
+  };
+  try {
+    assert.equal(await routeCommand('/stats', ctx), 'HANDLED');
+  } finally {
+    console.log = originalLog;
+  }
+  const text = output.join('\n');
+  assert.match(text, /Database Overview/);
+  assert.match(text, /Dramas dominate the catalog/);
+});
+
+test('/stats falls back gracefully when no chat client is available', async () => {
+  const originalLog = console.log;
+  const output = [];
+  console.log = (...args) => output.push(args.join(' '));
+  try {
+    assert.equal(await routeCommand('/stats', {}), 'HANDLED');
+  } finally {
+    console.log = originalLog;
+  }
+  const text = output.join('\n');
+  assert.match(text, /Database Overview/);
+  assert.doesNotMatch(text, /STATS ERROR/);
+});
+
+test('/theme next cycles to next theme and renders tuiPrompt if available', async () => {
+  let rendered = false;
+  const mockTuiPrompt = { render() { rendered = true; } };
+  const current = getThemeName();
+  assert.equal(await routeCommand('/theme next', { tuiPrompt: mockTuiPrompt }), 'HANDLED');
+  assert.equal(rendered, true);
+  assert.notEqual(getThemeName(), current);
+
+
+  assert.equal(await routeCommand('/theme prev', { tuiPrompt: mockTuiPrompt }), 'HANDLED');
+  assert.equal(getThemeName(), current);
+});
+
+test('all hotkey target commands are routeable and handled', async () => {
+  const dummyCtx = {
+    agent: {
+      session: {
+        setThinkingMode() {},
+        toggleThinkingMode() { return 'show'; },
+        exportToMarkdown: async () => ({ filePath: 'export.md' }),
+      },
+      getAllToolsSchema: () => [],
+    },
+    client: {},
+    printHelp: () => {},
+    printQueryDetails: () => {},
+    copyQueryDetails: () => ({ error: null }),
+    showTerminalImage: () => true,
+    lastQuery: 'test query',
+  };
+
+
+  assert.equal(await routeCommand('/help', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/details', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/details thinking', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/details tools', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/copy', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/gallery', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/theme next', { ...dummyCtx, tuiPrompt: { render() {} } }), 'HANDLED');
+  assert.equal(await routeCommand('/stats', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/provider', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/mcp list', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/thinking toggle', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/retry', dummyCtx), 'RETRY');
+  assert.equal(await routeCommand('/save', dummyCtx), 'HANDLED');
+});
+

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

@@ -0,0 +1,162 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { ContextCompactor, estimateTextTokens, estimateTokenCount } 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.match(llmOut[1].content, /LLM summary of 3 messages/);
+
+  const fallbackOut = await compactor.compactAsync(history, {
+    keepRecentMessages: 3,
+    summarizer: async () => { throw new Error('provider down'); },
+  });
+  assert.match(fallbackOut[1].content, /User asked: "who won the 2026 election of nowhere\?"/);
+});
+
+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);
+});