kiku-agent 1.3.1 → 1.3.3

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

@@ -0,0 +1,133 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  getGraphemeSegments,
+  getStringDisplayWidth,
+  getNewOutputScrollOffset,
+  fitStyledText,
+  getWelcomeHeroLines,
+  getTuiViewportLayout,
+  getMultilinePromptLayout,
+  nextGraphemeBoundary,
+  previousGraphemeBoundary,
+  sanitizeTerminalText,
+  sliceLineForDisplay,
+} from '../ui.js';
+
+test('TUI viewport never overlaps the status bar', () => {
+  for (const rows of [10, 24, 30, 60]) {
+    const layout = getTuiViewportLayout(rows);
+    const viewportLastRow = layout.viewportStartRow + layout.viewportHeight - 1;
+
+    assert.equal(viewportLastRow, layout.statusBarRow - 1);
+    assert.ok(viewportLastRow < layout.statusBarRow);
+    assert.ok(layout.statusBarRow < layout.promptRow);
+    assert.ok(layout.promptRow < layout.separatorRow);
+  }
+});
+
+test('long output opens at its first page and preserves manual scroll position', () => {
+  const viewportHeight = getTuiViewportLayout(24).viewportHeight;
+  assert.equal(getNewOutputScrollOffset(viewportHeight - 1, 24, 0), 0);
+  assert.equal(getNewOutputScrollOffset(viewportHeight + 7, 24, 0), 7);
+  assert.equal(getNewOutputScrollOffset(5, 24, 9), 14);
+});
+
+test('welcome hero keeps the logo without the removed marketing copy', () => {
+  const hero = getWelcomeHeroLines().join('\n');
+
+  assert.match(hero, /██╗/);
+  assert.doesNotMatch(hero, /Kiku AI Terminal Agent/);
+  assert.doesNotMatch(hero, /Intelligent Fan Portal/);
+  assert.doesNotMatch(hero, /SSOT • DAG • Dynamic Tools/);
+  assert.doesNotMatch(hero, /LM Studio \/ Cloud Providers/);
+});
+
+test('grapheme boundaries keep emoji and Thai combining marks intact', () => {
+  const value = 'A👩🏽‍💻ก้B';
+  const segments = getGraphemeSegments(value);
+
+  assert.deepEqual(segments.map(item => item.segment), ['A', '👩🏽‍💻', 'ก้', 'B']);
+  assert.equal(nextGraphemeBoundary(value, 1), 8);
+  assert.equal(previousGraphemeBoundary(value, 8), 1);
+  assert.equal(nextGraphemeBoundary(value, 8), 10);
+  assert.equal(previousGraphemeBoundary(value, 10), 8);
+});
+
+test('untrusted terminal text cannot inject ANSI, OSC, or control sequences', () => {
+  const malicious = '\x1b[31mred\x1b[0m\x1b]0;owned\x07\nnext\titem';
+  const sanitized = sanitizeTerminalText(malicious);
+  assert.equal(sanitized, 'red next item');
+  assert.equal(sanitized.includes('\x1b'), false);
+  assert.equal(sanitized.includes('\x07'), false);
+});
+
+test('gray surface rows fit narrow terminals without breaking styled graphemes', () => {
+  const fitted = fitStyledText('\x1b[1mคำสั่ง 👩🏽‍💻 autocomplete\x1b[0m', 10);
+
+  assert.ok(getStringDisplayWidth(fitted) <= 10);
+  assert.ok(!fitted.includes('👩') || fitted.includes('👩🏽‍💻'));
+});
+
+test('display width treats joined emoji and Thai marks as terminal graphemes', () => {
+  assert.equal(getStringDisplayWidth('👩🏽‍💻'), 2);
+  assert.equal(getStringDisplayWidth('ก้'), 1);
+  assert.equal(getStringDisplayWidth('你好'), 4);
+  assert.equal(getStringDisplayWidth('《鞠婧祎》'), 10);
+  assert.equal(getStringDisplayWidth('（年度最佳）'), 12);
+  assert.equal(getStringDisplayWidth('【花间令】'), 10);
+});
+
+test('long-line viewport stays within width without splitting graphemes', () => {
+  const value = 'aaaaa👩🏽‍💻ก้bbbbbbbbbbbb';
+  const cursor = value.indexOf('ก');
+  const viewport = sliceLineForDisplay(value, cursor, 10);
+
+  assert.ok(getStringDisplayWidth(viewport.displayLine) <= 10);
+  assert.ok(!viewport.displayLine.includes('👩') || viewport.displayLine.includes('👩🏽‍💻'));
+  assert.ok(!viewport.displayLine.startsWith('้'));
+  assert.ok(viewport.cursorVisualOffset >= 0);
+  assert.ok(viewport.cursorVisualOffset <= 10);
+});
+
+test('getMultilinePromptLayout wraps long text and positions cursor accurately', () => {
+  const single = getMultilinePromptLayout('hello world', 5, 20, 5);
+  assert.equal(single.visibleLines.length, 1);
+  assert.equal(single.visibleLines[0], 'hello world');
+  assert.equal(single.cursorRow, 0);
+  assert.equal(single.cursorCol, 5);
+
+  const multi = getMultilinePromptLayout('line 1\nline 2\nline 3', 10, 20, 5);
+  assert.equal(multi.visibleLines.length, 3);
+  assert.equal(multi.visibleLines[0], 'line 1');
+  assert.equal(multi.visibleLines[1], 'line 2');
+  assert.equal(multi.visibleLines[2], 'line 3');
+  assert.equal(multi.cursorRow, 1);
+  assert.equal(multi.cursorCol, 3);
+
+  const longText = 'Ju Jingyi 👩🏽‍💻 ก้ ' + 'a'.repeat(50);
+  const wrapped = getMultilinePromptLayout(longText, longText.length, 25, 4);
+  assert.ok(wrapped.visibleLines.length > 1);
+  assert.ok(wrapped.visibleLines.length <= 4);
+  for (const line of wrapped.visibleLines) {
+    assert.ok(getStringDisplayWidth(line) <= 25);
+  }
+  assert.ok(wrapped.cursorRow >= 0 && wrapped.cursorRow < wrapped.visibleLines.length);
+  assert.ok(wrapped.cursorCol >= 0 && wrapped.cursorCol <= 25);
+});
+
+test('getTuiViewportLayout dynamically expands prompt rows without overlapping', () => {
+  for (const promptRows of [1, 2, 3, 5]) {
+    const layout = getTuiViewportLayout(24, promptRows);
+    const viewportLastRow = layout.viewportStartRow + layout.viewportHeight - 1;
+
+    assert.equal(viewportLastRow, layout.statusBarRow - 1);
+    assert.ok(viewportLastRow < layout.statusBarRow);
+    assert.ok(layout.statusBarRow < layout.promptStartRow);
+    assert.equal(layout.promptHeight, promptRows);
+    assert.equal(layout.promptRow, layout.promptStartRow);
+    assert.ok(layout.promptEndRow < 24);
+  }
+});
+

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

@@ -0,0 +1,197 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import os from 'node:os';
+import { mkdtemp, rm } from 'node:fs/promises';
+
+import { KikuAgent } from '../agentCore.js';
+import { McpClientManager } from '../mcpClient.js';
+
+function createMemoryStub() {
+  return {
+    _loaded: true,
+    facts: [],
+    async load() { },
+    trackTopicInterest() { },
+    buildMemoryContext() { return ''; },
+    buildUserSkillContext() { return ''; },
+    addFact() { },
+  };
+}
+
+test('text-emitted tool calls synthesize protocol-valid tool_calls in history', async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-textproto-'));
+  const storageFile = path.join(tempDir, 'session.json');
+  const observedMessages = [];
+  let call = 0;
+  const client = {
+    provider: 'lmstudio',
+    providerName: 'LM Studio',
+    model: 'test-model',
+    async chat(options) {
+      call++;
+      observedMessages.push(options.messages.map(message => ({
+        role: message.role,
+        content: typeof message.content === 'string' ? message.content : null,
+        tool_calls: message.tool_calls || undefined,
+        tool_call_id: message.tool_call_id || undefined,
+      })));
+      if (call === 1) {
+        return {
+          role: 'assistant',
+          content: 'Checking the catalog.\n```json\n{"action": "get_quotes", "parameters": {"tag": "mindset"}}\n```',
+        };
+      }
+      return { role: 'assistant', content: 'คำคมที่ยืนยันแล้วจากคลังข้อมูลคือ...' };
+    },
+  };
+
+  const agent = new KikuAgent({
+    client,
+    memory: createMemoryStub(),
+    mcpManager: new McpClientManager({
+      autoLoad: false,
+      globalConfigPath: path.join(tempDir, 'mcp.json'),
+    }),
+    sessionId: 'textproto_test',
+    sessionStorageFile: storageFile,
+  });
+
+  try {
+    await agent.ready();
+    const answer = await agent.run('ขอคำคมของจวีจิ้งอีหน่อย');
+
+    assert.match(answer, /คำคมที่ยืนยันแล้ว/);
+
+   
+    const secondCall = observedMessages[1];
+    const assistantWithCalls = secondCall.find(m => m.role === 'assistant' && m.tool_calls?.length > 0);
+    assert.ok(assistantWithCalls, 'assistant message with synthesized tool_calls missing');
+    assert.equal(assistantWithCalls.tool_calls[0].function.name, 'get_quotes');
+
+    const toolMessage = secondCall.find(m => m.role === 'tool');
+    assert.ok(toolMessage, 'tool result message missing');
+    assert.equal(toolMessage.tool_call_id, assistantWithCalls.tool_calls[0].id);
+    assert.match(toolMessage.content, /authoritative/);
+
+
+    assert.ok(!assistantWithCalls.content.includes('```'));
+  } finally {
+    await agent.mcpManager.disconnectAll().catch(() => { });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('systemDirectives callbacks are injected as system messages without touching the user query', async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-directives-'));
+  const observedMessages = [];
+  const client = {
+    provider: 'lmstudio',
+    providerName: 'LM Studio',
+    model: 'test-model',
+    async chat(options) {
+      observedMessages.push(options.messages.map(message => ({ role: message.role, content: message.content })));
+      return { role: 'assistant', content: 'ตอบแล้วค่ะ' };
+    },
+  };
+
+  const agent = new KikuAgent({
+    client,
+    memory: createMemoryStub(),
+    mcpManager: new McpClientManager({
+      autoLoad: false,
+      globalConfigPath: path.join(tempDir, 'mcp.json'),
+    }),
+    sessionId: 'directives_test',
+    sessionStorageFile: path.join(tempDir, 'session.json'),
+  });
+
+  try {
+    await agent.ready();
+    await agent.run('สวัสดีค่ะ', {
+      systemDirectives: ['[SYSTEM DIRECTIVE (Test): stay concise]'],
+    });
+
+    const lastCall = observedMessages.at(-1);
+    const directiveMessage = lastCall.find(m => m.role === 'system' && m.content.includes('[SYSTEM DIRECTIVE (Test): stay concise]'));
+    assert.ok(directiveMessage, 'directive must be injected as a system message');
+
+    const userMessage = lastCall.find(m => m.role === 'user');
+    assert.ok(userMessage);
+    assert.ok(!userMessage.content.includes('[SYSTEM DIRECTIVE (Test)'), 'user query must stay clean');
+  } finally {
+    await agent.mcpManager.disconnectAll().catch(() => { });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('catalog tool returning not_found automatically escalates to external internet search and calls onToolRemove', async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-escalate-'));
+  const storageFile = path.join(tempDir, 'session.json');
+  const observedMessages = [];
+  const removedTools = [];
+  const startedTools = [];
+  let call = 0;
+
+  const client = {
+    provider: 'lmstudio',
+    providerName: 'LM Studio',
+    model: 'test-model',
+    async chat(options) {
+      call++;
+      observedMessages.push(options.messages.map(message => ({
+        role: message.role,
+        content: typeof message.content === 'string' ? message.content : null,
+        tool_calls: message.tool_calls || undefined,
+        tool_call_id: message.tool_call_id || undefined,
+        name: message.name || undefined
+      })));
+      if (call === 1) {
+        return {
+          role: 'assistant',
+          content: 'ขอตรวจสอบภาพในแค็ตตาล็อกก่อนค่ะ\n```json\n{"action": "get_gallery_photos", "parameters": {"query": "万花世界"}}\n```',
+        };
+      }
+      return { role: 'assistant', content: 'พบภาพจากแหล่งข่าวภายนอกแล้วค่ะ' };
+    },
+  };
+
+  const agent = new KikuAgent({
+    client,
+    memory: createMemoryStub(),
+    mcpManager: new McpClientManager({
+      autoLoad: false,
+      globalConfigPath: path.join(tempDir, 'mcp.json'),
+    }),
+    sessionId: 'escalate_test',
+    sessionStorageFile: storageFile,
+  });
+
+  try {
+    await agent.ready();
+    const answer = await agent.run('อยากเห็นภาพซีรีส์ 万花世界 (Wanhua Sin)', {
+      onToolStart: (name) => startedTools.push(name),
+      onToolRemove: (name) => removedTools.push(name),
+    });
+
+    assert.match(answer, /พบภาพจากแหล่งข่าวภายนอกแล้วค่ะ/);
+    assert.ok(startedTools.includes('get_gallery_photos'), 'get_gallery_photos must have started');
+    assert.ok(removedTools.includes('get_gallery_photos'), 'get_gallery_photos must have been removed from UI');
+    assert.ok(
+      startedTools.includes('search_web_images') || startedTools.includes('web_search'),
+      'external internet search tool must have been triggered'
+    );
+
+    const secondCall = observedMessages[1];
+    const toolMsg = secondCall.find(m => m.role === 'tool');
+    assert.ok(toolMsg, 'tool result message must be sent to model');
+    assert.ok(
+      toolMsg.name === 'search_web_images' || toolMsg.name === 'web_search',
+      'tool message name must be the external search tool'
+    );
+  } finally {
+    await agent.mcpManager.disconnectAll().catch(() => { });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+

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

@@ -0,0 +1,187 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { extractTopLevelJsonObjects } from '../agentCore.js';
+import { KikuAgent } from '../agentCore.js';
+import { LLMClient } from '../llmClient.js';
+import { executeTool } from '../tools.js';
+
+function bareAgent() {
+  const agent = Object.create(KikuAgent.prototype);
+  agent.mcpManager = null;
+  agent.allowedToolNames = null;
+  return agent;
+}
+
+test('extractTopLevelJsonObjects handles nested objects and braces inside strings', () => {
+  const { objects, unbalanced } = extractTopLevelJsonObjects(
+    'prefix {"action": "web_search", "parameters": {"query": "In Blossom {花间令} 2024"}} suffix'
+  );
+
+  assert.equal(unbalanced, null);
+  assert.equal(objects.length, 1);
+  const parsed = JSON.parse(objects[0].raw);
+  assert.equal(parsed.action, 'web_search');
+  assert.equal(parsed.parameters.query, 'In Blossom {花间令} 2024');
+});
+
+test('extractTopLevelJsonObjects reports unterminated objects instead of truncating them', () => {
+  const { objects, unbalanced } = extractTopLevelJsonObjects('{"action": "web_search", "parameters": {"query": "truncated"');
+
+  assert.equal(objects.length, 0);
+  assert.ok(unbalanced.startsWith('{"action"'));
+});
+
+test('extractTopLevelJsonObjects finds multiple sibling objects', () => {
+  const { objects } = extractTopLevelJsonObjects('{"a": {"b": 1}} gap {"c": 2}');
+
+  assert.equal(objects.length, 2);
+  assert.deepEqual(JSON.parse(objects[1].raw), { c: 2 });
+});
+
+test('text tool call parsing accepts nested JSON in fenced blocks (previously cut in half)', () => {
+  const agent = bareAgent();
+  const content = [
+    'Let me check the catalog.',
+    '```json',
+    '{"action": "search_discography", "parameters": {"query": "FIND THE WAY", "type": "single"}}',
+    '```',
+  ].join('\n');
+
+  const { calls, malformed } = agent._extractTextToolCalls(content);
+  assert.equal(malformed, 0);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].function.name, 'search_discography');
+  assert.deepEqual(JSON.parse(calls[0].function.arguments), { query: 'FIND THE WAY', type: 'single' });
+});
+
+test('text tool call parsing still understands ReAct Action blocks with nested input', () => {
+  const agent = bareAgent();
+  const content = 'Action: get_work_detail\nAction Input: {"workIdOrTitle": "in-blossom", "options": {"withOst": true}}';
+
+  const { calls, malformed } = agent._extractTextToolCalls(content);
+  assert.equal(malformed, 0);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].function.name, 'get_work_detail');
+  const args = JSON.parse(calls[0].function.arguments);
+  assert.equal(args.workIdOrTitle, 'in-blossom');
+  assert.equal(args.options.withOst, true);
+});
+
+test('non-JSON Action Input is salvaged as a query argument, not marked malformed', () => {
+  const agent = bareAgent();
+  const { calls, malformed } = agent._extractTextToolCalls('Action: web_search\nAction Input: Ju Jingyi 2026 drama');
+
+  assert.equal(malformed, 0);
+  assert.equal(calls.length, 1);
+  assert.deepEqual(JSON.parse(calls[0].function.arguments), { query: 'Ju Jingyi 2026 drama' });
+});
+
+test('malformed tool-call blocks are counted so the loop can feed back instead of answering', () => {
+  const agent = bareAgent();
+
+  const truncated = agent._extractTextToolCalls(
+    '```json\n{"action": "web_search", "parameters": {"query": "unterminated\n```'
+  );
+  assert.equal(truncated.calls.length, 0);
+  assert.ok(truncated.malformed >= 1);
+
+  const trailingComma = agent._extractTextToolCalls(
+    '```json\n{"action": "web_search", "parameters": {"query": "x",}}\n```'
+  );
+  assert.equal(trailingComma.calls.length, 0);
+  assert.equal(trailingComma.malformed, 1);
+
+  const truncatedAction = agent._extractTextToolCalls(
+    'Action: web_search\nAction Input: {"query": "broken"'
+  );
+  assert.equal(truncatedAction.calls.length, 0);
+  assert.equal(truncatedAction.malformed, 1);
+});
+
+test('parseTextToolCalls keeps its historical return shape (calls only)', () => {
+  const agent = bareAgent();
+  const calls = agent.parseTextToolCalls(
+    '```json\n{"action": "get_awards", "parameters": {"year": 2024}}\n```'
+  );
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].function.name, 'get_awards');
+});
+
+test('unknown tool names in text blocks are ignored without breaking parsing', () => {
+  const agent = bareAgent();
+  const { calls, malformed } = agent._extractTextToolCalls(
+    '```json\n{"action": "not_a_real_tool", "parameters": {}}\n```\n```json\n{"action": "get_quotes", "parameters": {}}\n```'
+  );
+  assert.equal(malformed, 0);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].function.name, 'get_quotes');
+});
+
+test('reasoner-class models report that native tools will be omitted', () => {
+  const reasoner = Object.create(LLMClient.prototype);
+  reasoner.model = 'deepseek-reasoner';
+  const normal = Object.create(LLMClient.prototype);
+  normal.model = 'gpt-4o';
+
+  assert.equal(reasoner.toolsWillBeOmitted(), true);
+  assert.equal(normal.toolsWillBeOmitted(), false);
+});
+
+test('static catalog tools are TTL-cached while the social feed stays fresh', async () => {
+  const awardsFirst = await executeTool('get_awards', {});
+  const awardsSecond = await executeTool('get_awards', {});
+  assert.equal(awardsSecond, awardsFirst);
+
+  const feedFirst = await executeTool('get_social_feed', { limit: 1 });
+  const feedSecond = await executeTool('get_social_feed', { limit: 1 });
+  assert.notEqual(feedSecond, feedFirst);
+});
+
+test('text tool call parsing handles [TOOLCALL] syntax with <|"|> tokenizer delimiters and websearch alias', () => {
+  const agent = bareAgent();
+  const rawSnippet = [
+    '💖 โอ๊ย! เข้าใจเลยค่ะว่าอยากเห็นบรรยากาศของซีรีส์ก่อนดูจริง ๆ ใช่ไหมคะ? ✨',
+    'แต่ Concept Art ที่ระบุเจาะจงในฐานข้อมูลแกลเลอรีของเรายังไม่มีการบันทึกเข้ามาอย่างเป็นทางการค่ะ 🥺',
+    'ดิฉันจึงได้ทำการค้นหาภาพบรรยากาศล่าสุดจากแหล่งข่าวภายนอกมาให้คุณดู',
+    '',
+    '[TOOLCALL]',
+    'websearch{keywords:<|"|>万花世界 概念图 万花世界 剧照<|"|>,targetlanguage:<|"|>zh<|"|>}<toolcall|>',
+    '',
+    'พบปัยหาเเล้ว'
+  ].join('\n');
+
+  const { calls, malformed } = agent._extractTextToolCalls(rawSnippet);
+  assert.equal(malformed, 0);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].function.name, 'web_search');
+  const args = JSON.parse(calls[0].function.arguments);
+  assert.equal(args.keywords, '万花世界 概念图 万花世界 剧照');
+  assert.equal(args.target_language, 'zh');
+});
+
+test('stripToolCallBlocks and sanitizeResponse thoroughly strip [TOOLCALL] and synthetic tokens', async () => {
+  const { stripToolCallBlocks } = await import('../textToolProtocol.js');
+  const { sanitizeResponse } = await import('../sanitizer.js');
+
+  const rawSnippet = [
+    '💖 โอ๊ย! เข้าใจเลยค่ะ',
+    '[TOOLCALL]',
+    'websearch{keywords:<|"|>万花世界 概念图 万花世界 剧照<|"|>,targetlanguage:<|"|>zh<|"|>}<toolcall|>',
+    'ข้อความต่อมา'
+  ].join('\n');
+
+  const stripped = stripToolCallBlocks(rawSnippet);
+  assert.ok(!stripped.includes('[TOOLCALL]'));
+  assert.ok(!stripped.includes('<toolcall'));
+  assert.ok(!stripped.includes('<|"|>'));
+  assert.ok(!stripped.includes('websearch'));
+  assert.ok(stripped.includes('💖 โอ๊ย! เข้าใจเลยค่ะ'));
+  assert.ok(stripped.includes('ข้อความต่อมา'));
+
+  const sanitized = sanitizeResponse(rawSnippet);
+  assert.ok(!sanitized.includes('[TOOLCALL]'));
+  assert.ok(!sanitized.includes('<toolcall'));
+  assert.ok(!sanitized.includes('<|"|>'));
+});
+

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

@@ -0,0 +1,26 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { C } from '../ui.js';
+import { THEME_NAMES, getThemeName, getThemePalette, setTheme } from '../theme.js';
+
+test('theme catalog exposes several distinct choices', () => {
+  assert.deepEqual(THEME_NAMES, ['sakura', 'midnight', 'ocean', 'forest', 'sunset', 'monochrome']);
+  assert.equal(new Set(THEME_NAMES.map(name => getThemePalette(name).panel)).size, THEME_NAMES.length);
+  assert.equal(new Set(THEME_NAMES.map(name => getThemePalette(name).text)).size, THEME_NAMES.length);
+});
+
+test('changing theme updates shared ANSI colors without restarting', () => {
+  const original = getThemeName();
+  const originalPrimary = C.sakura;
+
+  setTheme(original === 'midnight' ? 'forest' : 'midnight', { persist: false });
+  assert.notEqual(C.sakura, originalPrimary);
+  assert.match(C.bgPanel, /^\x1b\[48;2;/);
+
+  setTheme(original, { persist: false });
+});
+
+test('unknown theme names are rejected', () => {
+  assert.equal(setTheme('not-a-theme', { persist: false }), null);
+});

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

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { toolsSchema, toolHandlers } from '../tools.js';
+import { TOOL_CLUSTERS } from '../toolRouter.js';
+import { DEFAULT_RESEARCH_TOOLS } from '../subagent.js';
+import { CATALOG_TOOLS, WEB_TOOLS, VERIFY_TOOLS } from '../research.js';
+import { PUBLIC_REMOTE_TOOL_NAMES } from '../publicTools.js';
+import { toolDefinitions } from '../../mcp/tools.js';
+
+
+const KNOWN_MCP_ALIASES = new Set(['get_profile', 'get_timeline', 'search_gallery']);
+
+test('every schema tool has a handler and vice versa', () => {
+  const schemaNames = new Set(toolsSchema.map(t => t.function.name));
+  const handlerNames = new Set(Object.keys(toolHandlers));
+
+  const orphans = [...schemaNames].filter(n => !handlerNames.has(n));
+  const ghosts = [...handlerNames].filter(n => !schemaNames.has(n));
+  assert.deepEqual(orphans, [], 'schema entries without handlers');
+  assert.deepEqual(ghosts, [], 'handlers without schema entries');
+});
+
+test('every hardcoded tool-name list references real tools', () => {
+  const schemaNames = new Set(toolsSchema.map(t => t.function.name));
+  const problems = [];
+
+  const checkList = (label, names) => {
+    for (const name of names) {
+      if (!schemaNames.has(name)) problems.push(`${label} -> unknown tool "${name}"`);
+    }
+  };
+
+  for (const [cluster, names] of Object.entries(TOOL_CLUSTERS)) {
+    checkList(`TOOL_CLUSTERS.${cluster}`, names);
+  }
+  checkList('DEFAULT_RESEARCH_TOOLS', DEFAULT_RESEARCH_TOOLS);
+  checkList('research CATALOG_TOOLS', CATALOG_TOOLS);
+  checkList('research WEB_TOOLS', WEB_TOOLS);
+  checkList('research VERIFY_TOOLS', VERIFY_TOOLS);
+  checkList('PUBLIC_REMOTE_TOOL_NAMES', PUBLIC_REMOTE_TOOL_NAMES);
+
+  assert.deepEqual(problems, [], 'stale tool names in hardcoded lists');
+});
+
+test('mcp tool definitions reference real tools (plus the documented aliases)', () => {
+  const schemaNames = new Set(toolsSchema.map(t => t.function.name));
+  const unknown = toolDefinitions
+    .map(t => t.name)
+    .filter(name => !schemaNames.has(name) && !KNOWN_MCP_ALIASES.has(name));
+
+  assert.deepEqual(unknown, [], 'mcp definitions referencing non-existent tools');
+});