kiku-agent 1.3.1 → 1.3.3

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

@@ -0,0 +1,141 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { COMMAND_NAMES } from '../commandRegistry.js';
+import { routeCommand } from '../commands.js';
+import { AgentJobManager } from '../jobManager.js';
+import { AgentMemory } from '../memory.js';
+import { getStringDisplayWidth, getWelcomeHeroLines, stripAnsi } from '../ui.js';
+
+const RECENT_DATE = new Date(Date.now() - 3 * 86_400_000).toISOString().slice(0, 10);
+
+function executor(name, args = {}) {
+  const query = String(args.query || '').toLowerCase();
+  if (name === 'search_works') {
+    const works = [
+      { id: 'in-blossom', titleTh: 'บุปผารักอลวน', titleEn: 'In Blossom', year: args.year || 2024, role: 'Yang Caiwei', platform: 'Youku', episodes: 32 },
+      { id: 'beauty-of-resilience', titleTh: 'ตำนานเลือดฟีนิกซ์', titleEn: 'Beauty of Resilience', year: args.year || 2023, role: 'Wei Zhi', platform: 'iQIYI', episodes: 36 },
+    ].filter(item => !query || `${item.titleTh} ${item.titleEn}`.toLowerCase().includes(query));
+    return Promise.resolve({ works, count: works.length });
+  }
+  if (name === 'search_discography') return Promise.resolve({ songs: [{ id: 'rain-love', title: 'Rain Love (雨恋)', year: args.year || 2024, type: 'OST', duration: '3:45', youtubeUrl: 'https://youtube.com/watch?v=test' }], count: 1 });
+  if (name === 'get_character_roles') return Promise.resolve({ roles: [{ role: 'Yang Caiwei', roleCn: '杨采薇', workTitle: 'In Blossom', year: 2024 }], count: 1 });
+  if (name === 'get_brand_endorsements') return Promise.resolve({ brands: [{ brand: 'Versace', title: 'Global Brand Ambassador', category: 'Luxury', year: args.year || 2026 }], count: 1 });
+  if (name === 'get_awards') return Promise.resolve({ awards: [{ id: 'award-1', title: 'Weibo Actress of the Year', ceremony: 'Weibo Night', category: 'Acting', year: args.year || 2025 }], count: 1 });
+  if (name === 'get_gallery_photos') return Promise.resolve({ photos: [{ id: 'photo-1', title: 'Milan Fashion Week Portrait', category: 'fashion-magazine', year: args.year || 2025 }], count: 1 });
+  if (name === 'get_music_videos') return Promise.resolve({ videos: [{ id: 'stage-1', title: 'Live Stage Performance', category: 'Stage Performance', year: 2025, duration: '4:12', youtubeUrl: 'https://youtube.com/watch?v=stage' }], count: 1 });
+  if (name === 'web_search') return Promise.resolve({ results: [
+    { title: `Ju Jingyi official studio update ${RECENT_DATE}`, url: 'https://weibo.com/kiku-studio', snippet: 'A concise official update about the latest drama production.' },
+    { title: 'Ju Jingyi interview', url: 'https://example.com/interview', snippet: 'A recent interview covering music and acting.' },
+  ] });
+  return Promise.resolve({});
+}
+
+function createContext() {
+  const memory = new AgentMemory();
+  memory.save = async () => true;
+  memory.exportFavorites = async format => ({ filePath: `C:\\kiku-test\\favorites.${format === 'markdown' ? 'md' : 'json'}`, count: memory.getFavorites().length });
+  const jobs = new AgentJobManager();
+  const running = jobs.create('research', 'Inspect the newest Ju Jingyi drama announcement and collect trustworthy sources');
+  return {
+    context: {
+      executeTool: executor,
+      random: () => 0,
+      agent: {
+        memory,
+        getJobs: () => jobs.list(),
+        getJob: id => jobs.get(id),
+        cancelJob: id => jobs.cancel(id),
+        clearJobs: () => jobs.clear(),
+      },
+    },
+    memory,
+    jobs,
+    running,
+  };
+}
+
+async function captureAtWidth(width, run) {
+  const originalLog = console.log;
+  const originalDescriptor = Object.getOwnPropertyDescriptor(process.stdout, 'columns');
+  const output = [];
+  Object.defineProperty(process.stdout, 'columns', { value: width, configurable: true });
+  console.log = (...args) => output.push(args.join(' '));
+  try {
+    const result = await run();
+    return { result, output: output.join('\n') };
+  } finally {
+    console.log = originalLog;
+    if (originalDescriptor) Object.defineProperty(process.stdout, 'columns', originalDescriptor);
+    else delete process.stdout.columns;
+  }
+}
+
+function assertHealthyTui(output, width) {
+  assert.doesNotMatch(output, /undefined|\[object Object\]|NaN/);
+  for (const line of output.split('\n')) {
+    assert.ok(getStringDisplayWidth(stripAnsi(line)) <= width, `TUI line exceeded ${width} columns: ${stripAnsi(line)}`);
+  }
+}
+
+test('every canonical command exposes its help route without executing side effects', async () => {
+  const seen = [];
+  for (const command of COMMAND_NAMES) {
+    const result = await routeCommand(`${command} help`, { printHelp: name => seen.push(name) });
+    assert.equal(result, 'HANDLED', command);
+  }
+  assert.deepEqual(seen, COMMAND_NAMES.map(command => command === '/help' ? 'help' : command));
+});
+
+for (const width of [80, 120]) {
+  test(`welcome TUI is bounded and complete at ${width} columns`, async () => {
+    const rendered = await captureAtWidth(width, async () => getWelcomeHeroLines());
+    const lines = rendered.result;
+    assert.match(stripAnsi(lines.join('\n')), /Ju Jingyi/);
+    assert.match(stripAnsi(lines.join('\n')), /Ctrl\+C/);
+    for (const line of lines) assert.ok(getStringDisplayWidth(stripAnsi(line)) <= width, stripAnsi(line));
+    if (width === 80) assert.ok(lines.length <= 14);
+  });
+}
+
+for (const width of [80, 120]) {
+  test(`new command TUI matrix is complete and bounded at ${width} columns`, async () => {
+    const { context, memory, running } = createContext();
+    const commands = [
+      ['/find "In Blossom" --type work --limit 4', /Catalog Search/],
+      ['/find Versace --type brand --year 2026', /Versace/],
+      ['/find test --type invalid', /COMMAND ERROR/],
+      ['/compare "In Blossom" -- "Beauty of Resilience" --type work', /Compare/],
+      ['/compare 2024 -- 2025', /2024/],
+      ['/compare missing separator', /Usage/],
+      ['/favorites list', /Favorites/],
+      ['/favorites add song "Rain Love"', /Favorite Added/],
+      ['/favorites list --type song', /Rain Love/],
+      ['/favorites export markdown', /Favorites Exported/],
+      ['/news drama --days 7', /News/],
+      ['/news drama --days 14 --official-only', /weibo\.com/],
+      ['/news --days 0', /COMMAND ERROR/],
+      ['/jobs list', new RegExp(running.id)],
+      [`/jobs show ${running.id}`, /Inspect the newest/],
+      [`/jobs cancel ${running.id}`, /cancellation requested/],
+      ['/jobs clear', /Cleared/],
+      ['/discover drama', /บุปผารักอลวน/],
+      ['/discover song --mood calm', /Rain Love/],
+      ['/discover stage --year 2025', /Live Stage/],
+      ['/discover photo', /Milan Fashion Week/],
+      ['/discover award', /COMMAND ERROR/],
+    ];
+
+    for (const [command, expected] of commands) {
+      const rendered = await captureAtWidth(width, () => routeCommand(command, context));
+      assert.equal(rendered.result, 'HANDLED', command);
+      assert.match(rendered.output, expected, command);
+      assertHealthyTui(rendered.output, width);
+    }
+
+    const favorite = memory.getFavorites()[0];
+    const removed = await captureAtWidth(width, () => routeCommand(`/favorites remove ${favorite.id}`, context));
+    assert.match(removed.output, /Favorite removed/);
+    assertHealthyTui(removed.output, width);
+  });
+}

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

@@ -0,0 +1,113 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { extractYouTubeVideoId, parseSubtitleToText } from '../youtubeTranscript.js';
+import { executeTool, toolHandlers, toolsSchema } from '../tools.js';
+import { KikuAgent } from '../agentCore.js';
+
+function bareAgent() {
+  const agent = Object.create(KikuAgent.prototype);
+  agent.mcpManager = null;
+  agent.allowedToolNames = null;
+  return agent;
+}
+
+test('get_current_datetime returns a coherent current date', async () => {
+  const result = await executeTool('get_current_datetime', {});
+
+  assert.equal(result.status, 'success');
+  assert.equal(result.year, new Date().getFullYear());
+  assert.ok(Number.isFinite(result.timestampMs));
+  assert.match(result.timezoneOffset, /^[+-]\d{2}:\d{2}$/);
+  assert.match(result.iso, /^\d{4}-\d{2}-\d{2}T/);
+  assert.ok(['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'].includes(result.weekday));
+});
+
+test('system prompt injects the live year instead of a hardcoded one', () => {
+  const prompt = bareAgent().buildSystemPrompt();
+  assert.ok(!prompt.includes('{{CURRENT_YEAR}}'));
+  assert.ok(prompt.includes(`THE CURRENT YEAR IS ${new Date().getFullYear()}`));
+  assert.ok(!prompt.includes('THE CURRENT YEAR IS 2026.'));
+});
+
+test('get_profile_and_fandom exposes previously hidden sections', async () => {
+  const talents = await toolHandlers.get_profile_and_fandom({ section: 'talents' });
+  assert.ok(Array.isArray(talents.talents));
+  assert.ok(talents.talents.length > 0);
+  assert.equal(talents.talents[0].title.length > 0, true);
+
+  const honors = await toolHandlers.get_profile_and_fandom({ section: 'honors' });
+  assert.ok(honors.honors.some(h => /Forbes/.test(h)));
+
+  const social = await toolHandlers.get_profile_and_fandom({ section: 'social' });
+  assert.ok(social.socialLinks.some(s => /^https?:\/\//.test(s.url)));
+
+  const all = await executeTool('get_profile_and_fandom', {});
+  assert.equal(all.status, 'success');
+  assert.ok(all.talents.length > 0);
+  assert.ok(all.stats.length > 0);
+  assert.ok(all.honors.length > 0);
+  assert.ok(all.socialLinks.length > 0);
+});
+
+test('get_gallery_photos includes the served image path', async () => {
+  const result = await executeTool('get_gallery_photos', { limit: 2 });
+  assert.equal(result.status, 'success');
+  assert.ok(result.photos.length > 0);
+  assert.match(result.photos[0].imageUrl, /^\/images\//);
+});
+
+test('extractYouTubeVideoId understands URLs and bare IDs', () => {
+  assert.equal(extractYouTubeVideoId('9AeErG03SZw'), '9AeErG03SZw');
+  assert.equal(extractYouTubeVideoId('https://www.youtube.com/watch?v=9AeErG03SZw'), '9AeErG03SZw');
+  assert.equal(extractYouTubeVideoId('https://youtu.be/OMLpNyp8T7Q?t=30'), 'OMLpNyp8T7Q');
+  assert.equal(extractYouTubeVideoId('https://www.youtube.com/shorts/abcd1234efg'), 'abcd1234efg');
+  assert.equal(extractYouTubeVideoId('not a youtube link'), null);
+});
+
+test('parseSubtitleToText flattens VTT with inline tags and dedupes rolling captions', () => {
+  const vtt = [
+    'WEBVTT',
+    '',
+    '00:00:01.000 --> 00:00:03.000',
+    '<c.colorE5E5E5>Hello</c> world',
+    '',
+    '00:00:03.000 --> 00:00:05.000',
+    'Hello world',
+    '',
+    'NOTE This is a comment',
+    '',
+    '00:00:05.000 --> 00:00:07.000',
+    'Second &amp; final line',
+  ].join('\n');
+
+  const text = parseSubtitleToText(vtt);
+  assert.equal(text, 'Hello world Second & final line');
+});
+
+test('parseSubtitleToText skips SRT sequence numbers', () => {
+  const srt = [
+    '1',
+    '00:00:01,000 --> 00:00:03,000',
+    'First line',
+    '',
+    '2',
+    '00:00:03,000 --> 00:00:05,000',
+    '2024',
+  ].join('\n');
+
+  const text = parseSubtitleToText(srt);
+  assert.equal(text, 'First line 2024');
+});
+
+test('get_youtube_transcript requires a url or videoId', async () => {
+  const result = await executeTool('get_youtube_transcript', {});
+  assert.equal(result.status, 'error');
+  assert.match(result.message, /valid YouTube URL|videoId/i);
+});
+
+test('new tools are exposed through the schema and executable via the standard pipeline', () => {
+  const names = toolsSchema.map(t => t.function.name);
+  assert.ok(names.includes('get_current_datetime'));
+  assert.ok(names.includes('get_youtube_transcript'));
+});

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

@@ -0,0 +1,178 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  extractArticleDate,
+  classifySource,
+  classifyTopics,
+  dedupeNewsItems,
+  rankNewsItems,
+  mergeNewsResults,
+  newsFingerprint,
+} from '../newsIntelligence.js';
+import { checkNewsWatch, loadWatchState, saveWatchState } from '../newsWatch.js';
+
+const NOW = new Date('2026-09-12T12:00:00Z');
+
+test('extractArticleDate parses ISO, Chinese, Thai BE, and English dates', () => {
+  const iso = extractArticleDate({ title: 'Ju Jingyi new drama 2026-09-01 announced', snippet: '' }, { now: NOW });
+  assert.equal(iso.source, 'iso');
+  assert.equal(iso.date.toISOString().slice(0, 10), '2026-09-01');
+
+  const zh = extractArticleDate({ title: '鞠婧祎 2026年9月10日 发新歌', snippet: '' }, { now: NOW });
+  assert.equal(zh.source, 'zh');
+  assert.equal(zh.date.toISOString().slice(0, 10), '2026-09-10');
+
+  const thBE = extractArticleDate({ title: 'จวีจิ้งอีปล่อยเพลงใหม่ 12 ก.ย. 2568', snippet: '' }, { now: NOW });
+  assert.equal(thBE.source, 'th');
+  assert.equal(thBE.date.toISOString().slice(0, 10), '2025-09-12', 'Buddhist Era 2568 must convert to CE 2025');
+
+  const thFull = extractArticleDate({ title: '', snippet: '12 กันยายน 2026 จวีจิ้งอีคว้ารางวัล' }, { now: NOW });
+  assert.equal(thFull.source, 'th');
+  assert.equal(thFull.date.toISOString().slice(0, 10), '2026-09-12');
+
+  const en1 = extractArticleDate({ title: 'Ju Jingyi appears at event Sep 12, 2026', snippet: '' }, { now: NOW });
+  assert.equal(en1.source, 'en');
+  assert.equal(en1.date.toISOString().slice(0, 10), '2026-09-12');
+
+  const en2 = extractArticleDate({ title: '', snippet: '12 September 2026 studio update' }, { now: NOW });
+  assert.equal(en2.date.toISOString().slice(0, 10), '2026-09-12');
+});
+
+test('extractArticleDate prefers RSS pubDate and supports relative dates', () => {
+  const rss = extractArticleDate({ publishedAt: '2026-09-08T06:30:00Z', title: 'x 2026-01-01' }, { now: NOW });
+  assert.equal(rss.source, 'rss');
+  assert.equal(rss.date.toISOString().slice(0, 10), '2026-09-08');
+
+  const enRel = extractArticleDate({ title: 'Ju Jingyi new single posted 3 hours ago', snippet: '' }, { now: NOW });
+  assert.equal(enRel.source, 'relative');
+  assert.equal(enRel.date.toISOString(), '2026-09-12T09:00:00.000Z');
+
+  const zhRel = extractArticleDate({ title: '鞠婧祎工作室 5小时前 发布', snippet: '' }, { now: NOW });
+  assert.equal(zhRel.date.toISOString(), '2026-09-12T07:00:00.000Z');
+
+  const thRel = extractArticleDate({ title: 'จวีจิ้งอี 2 วันที่แล้ว', snippet: '' }, { now: NOW });
+  assert.equal(thRel.date.toISOString(), '2026-09-10T12:00:00.000Z');
+
+  const none = extractArticleDate({ title: 'Ju Jingyi something happened', snippet: '' }, { now: NOW });
+  assert.equal(none.date, null);
+  assert.equal(none.source, null);
+});
+
+test('classifySource assigns trust tiers to official, press, and community hosts', () => {
+  assert.deepEqual(classifySource('https://weibo.com/u/123456'), { tier: 1, label: 'official' });
+  assert.deepEqual(classifySource('https://m.weibo.cn/status/abc'), { tier: 1, label: 'official' });
+  assert.deepEqual(classifySource('https://www.youtube.com/watch?v=x'), { tier: 1, label: 'official' });
+  assert.equal(classifySource('https://www.thairath.co.th/entertain/x').tier, 2);
+  assert.equal(classifySource('https://ent.sohu.com/a/1').tier, 2);
+  assert.deepEqual(classifySource('https://fanblog.example.com/post'), { tier: 3, label: 'community' });
+});
+
+test('classifyTopics tags music, drama, brand, award, and event coverage', () => {
+  assert.equal(classifyTopics({ title: 'Ju Jingyi new single MV released', snippet: '' }).primary, 'music');
+  assert.equal(classifyTopics({ title: 'จวีจิ้งอี รับบท leading role ซีรีส์ใหม่', snippet: '' }).primary, 'drama');
+  assert.equal(classifyTopics({ title: 'Ju Jingyi named brand ambassador', snippet: '' }).primary, 'brand');
+  assert.ok(classifyTopics({ title: 'Ju Jingyi wins award', snippet: '' }).tags.includes('award'));
+  assert.equal(classifyTopics({ title: 'Unrelated headline', snippet: '' }).primary, 'general');
+});
+
+test('dedupeNewsItems collapses near-duplicate stories and keeps distinct ones', () => {
+  const a = { title: 'Ju Jingyi releases new single 0.2s topping three regional charts', snippet: 'The single topped charts this week across regional platforms.', url: 'https://press-a.com/1' };
+  const b = { title: 'Ju Jingyi releases new single 0.2s topping three regional charts!', snippet: 'The single topped charts this week across regional platforms.', url: 'https://press-b.com/2' };
+  const c = { title: 'Ju Jingyi opening fanmeeting tour in Bangkok next month', snippet: 'Tickets go on sale for the Bangkok fanmeeting tour next month.', url: 'https://press-c.com/3' };
+
+  const kept = dedupeNewsItems([a, b, c]);
+  assert.equal(kept.length, 2);
+  assert.equal(kept[0].url, 'https://press-a.com/1');
+  assert.equal(kept[1].url, 'https://press-c.com/3');
+
+  const urlDupes = dedupeNewsItems([
+    { ...a, url: 'https://x.com/same?utm=1' },
+    { ...a, url: 'https://x.com/same?utm=2' },
+  ]);
+  assert.equal(urlDupes.length, 1, 'URL normalization must drop same-article copies');
+});
+
+test('rankNewsItems sorts by recency, filters by cutoff, and applies officialOnly', () => {
+  const fresh = { title: 'fresh official weibo post', snippet: '', url: 'https://weibo.com/u/1/1', publishedAt: '2026-09-12T10:00:00Z' };
+  const monthOld = { title: 'older press story', snippet: '', url: 'https://www.thairath.co.th/e/2', publishedAt: '2026-08-10T00:00:00Z' };
+  const undated = { title: 'undated fan blog post', snippet: '', url: 'https://blog.example.com/3' };
+
+  const ranked = rankNewsItems([monthOld, undated, fresh], { now: NOW });
+  assert.equal(ranked[0].title, fresh.title, 'fresh items must outrank older and undated ones');
+
+  const cutoffFiltered = rankNewsItems([monthOld, fresh], { now: NOW, cutoff: new Date('2026-09-01T00:00:00Z') });
+  assert.equal(cutoffFiltered.length, 1);
+  assert.equal(cutoffFiltered[0].title, fresh.title);
+
+  const official = rankNewsItems([fresh, monthOld], { now: NOW, officialOnly: true });
+  assert.equal(official.length, 1);
+  assert.equal(official[0].tier, 1);
+});
+
+test('mergeNewsResults fuses RSS and web groups with dedup and budget', () => {
+  const rss = [
+    { title: 'Studio announces comeback single', snippet: 'Official studio announcement of the comeback single this month.', url: 'https://press-a.com/comeback', publishedAt: '2026-09-11T00:00:00Z' },
+    { title: 'Drama filming wraps', snippet: 'The drama filming has wrapped after three months of production.', url: 'https://press-b.com/drama', publishedAt: '2026-09-05T00:00:00Z' },
+  ];
+  const web = [
+    { title: 'Studio announces comeback single', snippet: 'Official studio announcement of the comeback single this month.', url: 'https://aggregator.example/comeback' },
+    { title: 'Brand ambassador campaign launches', snippet: 'New brand ambassador campaign launches with a nationwide rollout.', url: 'https://press-c.com/brand', publishedAt: '2026-09-09T00:00:00Z' },
+  ];
+
+  const { items, totalUnique } = mergeNewsResults({
+    groups: [{ name: 'news-rss', results: rss }, { name: 'web', results: web }],
+    now: NOW,
+    budget: 10,
+  });
+  assert.equal(totalUnique, 3, 'same story from two groups must collapse to one');
+  assert.equal(items[0].title, 'Studio announces comeback single', 'freshest official story must rank first');
+  assert.ok(items[0].via, 'merge must record which group each item came from');
+});
+
+function tmpStatePath() {
+  return path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'kiku-news-')), 'watch-state.json');
+}
+
+test('checkNewsWatch detects first-run items, zero delta on repeat, and fresh items on change', async () => {
+  const statePath = tmpStatePath();
+  const fetcher = () => Promise.resolve([
+    { title: 'Ju Jingyi comeback stage confirmed for this weekend', snippet: 'Comeback stage confirmed with a special performance lineup.', url: 'https://press-a.com/1', publishedAt: '2026-09-11T00:00:00Z' },
+  ]);
+
+  const first = await checkNewsWatch({ topic: 'comeback', days: 7, fetcher, statePath, now: NOW });
+  assert.equal(first.fresh.length, 1);
+
+  const second = await checkNewsWatch({ topic: 'comeback', days: 7, fetcher, statePath, now: new Date(NOW.getTime() + 60000) });
+  assert.equal(second.fresh.length, 0, 'unchanged stories must not re-appear as fresh');
+
+  const changedFetcher = () => Promise.resolve([
+    { title: 'Ju Jingyi comeback stage confirmed for this weekend', snippet: 'Comeback stage confirmed with a special performance lineup.', url: 'https://press-a.com/1', publishedAt: '2026-09-11T00:00:00Z' },
+    { title: 'Ju Jingyi surprise digital single drops at midnight', snippet: 'A surprise digital single drops at midnight with an accompanying music video.', url: 'https://press-a.com/2', publishedAt: '2026-09-12T09:00:00Z' },
+  ]);
+  const third = await checkNewsWatch({ topic: 'comeback', days: 7, fetcher: changedFetcher, statePath, now: new Date(NOW.getTime() + 120000) });
+  assert.equal(third.fresh.length, 1, 'only the genuinely new story counts as fresh');
+  assert.equal(third.fresh[0].url, 'https://press-a.com/2');
+
+  const persisted = loadWatchState(statePath);
+  assert.ok(persisted.watches['comeback'].lastHashes.length >= 1);
+});
+
+test('watch state persists snapshots across processes', () => {
+  const statePath = tmpStatePath();
+  const state = loadWatchState(statePath);
+  state.watches['music'] = { lastHashes: ['abc'], lastCheckedAt: '2026-09-12T00:00:00.000Z', lastCount: 3 };
+  saveWatchState(state, statePath);
+
+  const reloaded = loadWatchState(statePath);
+  assert.equal(reloaded.watches['music'].lastHashes[0], 'abc');
+  assert.equal(reloaded.watches['music'].lastCount, 3);
+});
+
+test('newsFingerprint is stable for identical items', () => {
+  const item = { title: 'identical headline for fingerprint check', snippet: 'same body text' };
+  assert.equal(newsFingerprint(item), newsFingerprint({ ...item }));
+  assert.notEqual(newsFingerprint(item), newsFingerprint({ title: 'different headline entirely', snippet: 'other body' }));
+});

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

@@ -0,0 +1,101 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { DynamicToolRouter, TOOL_CLUSTERS } from '../toolRouter.js';
+import { ContextCompactor, estimateTokenCount } from '../contextCompactor.js';
+import { AgentMemory } from '../memory.js';
+import { getUnifiedProfile, getUnifiedWorks, getUnifiedDiscography } from '../../mcp/dataAdapter.js';
+import { eventBus, Events } from '../eventBus.js';
+
+test('DynamicToolRouter filters tools based on prompt intent', () => {
+  const router = new DynamicToolRouter();
+  
+  const mediaTools = router.routeToolsForQuery('เปิดเพลงของจวีจิ้งอีหน่อย');
+  assert.ok(mediaTools.some(t => t.function.name === 'play_music'));
+  assert.ok(mediaTools.some(t => t.function.name === 'search_discography'));
+  assert.ok(mediaTools.length < router.allTools.length);
+
+  const dramaTools = router.routeToolsForQuery('Ju Jingyi In Blossom drama synopsis');
+  assert.ok(dramaTools.some(t => t.function.name === 'search_works'));
+  assert.ok(dramaTools.some(t => t.function.name === 'get_work_detail'));
+
+  const fallbackTools = router.routeToolsForQuery('สวัสดีครับ');
+  assert.ok(fallbackTools.some(t => t.function.name === 'global_search'));
+  assert.ok(fallbackTools.length <= 10);
+});
+
+test('ContextCompactor calculates tokens and summarizes history without losing system message', () => {
+  const compactor = new ContextCompactor({ maxTokens: 50, keepRecentMessages: 2 });
+  const messages = [
+    { role: 'system', content: 'You are Kiku AI.' },
+    { role: 'user', content: 'Who is Ju Jingyi?' },
+    { role: 'assistant', content: 'Ju Jingyi is a singer and actress.' },
+    { role: 'user', content: 'Tell me about her songs.' },
+    { role: 'assistant', content: 'She has many solo singles.' },
+    { role: 'user', content: 'What is her latest drama in 2026?' },
+  ];
+
+  const tokens = estimateTokenCount(messages);
+  assert.ok(tokens > 0);
+
+  const compacted = compactor.compact(messages, { maxTokens: 20, keepRecentMessages: 2 });
+  assert.equal(compacted[0].role, 'system');
+  assert.equal(compacted[0].content, 'You are Kiku AI.');
+  assert.match(compacted[compacted.length - 1].content, /Previous Session Context Summary/);
+  assert.match(compacted[compacted.length - 1].content, /What is her latest drama in 2026\?/);
+  assert.equal(compacted.filter(message => message.role === 'system').length, 1);
+  assert.ok(compacted.some(m => typeof m.content === 'string' && m.content.includes('[Previous Session Context Summary')));
+});
+
+test('AgentMemory scores fact relevance and applies recency weighting', () => {
+  const memory = new AgentMemory();
+  const f1 = memory.addFact('Ju Jingyi won Top Female Singer in 2026', {
+    category: 'awards',
+    tags: ['singer', 'award', '2026'],
+    confidence: 'high'
+  });
+  const f2 = memory.addFact('Ju Jingyi starred in Legend of White Snake', {
+    category: 'drama',
+    tags: ['drama', 'white snake'],
+    confidence: 'high'
+  });
+
+  const relevant = memory.getRelevantFacts('awards 2026', 2);
+  assert.ok(relevant.length > 0);
+  assert.equal(relevant[0].content, f1.content);
+
+  const context = memory.buildMemoryContext('white snake drama');
+  assert.ok(context.includes('Legend of White Snake'));
+});
+
+test('SSOT DataAdapter provides consistent and valid records for MCP', () => {
+  const profile = getUnifiedProfile();
+  assert.equal(profile.nameCn, '鞠婧祎');
+  assert.ok(profile.fandomName.includes('Miju'));
+
+  const works = getUnifiedWorks();
+  assert.ok(works.length > 10);
+  assert.ok(works.some(w => w.year >= 2024));
+
+  const songs = getUnifiedDiscography();
+  assert.ok(songs.length > 20);
+});
+
+test('EventBus emits AGENT_PLAN lifecycle events for TUI Task Planning', () => {
+  const emitted = [];
+  const unsub1 = eventBus.on(Events.AGENT_PLAN_START, (d) => emitted.push({ type: 'start', data: d }));
+  const unsub2 = eventBus.on(Events.AGENT_PLAN_STEP_UPDATE, (d) => emitted.push({ type: 'update', data: d }));
+  const unsub3 = eventBus.on(Events.AGENT_PLAN_COMPLETE, (d) => emitted.push({ type: 'complete', data: d }));
+
+  eventBus.emit(Events.AGENT_PLAN_START, { planId: 'p1', steps: [{ id: 's1', state: 'pending' }] });
+  eventBus.emit(Events.AGENT_PLAN_STEP_UPDATE, { planId: 'p1', stepId: 's1', state: 'running' });
+  eventBus.emit(Events.AGENT_PLAN_COMPLETE, { planId: 'p1' });
+
+  assert.equal(emitted.length, 3);
+  assert.equal(emitted[0].type, 'start');
+  assert.equal(emitted[1].data.state, 'running');
+  assert.equal(emitted[2].type, 'complete');
+
+  unsub1();
+  unsub2();
+  unsub3();
+});