kiku-agent 1.3.0 → 1.3.2

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

@@ -0,0 +1,347 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { routeCommand } from '../commands.js';
+import { AgentMemory } from '../memory.js';
+import { AgentJobManager } from '../jobManager.js';
+
+const RECENT_DATE = new Date(Date.now() - 3 * 86_400_000).toISOString().slice(0, 10);
+
+async function captureOutput(run) {
+  const originalLog = console.log;
+  const output = [];
+  console.log = (...args) => output.push(args.join(' '));
+  try {
+    const result = await run();
+    return { result, output: output.join('\n') };
+  } finally {
+    console.log = originalLog;
+  }
+}
+
+function catalogExecutor(name, args = {}) {
+  if (name === 'search_works' && (!args.query || /in blossom/i.test(args.query))) return Promise.resolve({ works: [{ id: 'in-blossom', titleTh: 'In Blossom', year: 2024, role: 'Yang Caiwei', platform: 'Youku', episodes: 32 }] });
+  if (name === 'search_discography' && (!args.query || /rain love/i.test(args.query))) return Promise.resolve({ songs: [{ id: 'rain-love', title: 'Rain Love', year: 2024, type: 'Single', duration: '3:45' }] });
+  return Promise.resolve({ works: [], songs: [], roles: [], brands: [], awards: [], photos: [], videos: [] });
+}
+
+test('/find validates flags and renders normalized catalog results', async () => {
+  const found = await captureOutput(() => routeCommand('/find "In Blossom" --type work --limit 2', { executeTool: catalogExecutor }));
+  assert.equal(found.result, 'HANDLED');
+  assert.match(found.output, /Catalog Search/);
+  assert.match(found.output, /In Blossom/);
+
+  const invalid = await captureOutput(() => routeCommand('/find test --type file', { executeTool: catalogExecutor }));
+  assert.equal(invalid.result, 'HANDLED');
+  assert.match(invalid.output, /COMMAND ERROR/);
+});
+
+test('/compare resolves both sides around the separator', async () => {
+  const output = await captureOutput(() => routeCommand('/compare "In Blossom" -- "Rain Love"', { executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Compare/);
+  assert.match(output.output, /In Blossom/);
+  assert.match(output.output, /Rain Love/);
+});
+
+test('/favorites adds, lists, removes, and exports resolved entries', async () => {
+  const memory = new AgentMemory();
+  memory.save = async () => true;
+  memory.exportFavorites = async format => ({ filePath: `C:\\safe\\favorites.${format === 'markdown' ? 'md' : 'json'}`, count: memory.getFavorites().length });
+  const agent = { memory };
+
+  const added = await captureOutput(() => routeCommand('/favorites add work "In Blossom"', { agent, executeTool: catalogExecutor }));
+  assert.equal(added.result, 'HANDLED');
+  assert.equal(memory.getFavorites().length, 1);
+  assert.match(added.output, /Favorite Added/);
+
+  const listed = await captureOutput(() => routeCommand('/favorites list --type work', { agent }));
+  assert.match(listed.output, /In Blossom/);
+
+  const id = memory.getFavorites()[0].id;
+  await captureOutput(() => routeCommand(`/favorites remove ${id}`, { agent }));
+  assert.equal(memory.getFavorites().length, 0);
+
+  const exported = await captureOutput(() => routeCommand('/favorites export markdown', { agent }));
+  assert.match(exported.output, /Favorites Exported/);
+});
+
+test('/news filters unsafe URLs and honors official-only hosts', async () => {
+  let query = '';
+  const executeTool = async () => ({
+    results: [
+      { title: `Official update ${RECENT_DATE}`, url: 'https://weibo.com/example', snippet: 'Studio update\u001b[31m' },
+      { title: 'Unsafe', url: 'javascript:alert(1)', snippet: 'Ignore' },
+      { title: 'Blog', url: 'https://example.com/news', snippet: 'Unofficial' },
+    ],
+  });
+  const output = await captureOutput(() => routeCommand('/news drama --days 7 --official-only', { executeTool: async (name, args) => {
+    query = args.query;
+    return executeTool(name, args);
+  } }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(query, /after:\d{4}-\d{2}-\d{2} before:\d{4}-\d{2}-\d{2}/);
+  assert.match(output.output, /requested 7-day window/);
+  assert.match(output.output, /weibo\.com/);
+  assert.doesNotMatch(output.output, /javascript:/);
+  assert.doesNotMatch(output.output, /example\.com/);
+  assert.doesNotMatch(output.output, /\u001b\[31m/);
+});
+
+test('/news labels results without dates as recency unverified', async () => {
+  const executeTool = async () => ({ results: [{ title: 'Drama update', url: 'https://example.com/update', snippet: 'No publication date' }] });
+  const output = await captureOutput(() => routeCommand('/news drama --days 7', { executeTool }));
+  assert.match(output.output, /date unavailable • recency unverified/);
+});
+
+test('/jobs lists, shows, cancels, and clears through the agent contract', async () => {
+  const manager = new AgentJobManager();
+  const job = manager.create('research', 'Current drama news');
+  const agent = {
+    getJobs: () => manager.list(),
+    getJob: id => manager.get(id),
+    cancelJob: id => manager.cancel(id),
+    clearJobs: () => manager.clear(),
+  };
+  const listed = await captureOutput(() => routeCommand('/jobs', { agent }));
+  assert.match(listed.output, new RegExp(job.id));
+  const shown = await captureOutput(() => routeCommand(`/jobs show ${job.id}`, { agent }));
+  assert.match(shown.output, /Current drama news/);
+  await captureOutput(() => routeCommand(`/jobs cancel ${job.id}`, { agent }));
+  assert.equal(manager.get(job.id).state, 'cancelled');
+  await captureOutput(() => routeCommand('/jobs clear', { agent }));
+  assert.equal(manager.list().length, 0);
+});
+
+test('/discover returns one catalog recommendation with deterministic selection', async () => {
+  const output = await captureOutput(() => routeCommand('/discover song --mood calm', { executeTool: catalogExecutor, random: () => 0 }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Discover/);
+  assert.match(output.output, /Rain Love/);
+});
+
+test('/discover renders an AI rationale when a chat client is available', async () => {
+  const agent = {
+    memory: new AgentMemory(),
+    client: {
+      chat: async () => ({ content: 'A dreamy choice to end the day.' }),
+    },
+  };
+  const output = await captureOutput(() => routeCommand('/discover song --mood calm', { agent, executeTool: catalogExecutor, random: () => 0 }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /A dreamy choice to end the day/);
+});
+
+test('/discover falls back gracefully when the chat client fails', async () => {
+  const agent = {
+    memory: new AgentMemory(),
+    client: {
+      chat: async () => { throw new Error('model unavailable'); },
+    },
+  };
+  const output = await captureOutput(() => routeCommand('/discover drama', { agent, executeTool: catalogExecutor, random: () => 0 }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Discover/);
+  assert.match(output.output, /In Blossom/);
+  assert.doesNotMatch(output.output, /COMMAND ERROR/);
+});
+
+function fakeAgent(narration) {
+  const memory = new AgentMemory();
+  memory.save = async () => true;
+  return {
+    memory,
+    client: { chat: async () => ({ content: narration }) },
+  };
+}
+
+test('/compare renders an AI natural-language summary when a client is available', async () => {
+  const output = await captureOutput(() => routeCommand('/compare "In Blossom" -- "Rain Love"', { agent: fakeAgent('In Blossom is a drama while Rain Love is a single.'), executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /In Blossom is a drama while Rain Love is a single/);
+});
+
+test('/compare falls back gracefully when the chat client fails', async () => {
+  const agent = { client: { chat: async () => { throw new Error('boom'); } } };
+  const output = await captureOutput(() => routeCommand('/compare "In Blossom" -- "Rain Love"', { agent, executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Differences/);
+  assert.doesNotMatch(output.output, /COMMAND ERROR/);
+});
+
+test('/find renders an AI explanation when a client is available', async () => {
+  const output = await captureOutput(() => routeCommand('/find "In Blossom" --type work', { agent: fakeAgent('In Blossom matches because the query matches its title.'), executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /matches because/);
+});
+
+test('/find falls back gracefully when no client is available', async () => {
+  const output = await captureOutput(() => routeCommand('/find "In Blossom" --type work', { executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Catalog Search/);
+  assert.match(output.output, /In Blossom/);
+  assert.doesNotMatch(output.output, /COMMAND ERROR/);
+});
+
+test('/favorites suggest renders an AI recommendation from saved taste', async () => {
+  const agent = fakeAgent('Rain Love — a gentle companion piece\nIn Blossom encore');
+  await captureOutput(() => routeCommand('/favorites add work "In Blossom"', { agent, executeTool: catalogExecutor }));
+  const output = await captureOutput(() => routeCommand('/favorites suggest', { agent, executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Favorites Suggest/);
+  assert.match(output.output, /Rain Love/);
+});
+
+test('/favorites suggest explains when there are no favorites yet', async () => {
+  const output = await captureOutput(() => routeCommand('/favorites suggest', { agent: fakeAgent('ignored'), executeTool: catalogExecutor }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /No favorites yet/);
+  assert.doesNotMatch(output.output, /COMMAND ERROR/);
+});
+
+test('/news renders an AI summary of results when a client is available', async () => {
+  const executeTool = async () => ({ results: [{ title: `Studio update ${RECENT_DATE}`, url: 'https://weibo.com/example', snippet: 'New single released' }] });
+  const output = await captureOutput(() => routeCommand('/news drama --days 7', { agent: fakeAgent('The studio announced a new single this week.'), executeTool }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /announced a new single/);
+});
+
+test('/news falls back gracefully when no client is available', async () => {
+  const executeTool = async () => ({ results: [{ title: `Studio update ${RECENT_DATE}`, url: 'https://weibo.com/example', snippet: 'New single released' }] });
+  const output = await captureOutput(() => routeCommand('/news drama --days 7', { executeTool }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /News Search/);
+  assert.doesNotMatch(output.output, /COMMAND ERROR/);
+});
+
+test('/history summary delegates to /session summary and renders an AI summary when messages and client exist', async () => {
+  const agent = fakeAgent('Discussed In Blossom release details and music.');
+  agent.session = {
+    messages: [
+      { role: 'user', parts: [{ type: 'text', content: 'Tell me about In Blossom' }] },
+      { role: 'assistant', parts: [{ type: 'text', content: 'In Blossom was released in 2024.' }] },
+    ],
+  };
+  const output = await captureOutput(() => routeCommand('/history summary', { agent }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Session Summary/);
+  assert.match(output.output, /Discussed In Blossom/);
+});
+
+test('/history summary handles empty history gracefully', async () => {
+  const agent = fakeAgent('ignored');
+  agent.session = { messages: [] };
+  const output = await captureOutput(() => routeCommand('/history summary', { agent }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /No messages in the active session/);
+});
+
+test('/session summary synthesizes an AI session analysis when messages exist', async () => {
+  const agent = fakeAgent('Session focused on 2024 filmography research with 2 tool calls.');
+  agent.session = {
+    id: 'sess_test_123',
+    messages: [
+      { role: 'user', parts: [{ type: 'text', content: 'Who did Ju Jingyi play in In Blossom?' }] },
+      { role: 'assistant', parts: [{ type: 'text', content: 'She played Yang Caiwei.' }] },
+    ],
+    stats: { totalQueries: 1, totalToolCalls: 2 },
+  };
+  const output = await captureOutput(() => routeCommand('/session summary', { agent }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Session Summary/);
+  assert.match(output.output, /Session focused on 2024/);
+});
+
+test('/session summary handles empty session messages gracefully', async () => {
+  const agent = fakeAgent('ignored');
+  agent.session = { id: 'sess_empty', messages: [], stats: {} };
+  const output = await captureOutput(() => routeCommand('/session summary', { agent }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /No messages in the active session/);
+});
+
+test('/mem summary synthesizes an AI persona profile when facts exist', async () => {
+  const agent = fakeAgent('User is an avid fan tracking Ju Jingyi dramas and OST releases.');
+  agent.memory.addFact('Loves In Blossom (2024)', { source: 'user' });
+  const output = await captureOutput(() => routeCommand('/mem summary', { agent }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Memory Profile Summary/);
+  assert.match(output.output, /avid fan tracking/);
+});
+
+test('/mem summary handles empty memory gracefully', async () => {
+  const agent = fakeAgent('ignored');
+  const output = await captureOutput(() => routeCommand('/mem summary', { agent }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /No long-term memories/);
+});
+
+test('/stats renders AI data narration alongside summary counts', async () => {
+  const agent = fakeAgent('Ju Jingyi has a rich discography and television portfolio.');
+  const output = await captureOutput(() => routeCommand('/stats', { agent, executeTool: async () => ({ stats: { totalWorks: 15, totalUniqueSongs: 40, brandEndorsements: 12, totalAwards: 25, timelineMilestones: 30 } }) }));
+  assert.equal(output.result, 'HANDLED');
+  assert.match(output.output, /Database Overview/);
+  assert.match(output.output, /rich discography/);
+});
+
+test('job manager records completion, failure, and cancellation states', async () => {
+  const manager = new AgentJobManager();
+  await manager.run('research', 'done', async () => ({ ok: true }));
+  assert.equal(manager.list()[0].state, 'completed');
+
+  await assert.rejects(manager.run('research', 'failed', async () => { throw new Error('failed'); }), /failed/);
+  assert.equal(manager.list()[0].state, 'failed');
+
+  let release;
+  const pending = manager.run('research', 'cancel me', ({ signal }) => new Promise((resolve, reject) => {
+    release = resolve;
+    signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+  }));
+  const active = manager.list()[0];
+  assert.equal(manager.cancel(active.id), true);
+  await assert.rejects(pending, /Cancelled by user/);
+  assert.equal(manager.get(active.id).state, 'cancelled');
+  release?.();
+});
+
+test('/session load and /resume restore archived sessions into memory', async () => {
+  let restoredTarget = null;
+  const mockAgent = {
+    session: {
+      id: 'sess_active',
+      messages: [],
+      stats: { totalQueries: 0, totalToolCalls: 0, totalDurationMs: 0 },
+      thinkingMode: 'hide',
+    },
+    memory: {
+      getArchivedSessions: (limit) => [
+        { id: 'sess_arch_1', createdAt: new Date(), messageCount: 4, stats: { totalQueries: 2, totalToolCalls: 3, totalDurationMs: 1500 } },
+        { id: 'sess_arch_2', createdAt: new Date(), messageCount: 2, stats: { totalQueries: 1, totalToolCalls: 1, totalDurationMs: 800 } },
+      ],
+    },
+    restoreSession: async (target) => {
+      restoredTarget = target;
+      return {
+        id: 'sess_arch_1',
+        createdAt: new Date(),
+        messages: [{ role: 'user' }, { role: 'assistant' }, { role: 'user' }, { role: 'assistant' }],
+        stats: { totalQueries: 2, totalToolCalls: 3, totalDurationMs: 1500 },
+      };
+    },
+  };
+
+  const usageOutput = await captureOutput(() => routeCommand('/session load', { agent: mockAgent, sub: 'load', extra: '' }));
+  assert.equal(usageOutput.result, 'HANDLED');
+  assert.match(usageOutput.output, /Load Session Usage/);
+
+  const loadOutput = await captureOutput(() => routeCommand('/session load sess_arch_1', { agent: mockAgent, sub: 'load', extra: 'sess_arch_1' }));
+  assert.equal(loadOutput.result, 'HANDLED');
+  assert.equal(restoredTarget, 'sess_arch_1');
+  assert.match(loadOutput.output, /Session Restored Successfully/);
+
+  const resumeOutput = await captureOutput(() => routeCommand('/resume 1', { agent: mockAgent, sub: '1', extra: '' }));
+  assert.equal(resumeOutput.result, 'HANDLED');
+  assert.equal(restoredTarget, '1');
+  assert.match(resumeOutput.output, /Session Restored Successfully/);
+});
+

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