kiku-agent 1.3.0 → 1.3.2

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

@@ -0,0 +1,101 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+import serverlessHandler, { isWebChatRequest } from '../../../api/index.js';
+import { getWebChatHtml } from '../../web-chat/ui/htmlBuilder.js';
+
+test('Vercel routes the web chat page through the serverless web-chat handler first', () => {
+  const config = JSON.parse(readFileSync(new URL('../../../vercel.json', import.meta.url), 'utf8'));
+  const chatIndex = config.rewrites.findIndex(rule => rule.source === '/chat');
+  const apiIndex = config.rewrites.findIndex(rule => rule.source === '/api/(.*)');
+  const spaIndex = config.rewrites.findIndex(rule => rule.source === '/(.*)');
+
+  assert.ok(chatIndex >= 0);
+  assert.equal(config.rewrites[chatIndex].destination, '/api/index.js');
+  assert.ok(chatIndex < apiIndex);
+  assert.ok(apiIndex < spaIndex);
+});
+
+test('serverless dispatcher separates web-chat APIs from REST API v1', () => {
+  [
+    '/chat',
+    '/chat/session',
+    '/api/chat',
+    '/api/status',
+    '/api/suggestions',
+    '/api/ai-suggest',
+    '/api/quiz',
+    '/api/export',
+    '/api/verify',
+    '/api/news',
+    '/api/compare',
+    '/api/clarify',
+    '/api/clarify/analytics',
+    '/api/feedback',
+    '/api/feedback/stats'
+  ].forEach(url => assert.equal(isWebChatRequest({ url }), true, url));
+
+  assert.equal(isWebChatRequest({ url: '/api/v1/timeline' }), false);
+  assert.equal(isWebChatRequest({ url: '/api/v1/profile' }), false);
+});
+
+test('serverless dispatcher renders the Agent Chat page for /chat routes', async () => {
+  const response = {
+    headers: {},
+    statusCode: 0,
+    body: '',
+    setHeader(name, value) { this.headers[name] = value; },
+    writeHead(statusCode, headers = {}) {
+      this.statusCode = statusCode;
+      Object.assign(this.headers, headers);
+    },
+    end(body = '') { this.body += body; }
+  };
+
+  await serverlessHandler({ url: '/chat', method: 'GET' }, response);
+
+  assert.equal(response.statusCode, 200);
+  assert.match(response.headers['Content-Type'], /text\/html/);
+  assert.match(response.body, /id="app-sidebar"/);
+  assert.match(response.body, /KIKU AGENT/);
+});
+
+test('sidebar language refresh preserves dynamic control state labels', () => {
+  const html = getWebChatHtml();
+  const start = html.indexOf('function updateLanguageUi()');
+  const end = html.indexOf('var JU_JINGYI_PLAYLIST', start);
+  const languageFunction = html.slice(start, end);
+
+  const genericLabels = languageFunction.indexOf('updateSidebarLabels(t);');
+  assert.ok(genericLabels >= 0);
+  assert.ok(genericLabels < languageFunction.indexOf('updatePetalsLabel();'));
+  assert.ok(genericLabels < languageFunction.indexOf('updateThemeIcon();'));
+  assert.ok(genericLabels < languageFunction.indexOf('updateSoundIcon();'));
+  assert.ok(genericLabels < languageFunction.indexOf("document.getElementById('sidebar-lang-label')"));
+});
+
+test('jukebox derives sidebar and tab counts from the playlist', () => {
+  const html = getWebChatHtml();
+
+  assert.match(html, /function updateJukeboxCountLabels\(\)/);
+  assert.match(html, /const total = JU_JINGYI_PLAYLIST\.length/);
+  assert.match(html, /id="sidebar-music-button"/);
+  assert.doesNotMatch(html, /Jukebox \(44 บทเพลง\)/);
+  assert.doesNotMatch(html, /ทั้งหมด \(44\)/);
+});
+
+test('sidebar export downloads through the export API and reports failures', () => {
+  const html = getWebChatHtml();
+  const start = html.indexOf('async function exportChat()');
+  const end = html.indexOf('function shareChatLink()', start);
+  const exportFunction = html.slice(start, end);
+
+  assert.ok(start >= 0);
+  assert.match(exportFunction, /fetch\('\/api\/export'/);
+  assert.match(exportFunction, /if \(!response\.ok\) throw new Error/);
+  assert.match(exportFunction, /link\.download = filename/);
+  assert.doesNotMatch(exportFunction, /showToast/);
+  assert.doesNotMatch(exportFunction, /navigator\.clipboard/);
+  assert.match(html, /title="ส่งออกบทสนทนาเป็นไฟล์ Markdown"/);
+  assert.doesNotMatch(html, /Export \/ Copy Chat/);
+});

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

@@ -0,0 +1,270 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import os from 'node:os';
+import path from 'node:path';
+import { mkdtemp, rm } from 'node:fs/promises';
+
+import { HierarchicalStore, parseAndValidatePath, computeContentHash } from '../memory/hierarchicalStore.js';
+import { ContextAllocator } from '../memory/contextAllocator.js';
+import { ReflectionWorker } from '../memory/reflectionWorker.js';
+import { AgentMemory } from '../memory.js';
+import { executeTool } from '../tools.js';
+
+test('parseAndValidatePath correctly parses valid hierarchical memory paths', () => {
+  const p1 = parseAndValidatePath('kiku/runs/run_task_001/state');
+  assert.equal(p1.section, 'runs');
+  assert.equal(p1.runId, 'run_task_001');
+  assert.equal(p1.subpath, 'state');
+
+  const p2 = parseAndValidatePath('kiku/runs/run_task_001/plan');
+  assert.equal(p2.subpath, 'plan');
+
+  const p3 = parseAndValidatePath('kiku/runs/run_task_001/artifacts');
+  assert.equal(p3.subpath, 'artifacts');
+
+  const p4 = parseAndValidatePath('kiku/reflections/web_search');
+  assert.equal(p4.section, 'reflections');
+  assert.equal(p4.domain, 'web_search');
+
+  const p5 = parseAndValidatePath('kiku/guidelines/drama');
+  assert.equal(p5.section, 'guidelines');
+  assert.equal(p5.domain, 'drama');
+
+  const p6 = parseAndValidatePath('kiku/archive/run_task_001');
+  assert.equal(p6.section, 'archive');
+  assert.equal(p6.runId, 'run_task_001');
+});
+
+test('parseAndValidatePath rejects invalid paths, traversal, and invalid IDs', () => {
+  assert.throws(() => parseAndValidatePath('../kiku/runs/run_1/state'), /Invalid path traversal/);
+  assert.throws(() => parseAndValidatePath('invalid/runs/run_1/state'), /Path must start with "kiku\/"/);
+  assert.throws(() => parseAndValidatePath('kiku/unknown/section'), /Unrecognized memory section/);
+  assert.throws(() => parseAndValidatePath('kiku/runs/!bad@id/state'), /Invalid run_id/);
+  assert.throws(() => parseAndValidatePath('kiku/runs/run_1/bad_subpath'), /Invalid run subpath/);
+});
+
+test('HierarchicalStore enforces Pointer-Over-Data Rule (>1000 characters)', async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-hstore-'));
+  try {
+    const store = new HierarchicalStore({
+      baseDir: path.join(tempDir, 'nodes'),
+      artifactsDir: path.join(tempDir, 'artifacts')
+    });
+
+  
+    const smallText = 'Hello Kiku memory engine';
+    const smallRes = await store.setNode('kiku/guidelines/small', smallText);
+    assert.equal(smallRes.node.content, smallText);
+    const largePayload = 'A'.repeat(2500);
+    const largeRes = await store.setNode('kiku/runs/run_pointer_test/state', {
+      rawLog: largePayload,
+      step: 'step1'
+    });
+
+    assert.equal(largeRes.node.content.$type, 'pointer');
+    assert.ok(largeRes.node.content.uri.startsWith('file://'));
+    assert.equal(largeRes.node.content.charCount > 2500, true);
+
+ 
+    const resolved = await store.resolvePointer(largeRes.node.content);
+    assert.equal(resolved.step, 'step1');
+    assert.equal(resolved.rawLog, largePayload);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('HierarchicalStore enforces Run-ID Scoping & Path Isolation', async () => {
+  const store = new HierarchicalStore({ persistence: false });
+  await store.setNode('kiku/runs/run_alpha/state', { status: 'IN_PROGRESS' }, { scopedRunId: 'run_alpha' });
+
+
+  await assert.rejects(
+    async () => store.setNode('kiku/runs/run_beta/state', { status: 'ATTACK' }, { scopedRunId: 'run_alpha' }),
+    /Run scoping violation/
+  );
+});
+
+test('HierarchicalStore enforces Idempotency with content hashing', async () => {
+  const store = new HierarchicalStore({ persistence: false });
+  const content = { status: 'IN_PROGRESS', step: 'search_works' };
+
+  const first = await store.setNode('kiku/runs/run_idem/state', content);
+  assert.equal(first.status, 'saved');
+
+ 
+  const second = await store.setNode('kiku/runs/run_idem/state', content);
+  assert.equal(second.status, 'unchanged');
+  assert.equal(first.contentHash, second.contentHash);
+});
+
+test('Real-time Checkpointing: checkpointStep and recordFailure', async () => {
+  const store = new HierarchicalStore({ persistence: false });
+
+  const cp1 = await store.checkpointStep({
+    runId: 'run_cp_test',
+    stepName: 'analyze_query',
+    status: 'completed',
+    summary: 'Analyzed user query successfully'
+  });
+  assert.equal(cp1.status, 'completed');
+  assert.equal(cp1.currentStep, 'analyze_query');
+
+  const cp2 = await store.checkpointStep({
+    runId: 'run_cp_test',
+    stepName: 'query_catalog',
+    status: 'in_progress',
+    summary: 'Querying catalog works for Ju Jingyi'
+  });
+  assert.equal(cp2.currentStep, 'query_catalog');
+  assert.equal(cp2.totalSubtasks, 2);
+
+
+  const failRes = await store.recordFailure({
+    runId: 'run_cp_test',
+    errorTrace: 'HTTP 429 Rate limited on endpoint',
+    recoveryAction: 'Fallback to local catalog tools',
+    toolName: 'web_search'
+  });
+  assert.equal(failRes.status, 'recorded');
+
+ 
+  const hydrated = await store.loadActiveRun('run_cp_test');
+  assert.equal(hydrated.exists, true);
+  assert.equal(hydrated.state.currentStep, 'query_catalog');
+  assert.equal(hydrated.plan.subtasks.length, 2);
+  assert.equal(hydrated.state.failures.length, 1);
+  assert.equal(hydrated.state.failures[0].toolName, 'web_search');
+});
+
+test('Post-Run Compaction Worker: Summarization, Reflection Extraction, Archival & TTL', async () => {
+  const store = new HierarchicalStore({ persistence: false });
+  const worker = new ReflectionWorker({ store, ttlDays: 3 });
+
+  const runId = 'run_worker_test';
+  await store.checkpointStep({
+    runId,
+    stepName: 'fetch_data',
+    status: 'completed',
+    summary: 'Fetched video information'
+  });
+
+  await store.recordFailure({
+    runId,
+    errorTrace: 'Connection timeout after 30s',
+    recoveryAction: 'Switched to bilibili mirror search',
+    toolName: 'search_youtube'
+  });
+
+ 
+  const result = await worker.processPostRunCompaction(runId, 'COMPLETED');
+  assert.equal(result.success, true);
+  assert.equal(result.finalStatus, 'COMPLETED');
+  assert.equal(result.executiveSummary.completedSteps, 1);
+  assert.equal(result.reflectionsExtracted, 1);
+
+
+  const reflection = await store.getNode('kiku/reflections/search_youtube');
+  assert.ok(reflection);
+  assert.equal(reflection.content.recoveryAction, 'Switched to bilibili mirror search');
+  assert.equal(reflection.content.occurrences, 1);
+
+ 
+  const activeCheck = await store.loadActiveRun(runId);
+  assert.equal(activeCheck.exists, false);
+
+  const archiveNode = await store.getNode(`kiku/archive/${runId}`);
+  assert.ok(archiveNode);
+  const resolvedArchive = await store.resolvePointer(archiveNode.content);
+  assert.equal(resolvedArchive.runId, runId);
+  assert.ok(resolvedArchive.expiresAt);
+});
+
+test('ContextAllocator implements 4-Tier Quota and Context Hydration', async () => {
+  const store = new HierarchicalStore({ persistence: false });
+  const memory = new AgentMemory({ persistence: false });
+
+ 
+  await store.setNode('kiku/guidelines/drama', 'Always verify broadcast year with get_work_detail before stating.');
+  memory.addUserSkill('ตอบคำถามสั้น กระชับ ชัดเจน');
+
+ 
+  const runId = 'run_context_alloc_test';
+  await store.checkpointStep({
+    runId,
+    stepName: 'verify_year',
+    status: 'in_progress',
+    summary: 'Checking year for The Legend of White Snake'
+  });
+
+  
+  await store.setNode('kiku/reflections/search_works', {
+    domain: 'search_works',
+    issuePattern: 'Generic title search matches too many items',
+    recoveryAction: 'Include artist name Ju Jingyi to narrow results',
+    confidence: 1.2
+  });
+
+ 
+  memory.addFact('鞠婧祎 played Bai Suzhen in The Legend of White Snake (2019)');
+
+  const allocator = new ContextAllocator({ store, maxTokens: 1500 });
+  const context = await allocator.allocateContext({
+    currentQuery: 'search works White Snake',
+    activeRunId: runId,
+    memory
+  });
+
+  assert.match(context, /=== STATEFUL & SELF-REFLECTIVE MEMORY CONTEXT ===/);
+  assert.match(context, /USER GUIDELINES & PREFERENCES/);
+  assert.match(context, /Always verify broadcast year/);
+  assert.match(context, /ACTIVE TASK RUN STATE/);
+  assert.match(context, /verify_year/);
+  assert.match(context, /EPISODIC REFLECTIONS & GOTCHAS/);
+  assert.match(context, /Generic title search/);
+  assert.match(context, /GENERAL KNOWLEDGE & CONTEXT/);
+});
+
+test('Agent Tools: checkpoint_step, record_failure, and load_active_run work via executeTool', async () => {
+  const memory = new AgentMemory({ persistence: false });
+  const runId = 'run_tool_exec_test';
+
+ 
+  const cpRes = await executeTool('checkpoint_step', {
+    run_id: runId,
+    step_name: 'parse_input',
+    status: 'completed',
+    summary: 'Input arguments verified'
+  }, { memory });
+  assert.equal(cpRes.status, 'success');
+  assert.equal(cpRes.checkpoint.currentStep, 'parse_input');
+
+ 
+  const failRes = await executeTool('record_failure', {
+    run_id: runId,
+    error_trace: 'ETIMEDOUT on remote host',
+    recovery_action: 'Switched to cache fallback',
+    tool_name: 'fetch_webpage'
+  }, { memory });
+  assert.equal(failRes.status, 'success');
+
+
+  const loadRes = await executeTool('load_active_run', {
+    run_id: runId
+  }, { memory });
+  assert.equal(loadRes.status, 'success');
+  assert.equal(loadRes.run.state.currentStep, 'parse_input');
+  assert.equal(loadRes.run.state.failures.length, 1);
+});
+
+test('AgentMemory backward compatibility: legacy methods and facts remain unaffected', () => {
+  const memory = new AgentMemory({ persistence: false });
+  memory.addFact('Test fact about Ju Jingyi', { category: 'music' });
+  const facts = memory.getRelevantFacts('music');
+  assert.equal(facts.length, 1);
+  assert.equal(facts[0].content, 'Test fact about Ju Jingyi');
+
+  const legacyContext = memory.buildMemoryContext('music');
+  assert.match(legacyContext, /=== LONG-TERM MEMORY CONTEXT ===/);
+  assert.match(legacyContext, /Test fact about Ju Jingyi/);
+});

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

@@ -0,0 +1,216 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { ResearchSubagent } from '../subagent.js';
+import { AgentMemory } from '../memory.js';
+import { ResearchOrchestrator, uniqueUrls, cleanUrl, resolveTruncatedUrl, expandTruncatedUrlsInText } from '../research.js';
+
+test('research subagent executes only an allowed validated tool and returns evidence', async () => {
+  const responses = [
+    {
+      role: 'assistant',
+      content: '',
+      tool_calls: [{ id: 'call_1', function: { name: 'search_works', arguments: '{"query":"千香"}' } }],
+    },
+    { role: 'assistant', content: '千香 is listed in the verified Kiku catalog.' },
+  ];
+  const executed = [];
+  const client = { async chat() { return responses.shift(); } };
+  const subagent = new ResearchSubagent({
+    client,
+    allowedTools: ['search_works'],
+    executeTool: async (name, args) => {
+      executed.push({ name, args });
+      return { status: 'ok', works: [{ titleCn: '千香' }] };
+    },
+  });
+
+  const result = await subagent.run('Verify Ju Jingyi project 千香');
+  assert.deepEqual(executed, [{ name: 'search_works', args: { query: '千香' } }]);
+  assert.equal(result.toolCalls.length, 1);
+  assert.match(result.answer, /千香/);
+});
+
+test('research subagent denies tools outside its capability set', async () => {
+  let executed = false;
+  const client = {
+    calls: 0,
+    async chat() {
+      this.calls += 1;
+      if (this.calls === 1) {
+        return { role: 'assistant', tool_calls: [{ id: 'bad', function: { name: 'read_local_file', arguments: '{"path":".env"}' } }] };
+      }
+      return { role: 'assistant', content: 'The request was denied.' };
+    },
+  };
+  const subagent = new ResearchSubagent({
+    client,
+    allowedTools: ['search_works'],
+    executeTool: async () => { executed = true; },
+  });
+
+  const result = await subagent.run('Read secrets');
+  assert.equal(executed, false);
+  assert.match(result.answer, /denied/i);
+});
+
+test('user-taught skills are deduplicated and included in memory context', () => {
+  const memory = new AgentMemory();
+  memory.save = async () => true;
+  const first = memory.addUserSkill('ตอบภาษาไทยแบบสั้น กระชับ');
+  const duplicate = memory.addUserSkill('ตอบภาษาไทยแบบสั้น กระชับ');
+
+  assert.equal(first.id, duplicate.id);
+  assert.equal(memory.preferences.userSkills.length, 1);
+  assert.match(memory.buildMemoryContext(), /ตอบภาษาไทยแบบสั้น กระชับ/);
+
+  memory.setPreference('skillsEnabled', false);
+  assert.equal(memory.buildUserSkillContext(), '');
+});
+
+test('research orchestrator runs bounded workers concurrently and deduplicates sources', async () => {
+  const client = {
+    async chat({ messages }) {
+      if (messages[0].content.includes('Kiku research editor')) {
+        return { role: 'assistant', content: 'Synthesized verified answer https://example.com/official' };
+      }
+      const objective = messages[1].content;
+      if (objective.includes('local Kiku catalog')) {
+        return { role: 'assistant', content: 'Catalog evidence for 千香.' };
+      }
+      if (objective.includes('primary or authoritative')) {
+        return { role: 'assistant', content: 'Official source https://example.com/official' };
+      }
+      return { role: 'assistant', content: 'Corroborated at https://example.com/official and https://example.org/second.' };
+    },
+  };
+  const orchestrator = new ResearchOrchestrator({ client });
+  const progress = [];
+  const result = await orchestrator.run('ข้อมูล 千香', { onProgress: event => progress.push(event.type) });
+
+  assert.equal(result.reports.length, 3);
+  assert.deepEqual(result.sources, ['https://example.com/official', 'https://example.org/second']);
+  assert.match(result.answer, /Synthesized/);
+  assert.equal(orchestrator.getStatus().state, 'idle');
+  assert.ok(progress.includes('worker-start'));
+  assert.ok(progress.includes('complete'));
+});
+
+test('research orchestrator verification mode requests an explicit verdict', async () => {
+  let synthesisSystem = '';
+  const client = {
+    async chat({ messages }) {
+      if (messages[0].content.includes('Kiku research editor')) {
+        synthesisSystem = messages[0].content;
+        return { role: 'assistant', content: 'UNVERIFIED — no primary announcement.' };
+      }
+      return { role: 'assistant', content: 'No confirming source was found.' };
+    },
+  };
+  const result = await new ResearchOrchestrator({ client }).run('ข่าวลือนี้จริงไหม', { mode: 'verify' });
+  assert.match(synthesisSystem, /VERIFIED, UNVERIFIED, CONFLICTING, or FALSE/);
+  assert.match(result.answer, /UNVERIFIED/);
+});
+
+test('research orchestrator shares identical tool results between workers', async () => {
+  let executions = 0;
+  const client = {
+    async chat({ messages }) {
+      if (messages[0].content.includes('Kiku research editor')) return { role: 'assistant', content: 'Combined answer.' };
+      if (messages.length === 2 && !messages[1].content.includes('primary or authoritative')) {
+        return {
+          role: 'assistant',
+          tool_calls: [{ id: `call_${Math.random()}`, function: { name: 'global_search', arguments: '{"query":"千香"}' } }],
+        };
+      }
+      return { role: 'assistant', content: 'Evidence collected.' };
+    },
+  };
+  const orchestrator = new ResearchOrchestrator({
+    client,
+    executeTool: async () => {
+      executions += 1;
+      return { status: 'ok', results: [] };
+    },
+  });
+
+  await orchestrator.run('千香');
+  assert.equal(executions, 1);
+});
+
+test('research orchestrator cleans backticks, resolves truncated URLs, and expands in text', () => {
+  const knownUrls = [
+    'https://wetv.vip/en/play/q0034a7434d/z0034f7158a-Lai_Zhan%3A_The_Love-Hate_Entanglement.html',
+    'https://mydramalist.com/790246-lai-zhan',
+    'https://www.newsbreak.com/news/4155481784345-lai-zhan-official-release',
+    'https://www.facebook.com/groups/1983148261871766/posts/1174442684836506/',
+  ];
+
+  assert.equal(cleanUrl('`https://mydramalist.com/790246-lai-zhan`'), 'https://mydramalist.com/790246-lai-zhan');
+  assert.equal(cleanUrl('"https://mydramalist.com/790246-lai-zhan",'), 'https://mydramalist.com/790246-lai-zhan');
+
+  const truncatedWeTV = 'https://wetv.vip/en/play/...Lai_Zhan%3A_The_Love-Hate...';
+  const resolvedWeTV = resolveTruncatedUrl(truncatedWeTV, knownUrls);
+  assert.equal(resolvedWeTV, 'https://wetv.vip/en/play/q0034a7434d/z0034f7158a-Lai_Zhan%3A_The_Love-Hate_Entanglement.html');
+
+  const truncatedFB = 'https://www.facebook.com/groups/1983148261871766/posts/...';
+  const resolvedFB = resolveTruncatedUrl(truncatedFB, knownUrls);
+  assert.equal(resolvedFB, 'https://www.facebook.com/groups/1983148261871766/posts/1174442684836506/');
+
+  const truncatedNews = 'https://www.newsbreak.com/news/4155481784345-lai-zhan...';
+  const resolvedNews = resolveTruncatedUrl(truncatedNews, knownUrls);
+  assert.equal(resolvedNews, 'https://www.newsbreak.com/news/4155481784345-lai-zhan-official-release');
+
+  const markdownTable = [
+    '| Source | URL | Notes |',
+    '| --- | --- | --- |',
+    '| WeTV | https://wetv.vip/en/play/...Lai_Zhan%3A_The_Love-Hate... | Official stream |',
+    '| FB | https://www.facebook.com/groups/1983148261871766/posts/... | Updates |',
+    '| News | https://www.newsbreak.com/news/4155481784345-lai-zhan... | Article |',
+  ].join('\n');
+  const expanded = expandTruncatedUrlsInText(markdownTable, knownUrls);
+  assert.ok(expanded.includes('https://wetv.vip/en/play/q0034a7434d/z0034f7158a-Lai_Zhan%3A_The_Love-Hate_Entanglement.html'));
+  assert.ok(expanded.includes('https://www.facebook.com/groups/1983148261871766/posts/1174442684836506/'));
+  assert.ok(expanded.includes('https://www.newsbreak.com/news/4155481784345-lai-zhan-official-release'));
+  assert.equal(expanded.includes('...'), false, 'All truncated URLs in table must be expanded');
+
+  const sampleReport = `
+    Check out \`https://mydramalist.com/790246-lai-zhan\`
+    Also see https://wetv.vip/en/play/...Lai_Zhan%3A_The_Love-Hate...
+    Unresolvable source: https://unknown-domain.com/path/.../something
+  `;
+  const urls = uniqueUrls(sampleReport, knownUrls);
+  assert.ok(urls.includes('https://mydramalist.com/790246-lai-zhan'));
+  assert.ok(urls.includes('https://wetv.vip/en/play/q0034a7434d/z0034f7158a-Lai_Zhan%3A_The_Love-Hate_Entanglement.html'));
+  assert.equal(urls.some(u => u.endsWith('`')), false, 'No URL should end with a backtick');
+  assert.equal(urls.some(u => u.includes('...')), false, 'No URL in validated sources should contain ellipsis');
+});
+
+test('research orchestrator degrades gracefully when a worker times out', async () => {
+  const client = {
+    async chat({ messages, signal }) {
+      if (messages[0].content.includes('Kiku research editor')) {
+        return { role: 'assistant', content: 'Synthesized report based on available catalog evidence.' };
+      }
+      const objective = messages[1].content;
+      if (objective.includes('primary or authoritative') || objective.includes('web sources')) {
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => resolve({ role: 'assistant', content: 'late' }), 10000);
+          signal?.addEventListener('abort', () => {
+            clearTimeout(timeout);
+            reject(new DOMException('Aborted', 'AbortError'));
+          });
+        });
+      }
+      return { role: 'assistant', content: 'Catalog details for Lai Zhan 2026.' };
+    },
+  };
+
+  const orchestrator = new ResearchOrchestrator({ client });
+  const result = await orchestrator.run('Lai Zhan news', { workerTimeoutMs: 100 });
+  assert.ok(result.answer.includes('Synthesized report'));
+  const webWorker = result.reports.find(r => r.id === 'web');
+  assert.equal(webWorker.error ? true : false, true);
+  assert.equal(orchestrator.getStatus().state, 'idle');
+});
+