kiku-agent 1.3.0 → 1.3.2

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

@@ -0,0 +1,83 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { TEST_SCENARIOS } from './scenariosData.js';
+import { DynamicToolRouter } from '../toolRouter.js';
+import { detectDominantLanguage } from '../agentCore.js';
+import { executeTool } from '../tools.js';
+import { AgentMemory } from '../memory.js';
+
+test('Benchmark: Test scenarios contain comprehensive valid entries', () => {
+  assert.ok(TEST_SCENARIOS.length >= 20);
+  const categories = new Set(TEST_SCENARIOS.map(s => s.category));
+  assert.ok(categories.has('works'));
+  assert.ok(categories.has('music'));
+  assert.ok(categories.has('brand'));
+  assert.ok(categories.has('awards'));
+  assert.ok(categories.has('profile'));
+  assert.ok(categories.has('timeline'));
+  assert.ok(categories.has('research'));
+  assert.ok(categories.has('system'));
+});
+
+test('Benchmark: DynamicToolRouter routes all test scenario prompts correctly', () => {
+  const router = new DynamicToolRouter();
+
+  for (const scenario of TEST_SCENARIOS) {
+    const routedTools = router.routeToolsForQuery(scenario.query);
+    const routedNames = new Set(routedTools.map(t => t.function.name));
+
+    assert.ok(routedTools.length > 0, `Scenario ${scenario.id} returned empty routed tools`);
+    assert.ok(routedTools.length <= 15, `Scenario ${scenario.id} exceeded tool limit`);
+
+    const hasExpectedTool = scenario.expectedTools.some(toolName => routedNames.has(toolName));
+    assert.ok(hasExpectedTool, `Scenario ${scenario.id} did not include any expected tools: ${scenario.expectedTools.join(', ')}`);
+  }
+});
+
+test('Benchmark: Language detection accurately identifies scenario query languages', () => {
+  for (const scenario of TEST_SCENARIOS) {
+    const detected = detectDominantLanguage(scenario.query);
+    assert.equal(detected, scenario.language, `Scenario ${scenario.id} expected ${scenario.language} but got ${detected}`);
+  }
+});
+
+test('Benchmark: Direct tool execution verifies domain facts across categories', async () => {
+  const worksRes = await executeTool('search_works', { query: 'In Blossom' });
+  assert.equal(worksRes.status, 'success');
+  assert.ok(worksRes.count > 0);
+
+  const discoRes = await executeTool('search_discography', { query: 'FIND THE WAY' });
+  assert.equal(discoRes.status, 'success');
+  assert.ok(discoRes.count > 0);
+
+  const brandRes = await executeTool('get_brand_endorsements', {});
+  assert.equal(brandRes.status, 'success');
+  assert.ok(brandRes.brands.length > 0);
+
+  const profileRes = await executeTool('get_profile_and_fandom', {});
+  assert.equal(profileRes.status, 'success');
+  assert.ok(profileRes.profile.nameCn.includes('鞠婧祎'));
+
+  const awardsRes = await executeTool('get_awards', {});
+  assert.equal(awardsRes.status, 'success');
+  assert.ok(awardsRes.awards.length > 0);
+
+  const statsRes = await executeTool('get_system_stats', {});
+  assert.equal(statsRes.status, 'success');
+  assert.ok(statsRes.stats.totalWorks > 0);
+});
+
+test('Benchmark: Memory query-aware ranking retrieves top relevant scenario facts', () => {
+  const memory = new AgentMemory();
+  for (const scenario of TEST_SCENARIOS) {
+    memory.addFact(`Ju Jingyi scenario fact for ${scenario.id}: ${scenario.expectedKeywords.join(' ')}`, {
+      category: scenario.category,
+      tags: scenario.expectedKeywords,
+      confidence: 'high'
+    });
+  }
+
+  const retrieved = memory.getRelevantFacts('In Blossom drama Yang Caiwei', 3);
+  assert.ok(retrieved.length > 0);
+  assert.ok(retrieved.some(f => f.content.includes('drama_in_blossom_detail')));
+});

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

@@ -0,0 +1,126 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  classifyToolResult,
+  formatDetailDuration,
+  parseDetailsRequest,
+  serializeDetailValue,
+  summarizeQueryDetails,
+  getCopyableContent,
+  copyToClipboard,
+  formatQueryDetails,
+} from '../queryDetails.js';
+
+test('details request supports latest, query, view, markdown, and raw tool selection', () => {
+  assert.deepEqual(parseDetailsRequest(''), {
+    error: null, queryNumber: null, view: 'answer', toolIndex: null,
+  });
+  assert.deepEqual(parseDetailsRequest('Q12 tools'), {
+    error: null, queryNumber: 12, view: 'tools', toolIndex: null,
+  });
+  assert.deepEqual(parseDetailsRequest('latest thinking'), {
+    error: null, queryNumber: null, view: 'thinking', toolIndex: null,
+  });
+  assert.deepEqual(parseDetailsRequest('3 tool 2'), {
+    error: null, queryNumber: 3, view: 'tool', toolIndex: 2,
+  });
+  assert.deepEqual(parseDetailsRequest('Q1 all'), {
+    error: null, queryNumber: 1, view: 'all', toolIndex: null,
+  });
+  assert.deepEqual(parseDetailsRequest('Q2 markdown'), {
+    error: null, queryNumber: 2, view: 'markdown', toolIndex: null,
+  });
+  assert.match(parseDetailsRequest('tool').error, /positive tool number/);
+  assert.match(parseDetailsRequest('Q1 unknown').error, /Unknown details view/);
+});
+
+test('query details summary separates successful, empty, and failed tools', () => {
+  const details = {
+    answer: 'answer',
+    thinking: 'thought',
+    tools: [
+      { duration: 10, result: { status: 'ok', count: 2 } },
+      { duration: 20, result: { status: 'not_found' } },
+      { duration: 30, result: { status: 'error' } },
+    ],
+  };
+
+  assert.deepEqual(summarizeQueryDetails(details), {
+    toolCount: 3,
+    successfulTools: 1,
+    failedTools: 1,
+    emptyTools: 1,
+    toolDurationMs: 60,
+    thinkingCharacters: 7,
+    answerCharacters: 6,
+  });
+  assert.equal(classifyToolResult({ count: 0 }).state, 'not_found');
+});
+
+test('detail formatting is bounded and handles non-serializable values', () => {
+  assert.equal(formatDetailDuration(45), '45ms');
+  assert.equal(formatDetailDuration(1250), '1.25s');
+  assert.equal(serializeDetailValue({ long: 'x'.repeat(100) }, 30).truncated, true);
+  assert.equal(serializeDetailValue({ long: 'x'.repeat(100) }).truncated, false);
+
+  const cyclic = {};
+  cyclic.self = cyclic;
+  assert.equal(serializeDetailValue(cyclic).truncated, false);
+});
+
+test('getCopyableContent extracts untruncated answers, thinking, tools, and markdown', () => {
+  const details = {
+    number: 1,
+    status: 'complete',
+    prompt: 'Who is Ju Jingyi?',
+    answer: 'Ju Jingyi (鞠婧祎) is a famous Chinese singer and actress.',
+    thinking: 'Analyzing profile catalog and works...',
+    tools: [
+      {
+        name: 'get_profile',
+        duration: 15,
+        args: {},
+        result: { status: 'success', nameCn: '鞠婧祎' },
+      },
+    ],
+  };
+
+  const ans = getCopyableContent(details, { view: 'answer' });
+  assert.equal(ans.text, 'Ju Jingyi (鞠婧祎) is a famous Chinese singer and actress.');
+  assert.equal(ans.type, 'answer');
+
+  const think = getCopyableContent(details, { view: 'thinking' });
+  assert.equal(think.text, 'Analyzing profile catalog and works...');
+  assert.equal(think.type, 'thinking');
+
+  const tool1 = getCopyableContent(details, { view: 'tool', toolIndex: 1 });
+  assert.match(tool1.text, /get_profile/);
+  assert.equal(tool1.type, 'tool');
+
+  const md = getCopyableContent(details, { view: 'markdown' });
+  assert.match(md.text, /# Question 1/);
+  assert.match(md.text, /## Thinking/);
+  assert.match(md.text, /## Answer/);
+  assert.equal(md.type, 'markdown');
+});
+
+test('copyToClipboard safely executes cross-platform child process', () => {
+  const result = copyToClipboard('test copy');
+  assert.equal(typeof result, 'boolean');
+});
+
+test('formatQueryDetails formats diagnostics without throwing', () => {
+  const formatted = formatQueryDetails({
+    number: 1,
+    status: 'complete',
+    prompt: 'test prompt',
+    answer: 'test answer',
+    durationMs: 50,
+  });
+  assert.match(formatted, /=== Answer • Q1 ===/);
+  assert.match(formatted, /test answer/);
+
+  assert.equal(formatQueryDetails(null), 'No query diagnostics recorded.');
+});
+

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

@@ -0,0 +1,391 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:http';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { estimateTokens, calculateTokenCost, formatCostUsd, formatTokenCount, MODEL_PRICING } from '../telemetry.js';
+import { getProfile, listProfiles, BUILTIN_PROFILES } from '../profiles.js';
+import { extractCitations, formatCitationsBlock, resolveCitationReference } from '../citations.js';
+import { handleWebChatRequest } from '../../web-chat/router.js';
+import { checkChatRateLimit, applySecurityHeaders, resolveAllowedOrigin, extractApiKey } from '../../web-chat/core/security.js';
+import {
+  getUnifiedProfile,
+  getUnifiedWorks,
+  getUnifiedDiscography,
+  getUnifiedAwards,
+  getUnifiedBrands,
+  getUnifiedTimeline
+} from '../../mcp/dataAdapter.js';
+import { worksData as richWorks } from '../../../src/data/worksData.js';
+import { worksData as mcpWorks } from '../../mcp/data/works.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const rootDir = resolve(__dirname, '../../../');
+const cliPath = resolve(rootDir, 'server/agent/cli.js');
+const mcpPath = resolve(rootDir, 'server/mcp/stdio.js');
+
+
+function runProcessWithTimeout(cmd, args, { input = null, timeoutMs = 10000 } = {}) {
+  return new Promise((resolve) => {
+    const proc = spawn(cmd, args, {
+      cwd: rootDir,
+      env: { ...process.env, NODE_ENV: 'test', NO_COLOR: '1' },
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try { proc.kill('SIGKILL'); } catch {}
+      resolve({
+        code: -1,
+        stdout,
+        stderr,
+        timedOut: true,
+        error: new Error(`Process timed out after ${timeoutMs}ms`)
+      });
+    }, timeoutMs);
+    timer.unref();
+
+    proc.stdout.on('data', d => { stdout += d.toString(); });
+    proc.stderr.on('data', d => { stderr += d.toString(); });
+
+    if (input) {
+      proc.stdin.write(input);
+    }
+    proc.stdin.end();
+
+    proc.on('close', code => {
+      clearTimeout(timer);
+      if (!timedOut) {
+        resolve({ code, stdout, stderr, timedOut: false });
+      }
+    });
+
+    proc.on('error', err => {
+      clearTimeout(timer);
+      resolve({ code: -1, stdout, stderr, timedOut: false, error: err });
+    });
+  });
+}
+
+
+
+test('Phase 1 Real-World: CLI --version exits cleanly in < 1s with exit code 0', async () => {
+
+  const res = await runProcessWithTimeout(process.execPath, [cliPath, '--version'], { timeoutMs: 8000 });
+  assert.equal(res.timedOut, false, 'CLI must not hang on --version');
+  assert.equal(res.code, 0);
+  assert.match(res.stdout.trim(), /^\d+\.\d+\.\d+/);
+});
+
+test('Phase 1 Real-World: CLI --help --plain produces zero ANSI garbage and exits code 0', async () => {
+  const res = await runProcessWithTimeout(process.execPath, [cliPath, '--help', '--plain'], { timeoutMs: 8000 });
+  assert.equal(res.timedOut, false, 'CLI must not hang on --help');
+  assert.equal(res.code, 0);
+
+  assert.equal(/\x1b\[[0-9;]*[a-zA-Z]/.test(res.stdout), false, 'Output must not contain ANSI escape codes in plain mode');
+  assert.ok(res.stdout.includes('CLI Flags & Options'));
+  assert.ok(res.stdout.includes('--profile'));
+  assert.ok(res.stdout.includes('--print'));
+});
+
+test('Phase 1 Real-World: CLI exits with code 3 on unknown flags without crashing', async () => {
+  const res = await runProcessWithTimeout(process.execPath, [cliPath, '--non-existent-flag-xyz'], { timeoutMs: 8000 });
+  assert.equal(res.timedOut, false);
+  assert.equal(res.code, 3);
+  assert.ok(res.stderr.includes('Unknown option') || res.stdout.includes('Unknown option'));
+});
+
+test('Phase 1 Real-World: CLI piped stdin handles EOF gracefully without hanging', async () => {
+  const res = await runProcessWithTimeout(
+    process.execPath,
+    [cliPath, '--url', 'http://127.0.0.1:9999/v1', '--output', 'json'],
+    { input: 'Who is Ju Jingyi?', timeoutMs: 4000 }
+  );
+  assert.equal(res.timedOut, false, 'CLI piped input must not hang');
+  assert.equal(res.code, 2, 'Unreachable server exits code 2');
+
+  const payload = JSON.parse(res.stdout);
+  assert.equal(payload.status, 'error');
+  assert.equal(payload.query, 'Who is Ju Jingyi?');
+  assert.ok(payload.metrics);
+  assert.equal(typeof payload.metrics.costUsd, 'number');
+});
+
+
+
+test('Phase 2 Real-World: Security headers and CORS origins are strictly defended', () => {
+  assert.equal(resolveAllowedOrigin('http://localhost:3000'), 'http://localhost:3000');
+  assert.equal(resolveAllowedOrigin('http://127.0.0.1:3000'), 'http://127.0.0.1:3000');
+  assert.equal(resolveAllowedOrigin('https://jujingyi-kikuuu.vercel.app'), 'https://jujingyi-kikuuu.vercel.app');
+
+  const origEnv = process.env.WEBCHAT_CORS_ORIGINS;
+  try {
+    process.env.WEBCHAT_CORS_ORIGINS = 'https://jujingyi-kikuuu.vercel.app, https://portal.kiku.com';
+    assert.equal(resolveAllowedOrigin('https://malicious-attacker.com'), null);
+    assert.equal(resolveAllowedOrigin('https://portal.kiku.com'), 'https://portal.kiku.com');
+  } finally {
+    if (origEnv !== undefined) process.env.WEBCHAT_CORS_ORIGINS = origEnv;
+    else delete process.env.WEBCHAT_CORS_ORIGINS;
+  }
+
+  const mockHeaders = {};
+  const mockRes = {
+    setHeader: (k, v) => { mockHeaders[k] = v; }
+  };
+  applySecurityHeaders({ headers: { origin: 'http://localhost:3000' } }, mockRes);
+  assert.equal(mockHeaders['X-Content-Type-Options'], 'nosniff');
+  assert.equal(mockHeaders['X-Frame-Options'], 'SAMEORIGIN');
+  assert.equal(mockHeaders['Referrer-Policy'], 'strict-origin-when-cross-origin');
+  assert.equal(mockHeaders['Access-Control-Allow-Origin'], 'http://localhost:3000');
+});
+
+test('Phase 2 Real-World: Rate limiter handles burst traffic and rejects on limit without leaking memory', () => {
+  const testIp = '198.51.100.99';
+  let allowedCount = 0;
+  let rejectedCount = 0;
+
+  for (let i = 0; i < 70; i++) {
+    const check = checkChatRateLimit(testIp);
+    if (check.allowed) allowedCount++;
+    else rejectedCount++;
+  }
+
+  assert.equal(allowedCount, 60, 'Should allow exactly 60 requests per minute');
+  assert.equal(rejectedCount, 10, 'Should reject requests exceeding the 60 threshold');
+});
+
+test('Phase 2 Real-World: Real HTTP server routes /api/status with security headers without errors', async () => {
+  const server = createServer(async (req, res) => {
+    await handleWebChatRequest(req, res);
+  });
+
+  await new Promise(r => server.listen(0, '127.0.0.1', r));
+  const port = server.address().port;
+
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/status`);
+    assert.equal(res.status, 200);
+    assert.equal(res.headers.get('x-content-type-options'), 'nosniff');
+    assert.equal(res.headers.get('x-frame-options'), 'SAMEORIGIN');
+    const data = await res.json();
+    assert.equal(data.status, 'ok');
+    assert.equal(data.server, 'Kiku Web Chatbot');
+    assert.ok(data.capabilities);
+  } finally {
+    server.close();
+  }
+});
+
+
+
+test('Phase 3 Real-World: Token heuristics handle Thai, CJK, English, and null edge cases safely', () => {
+  assert.equal(estimateTokens(''), 0);
+  assert.equal(estimateTokens(null), 0);
+  assert.equal(estimateTokens(undefined), 0);
+
+  const enCount = estimateTokens('Ju Jingyi is a talented Chinese singer and actress.');
+  assert.ok(enCount >= 10 && enCount <= 20);
+
+  const cnCount = estimateTokens('鞠婧祎是中国内地流行乐女歌手、影视演员。');
+  assert.ok(cnCount >= 15 && cnCount <= 35);
+
+  const thCount = estimateTokens('จวีจิ้งอี เป็นนักแสดงและนักร้องชาวจีนที่มีชื่อเสียง');
+  assert.ok(thCount >= 20 && thCount <= 75);
+
+  const mixedCount = estimateTokens('Ju Jingyi (鞠婧祎) แสดงในเรื่อง ตำนานหยุนซี (Legend of Yunxi) 2018');
+  assert.ok(mixedCount > 0 && !Number.isNaN(mixedCount));
+});
+
+test('Phase 3 Real-World: calculateTokenCost produces exact values across providers and local LM Studio', () => {
+  const localCost = calculateTokenCost({ prompt: 5000, completion: 2000, total: 7000 }, 'lmstudio', 'google/gemma-4-e4b');
+  assert.equal(localCost, 0);
+  assert.equal(formatCostUsd(localCost), '$0.00 (Local)');
+
+  const groqCost = calculateTokenCost({ prompt: 1_000_000, completion: 1_000_000, total: 2_000_000 }, 'groq');
+  assert.ok(groqCost > 0);
+
+  const deepseekCost = calculateTokenCost({ prompt: 1_000_000, completion: 1_000_000, total: 2_000_000 }, 'deepseek');
+  assert.ok(deepseekCost > 0);
+
+  assert.equal(formatCostUsd(0.00001), '<$0.0001');
+  assert.equal(formatCostUsd(0.01234), '$0.0123');
+  assert.equal(formatTokenCount(1500), '1,500');
+  assert.equal(formatTokenCount(1200000), '1,200,000');
+});
+
+test('Phase 3 Real-World: All built-in profiles are valid and have required runtime keys', () => {
+  const profiles = listProfiles();
+  assert.ok(profiles.length >= 5);
+
+  for (const p of profiles) {
+    assert.ok(p.id, 'Profile must have an id');
+    assert.ok(p.name, 'Profile must have a human-readable name');
+    assert.ok(p.provider, 'Profile must specify a provider');
+    assert.ok(p.model, 'Profile must specify a model');
+    assert.ok(typeof p.temperature === 'number', 'Profile must have numeric temperature');
+    assert.ok(typeof p.description === 'string', 'Profile must have a description');
+  }
+
+  const geminiProfile = getProfile('gemini');
+  assert.equal(geminiProfile.provider, 'gemini');
+  assert.equal(geminiProfile.model, 'gemini-3.7-flash');
+});
+
+
+test('Phase 4 Real-World: Citations extraction handles realistic multi-turn responses without corruption', () => {
+  const tools = [
+    {
+      name: 'search_works',
+      result: {
+        works: [
+          {
+            id: 'in-blossom',
+            titleTh: 'ฮวาเจียนลิ่ง ในม่านเมฆ (In Blossom)',
+            titleCn: '花间令',
+            titleEn: 'In Blossom',
+            year: 2024,
+            role: 'หยางไฉ่เวย / ซ่างกวนจื่อ',
+            category: 'ซีรีส์สืบสวนโบราณ'
+          },
+          {
+            id: 'veil-of-shadows',
+            titleTh: '月鳞绮纪 (Veil of Shadows)',
+            titleCn: '月鳞绮纪',
+            titleEn: 'Veil of Shadows',
+            year: 2026,
+            role: 'ลู่หวู่อี (Lu Wuyi)',
+            category: 'ซีรีส์แฟนตาซีโบราณ'
+          }
+        ]
+      }
+    }
+  ];
+
+  const answer = 'ผลงานเด่นในปี 2024 คือเรื่อง In Blossom (花间令) รับบทเป็น หยางไฉ่เวย และปี 2026 มีเรื่อง Veil of Shadows';
+  const citations = extractCitations(answer, tools);
+
+  assert.equal(citations.length, 2);
+  assert.equal(citations[0].id, 1);
+  assert.equal(citations[1].id, 2);
+
+
+  const block = formatCitationsBlock(citations, { lang: 'th' });
+  assert.ok(block.includes('📖 แหล่งข้อมูลและหลักฐานอ้างอิง'));
+  assert.ok(block.includes('[1]'));
+  assert.ok(block.includes('[2]'));
+  assert.ok(!block.includes('undefined'));
+  assert.ok(!block.includes('null'));
+});
+
+test('Phase 4 Real-World: resolveCitationReference is immune to crash on edge case queries', () => {
+  const mockCitations = [
+    { id: 1, title: 'ตำนานหยุนซี (芸汐传)', year: 2018 },
+    { id: 2, title: 'ฮวาเจียนลิ่ง ในม่านเมฆ (In Blossom)', year: 2024 }
+  ];
+
+
+  assert.equal(resolveCitationReference('', mockCitations), null);
+  assert.equal(resolveCitationReference('   ', mockCitations), null);
+  assert.equal(resolveCitationReference(null, mockCitations), null);
+  assert.equal(resolveCitationReference('!@#$%^&*()_+', mockCitations), null);
+
+ 
+  const matchBracket = resolveCitationReference('เล่าเนื้อเรื่องของ [2] ให้ฟังหน่อย', mockCitations);
+  assert.equal(matchBracket?.id, 2);
+
+  const matchHash = resolveCitationReference('ขอประวัติตัวละครใน #1', mockCitations);
+  assert.equal(matchHash?.id, 1);
+
+  const matchTitle = resolveCitationReference('หยุนซี ออกอากาศปีไหน', mockCitations);
+  assert.equal(matchTitle?.id, 1);
+
+  const matchEnglishTitle = resolveCitationReference('Tell me more about In Blossom', mockCitations);
+  assert.equal(matchEnglishTitle?.id, 2);
+});
+
+
+test('Phase 5 Real-World: 100% of 18 catalog works match with valid schema and release metadata', () => {
+  assert.equal(richWorks.length, 18, 'Expected exactly 18 works in rich catalog');
+
+  for (const w of richWorks) {
+    assert.ok(w.id, 'Work must have an id');
+    assert.ok(w.titleCn, `Work ${w.id} must have titleCn`);
+    assert.ok(w.titleEn, `Work ${w.id} must have titleEn`);
+    assert.ok(typeof w.year === 'number' && w.year >= 2013 && w.year <= 2026, `Work ${w.id} has invalid year ${w.year}`);
+
+  
+    if (w.themeSong?.youtubeId) {
+      assert.equal(w.themeSong.youtubeId.length, 11, `YouTube ID for ${w.id} theme song should be 11 characters`);
+    }
+
+  
+    const mcpMatch = mcpWorks.find(m => m.id === w.id || m.alias === w.id);
+    assert.ok(mcpMatch, `Work ${w.id} must exist in MCP worksData`);
+    assert.equal(mcpMatch.year, w.year);
+  }
+});
+
+test('Phase 5 Real-World: Unified DataAdapter models are structurally complete', () => {
+  const profile = getUnifiedProfile();
+  assert.equal(profile.nameEn, 'Ju Jingyi');
+  assert.equal(profile.nameCn, '鞠婧祎');
+  assert.ok(profile.bioSummary);
+
+  const works = getUnifiedWorks();
+  assert.equal(works.length, 18);
+
+  const discography = getUnifiedDiscography();
+  assert.ok(discography.length >= 25);
+
+  const ids = new Set();
+  for (const d of discography) {
+    assert.ok(d.id, 'Song must have id');
+    ids.add(d.id);
+  }
+  assert.equal(ids.size, discography.length, 'Unified discography must not have duplicate IDs');
+
+  const awards = getUnifiedAwards();
+  assert.ok(awards.length >= 10);
+
+  const brands = getUnifiedBrands();
+  assert.ok(brands.length >= 10);
+  assert.ok(brands.some(b => b.isGlobal && b.id === 'prsr'));
+  assert.ok(brands.some(b => b.isGlobal && b.id === 'versace'));
+
+  const timeline = getUnifiedTimeline();
+  assert.ok(timeline.length >= 10);
+});
+
+test('Phase 5 Real-World: MCP stdio server initializes properly over child process stdio', async () => {
+
+  const res = await runProcessWithTimeout(
+    process.execPath,
+    [mcpPath],
+    {
+      input: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2024-11-05',
+          capabilities: {},
+          clientInfo: { name: 'real-world-tester', version: '1.0.0' }
+        }
+      }) + '\n',
+      timeoutMs: 4000
+    }
+  );
+
+  assert.equal(res.timedOut, false, 'MCP server must not hang on initialize');
+
+  assert.ok(res.stdout.includes('"jsonrpc":"2.0"'), 'MCP must return valid JSON-RPC');
+  assert.ok(res.stdout.includes('"capabilities"'), 'MCP must advertise capabilities');
+});