kiku-agent 1.3.1 → 1.3.3

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

@@ -0,0 +1,217 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { routeCommand } from '../commands.js';
+
+test('TUI prompt reflects offline and online state accurately', async () => {
+  
+  let catalogOnly = true;
+  const mockPrompt = {
+    isConnected: false,
+    modelName: 'gemma-4-e4b',
+    renderCalls: 0,
+    render() {
+      this.renderCalls += 1;
+    },
+  };
+
+  const mockModelManager = {
+    async resolve() {
+      return { connected: true, selectedModel: 'google/gemma-4-e4b' };
+    },
+  };
+
+  const ctx = {
+    sub: 'reconnect',
+    modelManager: mockModelManager,
+    tuiPrompt: mockPrompt,
+    client: { provider: 'lmstudio', providerName: 'LM Studio' },
+    setCatalogOnlyMode(val) {
+      catalogOnly = val;
+    },
+  };
+
+  const res = await routeCommand('/model reconnect', ctx);
+  assert.equal(res, 'HANDLED');
+  assert.equal(catalogOnly, false);
+  assert.equal(mockPrompt.isConnected, true);
+  assert.equal(mockPrompt.modelName, 'google/gemma-4-e4b');
+  assert.ok(mockPrompt.renderCalls > 0);
+});
+
+test('TUI prompt stays offline when /model reconnect fails', async () => {
+  let catalogOnly = false;
+  const mockPrompt = {
+    isConnected: true,
+    modelName: 'gemma-4-e4b',
+    renderCalls: 0,
+    render() {
+      this.renderCalls += 1;
+    },
+  };
+
+  const mockModelManager = {
+    async resolve() {
+      return { connected: false, error: 'Connection refused at http://127.0.0.1:1234' };
+    },
+  };
+
+  const ctx = {
+    sub: 'reconnect',
+    modelManager: mockModelManager,
+    tuiPrompt: mockPrompt,
+    client: { provider: 'lmstudio', providerName: 'LM Studio' },
+    setCatalogOnlyMode(val) {
+      catalogOnly = val;
+    },
+  };
+
+  const res = await routeCommand('/model reconnect', ctx);
+  assert.equal(res, 'HANDLED');
+  assert.equal(catalogOnly, true);
+  assert.equal(mockPrompt.isConnected, false);
+  assert.ok(mockPrompt.renderCalls > 0);
+});
+
+test('Provider switch updates tuiPrompt isConnected and provider info', async () => {
+  let catalogOnly = true;
+  const mockPrompt = {
+    isConnected: false,
+    modelName: 'gemma-4-e4b',
+    provider: 'LM Studio',
+    render() {},
+  };
+
+  const mockClient = {
+    provider: 'lmstudio',
+    providerName: 'LM Studio',
+    switchProvider(target, opts) {
+      return {
+        provider: target,
+        providerName: 'OpenAI',
+        model: opts?.model || 'gpt-4o',
+        baseUrl: 'https://api.openai.com/v1',
+        hasApiKey: true,
+        isLocal: false,
+      };
+    },
+  };
+
+  const mockModelManager = {
+    client: mockClient,
+    requestedModel: 'gpt-4o',
+    async resolve() {
+      return { connected: true, selectedModel: 'gpt-4o' };
+    },
+  };
+
+  const ctx = {
+    sub: 'use',
+    extra: 'openai gpt-4o',
+    parts: ['/provider', 'use', 'openai', 'gpt-4o'],
+    client: mockClient,
+    modelManager: mockModelManager,
+    tuiPrompt: mockPrompt,
+    setCatalogOnlyMode(val) {
+      catalogOnly = val;
+    },
+  };
+
+  const res = await routeCommand('/provider use openai gpt-4o', ctx);
+  assert.equal(res, 'HANDLED');
+  assert.equal(catalogOnly, false);
+  assert.equal(mockPrompt.isConnected, true);
+  assert.equal(mockPrompt.provider, 'OpenAI');
+  assert.equal(mockPrompt.modelName, 'gpt-4o');
+});
+
+test('/model list automatically connects when model is loaded in VRAM without /model reconnect', async () => {
+  let catalogOnly = true;
+  const mockPrompt = {
+    isConnected: false,
+    modelName: 'gemma-4-e4b',
+    renderCalls: 0,
+    render() {
+      this.renderCalls += 1;
+    },
+  };
+
+  const mockModelManager = {
+    async inspect() {
+      return {
+        connected: true,
+        models: ['google/gemma-4-e4b', 'text-embedding-nomic-embed-text-v1.5'],
+        activeLoadedModel: 'google/gemma-4-e4b',
+      };
+    },
+    async resolve() {
+      return {
+        connected: true,
+        selectedModel: 'google/gemma-4-e4b',
+      };
+    },
+  };
+
+  const ctx = {
+    sub: 'list',
+    modelManager: mockModelManager,
+    tuiPrompt: mockPrompt,
+    client: { provider: 'lmstudio', providerName: 'LM Studio', model: 'google/gemma-4-e4b' },
+    setCatalogOnlyMode(val) {
+      catalogOnly = val;
+    },
+  };
+
+  const res = await routeCommand('/model list', ctx);
+  assert.equal(res, 'HANDLED');
+  assert.equal(catalogOnly, false, 'catalogOnlyMode should automatically become false');
+  assert.equal(mockPrompt.isConnected, true, 'tuiPrompt should automatically become connected');
+  assert.equal(mockPrompt.modelName, 'google/gemma-4-e4b');
+  assert.ok(mockPrompt.renderCalls > 0);
+});
+
+test('/model status automatically connects when model is loaded in VRAM', async () => {
+  let catalogOnly = true;
+  const mockPrompt = {
+    isConnected: false,
+    modelName: 'gemma-4-e4b',
+    renderCalls: 0,
+    render() {
+      this.renderCalls += 1;
+    },
+  };
+
+  const mockModelManager = {
+    async inspect() {
+      return {
+        connected: true,
+        models: ['google/gemma-4-e4b'],
+        activeLoadedModel: 'google/gemma-4-e4b',
+      };
+    },
+    async resolve() {
+      return {
+        connected: true,
+        selectedModel: 'google/gemma-4-e4b',
+      };
+    },
+  };
+
+  const ctx = {
+    sub: 'status',
+    modelManager: mockModelManager,
+    tuiPrompt: mockPrompt,
+    client: { provider: 'lmstudio', providerName: 'LM Studio', model: 'google/gemma-4-e4b' },
+    setCatalogOnlyMode(val) {
+      catalogOnly = val;
+    },
+  };
+
+  const res = await routeCommand('/model status', ctx);
+  assert.equal(res, 'HANDLED');
+  assert.equal(catalogOnly, false);
+  assert.equal(mockPrompt.isConnected, true);
+  assert.equal(mockPrompt.modelName, 'google/gemma-4-e4b');
+  assert.ok(mockPrompt.renderCalls > 0);
+});
+

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

@@ -0,0 +1,197 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  buildSystemPrompt,
+  buildOpenDomainSystemPrompt,
+  buildInDomainSystemPrompt,
+  buildDynamicRoutingDirective
+} from '../prompts.js';
+import {
+  classifyQuerySpectrum,
+  classifyQueryDomain,
+  isQueryInDomain
+} from '../catalogEntityResolver.js';
+import { KikuAgent } from '../agentCore.js';
+
+test('buildOpenDomainSystemPrompt includes coding, math, science, and awakening directives', () => {
+  const prompt = buildOpenDomainSystemPrompt(['web_search', 'search_encyclopedia']);
+
+
+  assert.ok(prompt.includes('SOFTWARE ENGINEERING & CODING EXCELLENCE'));
+  assert.ok(prompt.includes('markdown fenced code blocks'));
+  assert.ok(prompt.includes('time complexity $O(N)$'));
+
+
+  assert.ok(prompt.includes('MATHEMATICS & SCIENTIFIC RIGOR'));
+  assert.ok(prompt.includes('LaTeX / KaTeX'));
+  assert.ok(prompt.includes('$ ... $'));
+  assert.ok(prompt.includes('$$ ... $$'));
+  assert.ok(prompt.includes('step-by-step reasoning'));
+
+
+  assert.ok(prompt.includes('CONTEXT AWAKENING PROTOCOL'));
+  assert.ok(prompt.includes('ตื่นรู้เข้าสู่บริบท'));
+  assert.ok(prompt.includes('search_works'));
+  assert.ok(prompt.includes('search_discography'));
+
+
+  assert.ok(prompt.includes('OPEN-DOMAIN TOOL RETRIEVAL & INTEGRITY'));
+  assert.ok(prompt.includes('web_search'));
+
+
+  assert.ok(prompt.includes('Fibonacci'));
+  assert.ok(prompt.includes('แคลคูลัส'));
+  assert.ok(prompt.includes('เทอร์โมไดนามิกส์'));
+  assert.ok(prompt.includes('[CONTEXT AWAKENING ACTIVATED]'));
+});
+
+test('buildInDomainSystemPrompt retains full Ju Jingyi concierge persona', () => {
+  const prompt = buildInDomainSystemPrompt(['search_works', 'search_discography']);
+
+  assert.ok(prompt.includes('KIKU AGENT (菊)'));
+  assert.ok(prompt.includes('authoritative AI encyclopedia agent and concierge for international artist Ju Jingyi'));
+  assert.ok(prompt.includes('MANDATORY RETRIEVAL RULE'));
+  assert.ok(prompt.includes('DUAL-TIER RETRIEVAL ARCHITECTURE'));
+  assert.ok(prompt.includes('ENTITY & UNIT DISAMBIGUATION'));
+});
+
+test('buildSystemPrompt dispatcher honors options and maintains backward compatibility', () => {
+
+  const defaultPrompt = buildSystemPrompt();
+  assert.ok(defaultPrompt.includes('concierge for international artist Ju Jingyi'));
+
+  const inDomainPrompt = buildSystemPrompt([], { inDomain: true });
+  assert.ok(inDomainPrompt.includes('concierge for international artist Ju Jingyi'));
+
+  const inDomainExplicit = buildSystemPrompt([], { domain: 'IN_DOMAIN' });
+  assert.ok(inDomainExplicit.includes('concierge for international artist Ju Jingyi'));
+
+ 
+  const openDomainPrompt = buildSystemPrompt([], { inDomain: false });
+  assert.ok(openDomainPrompt.includes('OPEN-DOMAIN TECHNICAL & PROBLEM-SOLVING MODE'));
+  assert.ok(openDomainPrompt.includes('CONTEXT AWAKENING PROTOCOL'));
+
+
+  const openDomainExplicit = buildSystemPrompt([], { domain: 'OPEN_DOMAIN' });
+  assert.ok(openDomainExplicit.includes('OPEN-DOMAIN TECHNICAL & PROBLEM-SOLVING MODE'));
+});
+
+test('buildDynamicRoutingDirective includes open-domain and general tools', () => {
+  const directive = buildDynamicRoutingDirective([
+    'web_search',
+    'search_encyclopedia',
+    'get_weather',
+    'search_location_map',
+    'read_local_file',
+  ]);
+
+  assert.ok(directive.includes('Web Search & News -> web_search'));
+  assert.ok(directive.includes('Encyclopedia & General Knowledge -> search_encyclopedia'));
+  assert.ok(directive.includes('Real-time Weather & Location -> get_weather'));
+  assert.ok(directive.includes('Maps & Navigation -> search_location_map'));
+  assert.ok(directive.includes('System & Files -> read_local_file'));
+});
+
+test('classifyQuerySpectrum identifies coding, mathematics, and science as OPEN_DOMAIN', () => {
+  const testCases = [
+   
+    'ช่วยเขียนโค้ด Python เชื่อมต่อ WebSocket ให้หน่อย',
+    'สอนเขียนโปรแกรม Golang จัดการ Goroutines',
+    'แก้บั๊ก React useEffect infinite loop',
+    'เขียนฟังก์ชัน TypeScript สำหรับ debounce',
+    'Write a quicksort algorithm in C++',
+
+
+    'ช่วยแก้โจทย์คณิตศาสตร์หน่อย อินทิกรัล 2x dx',
+    'แก้สมการ x^2 - 5x + 6 = 0 ให้ดูทีละขั้นตอน',
+    'ช่วยคำนวณแคลคูลัสหาอนุพันธ์ของ f(x) = sin(x)*e^x',
+    'อธิบายทฤษฎีบทพีทาโกรัสและวิธีพิสูจน์',
+    'Calculate the eigenvalues of a 2x2 matrix',
+
+ 
+    'อธิบายกฎข้อที่ 2 ของเทอร์โมไดนามิกส์',
+    'กระบวนการสังเคราะห์ด้วยแสงในพืช light reaction กับ dark reaction แตกต่างกันอย่างไร',
+    'ทำไมน้ำถึงมีพันธะไฮโดรเจนและมีความจุความร้อนสูง',
+    'Explain the structure of an atom and electron orbitals',
+    'ความแตกต่างระหว่างแรงโน้มถ่วงและแรงแม่เหล็กไฟฟ้า'
+  ];
+
+  for (const query of testCases) {
+    const domain = classifyQueryDomain(query);
+    const inDomain = isQueryInDomain(query);
+    assert.strictEqual(domain, 'OPEN_DOMAIN', `Expected OPEN_DOMAIN for query: "${query}"`);
+    assert.strictEqual(inDomain, false, `Expected inDomain=false for query: "${query}"`);
+  }
+});
+
+test('classifyQuerySpectrum awakens to IN_DOMAIN when Ju Jingyi or catalog entities are mentioned', () => {
+  const awakeningCases = [
+   
+    'ช่วยเขียนโค้ด Python ดึงรายชื่อผลงานซีรีส์ของจวีจิ้งอี',
+    'คำนวณว่าจวีจิ้งอีเดบิวต์ในวงการมากี่ปีแล้ว',
+    'เพลง 0.2s ของจวีจิ้งอีมีความยาวกี่นาที',
+    'ซีรีส์เรื่อง In Blossom จวีจิ้งอีแสดงเป็นตัวละครอะไร',
+    'จวีจิ้งอีเป็นแอมบาสเดอร์ของแบรนด์ FRED Paris ตั้งแต่ปีไหน',
+    'ยอดขายกล่องของขวัญ TuTuCare ของจวีจิ้งอีขายหมดในกี่วินาที',
+    'เพลง Dewdrops ประกอบซีรีส์เรื่องอะไร',
+    'What dramas has Ju Jingyi starred in?'
+  ];
+
+  for (const query of awakeningCases) {
+    const domain = classifyQueryDomain(query);
+    const inDomain = isQueryInDomain(query);
+    assert.strictEqual(domain, 'IN_DOMAIN', `Expected IN_DOMAIN awakening for query: "${query}"`);
+    assert.strictEqual(inDomain, true, `Expected inDomain=true for query: "${query}"`);
+  }
+});
+
+test('KikuAgent dynamically adapts systemPrompt between open-domain and in-domain turns', async () => {
+  const agent = new KikuAgent();
+  await agent.ready();
+
+ 
+  const inDomainPrompt = agent.buildSystemPrompt(null, { inDomain: true });
+  assert.ok(inDomainPrompt.includes('concierge for international artist Ju Jingyi'));
+
+  const openDomainPrompt = agent.buildSystemPrompt(null, { inDomain: false });
+  assert.ok(openDomainPrompt.includes('OPEN-DOMAIN TECHNICAL & PROBLEM-SOLVING MODE'));
+  assert.ok(openDomainPrompt.includes('CONTEXT AWAKENING PROTOCOL'));
+});
+
+test('KikuAgent ask() triggers Context Awakening in multi-turn transition', async () => {
+  const capturedMessagesList = [];
+  const mockClient = {
+    model: 'mock-kiku',
+    baseUrl: 'http://127.0.0.1:1234',
+    provider: 'lmstudio',
+    providerName: 'lmstudio',
+    chat: async ({ messages }) => {
+      capturedMessagesList.push([...messages]);
+      return {
+        content: 'Response from mock LLM'
+      };
+    }
+  };
+
+  const agent = new KikuAgent({ client: mockClient });
+  await agent.ready();
+
+  
+  await agent.ask('ช่วยเขียนฟังก์ชัน Python สำหรับคำนวณ Fibonacci หน่อย');
+  assert.strictEqual(capturedMessagesList.length, 1);
+  const turn1Messages = capturedMessagesList[0];
+  const turn1SystemPrompt = turn1Messages[0].content;
+  assert.ok(turn1SystemPrompt.includes('OPEN-DOMAIN TECHNICAL & PROBLEM-SOLVING MODE'), 'Turn 1 must use open-domain system prompt');
+  const turn1OpenDirective = turn1Messages.find(m => typeof m.content === 'string' && m.content.includes('OPEN-DOMAIN EXPERT DIRECTIVE'));
+  assert.ok(turn1OpenDirective, 'Turn 1 must include OPEN-DOMAIN EXPERT DIRECTIVE');
+
+ 
+  await agent.ask('แล้วจวีจิ้งอีมีผลงานซีรีส์เรื่องล่าสุดอะไรบ้าง?');
+  assert.strictEqual(capturedMessagesList.length, 2);
+  const turn2Messages = capturedMessagesList[1];
+  const turn2SystemPrompt = turn2Messages[0].content;
+  assert.ok(turn2SystemPrompt.includes('concierge for international artist Ju Jingyi'), 'Turn 2 must awaken to Ju Jingyi concierge persona');
+  const turn2AwakeningDirective = turn2Messages.find(m => typeof m.content === 'string' && m.content.includes('CONTEXT AWAKENING ACTIVATED'));
+  assert.ok(turn2AwakeningDirective, 'Turn 2 must include CONTEXT AWAKENING ACTIVATED directive');
+});
+

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

@@ -0,0 +1,121 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  classifyQueryDomain,
+  isQueryInDomain,
+  QUERY_DOMAINS,
+  getContextualizedSearchQuery
+} from '../catalogEntityResolver.js';
+import { dynamicToolRouter } from '../toolRouter.js';
+import { buildImageSearchQuery } from '../webSearch.js';
+import { createCatalogMatcher, toolHandlers } from '../tools.js';
+
+test('classifyQueryDomain and isQueryInDomain correctly classify in-domain and open-domain queries', () => {
+ 
+  const inDomainQueries = [
+    'จวีจิ้งอี มีผลงานอะไรบ้าง',
+    'Ju Jingyi dramas 2026',
+    '鞠婧祎 花间令',
+    'เพลง 0.2s ใครร้อง',
+    'เสี่ยวจวี เป็นแบรนด์แอมบาสเดอร์อะไรบ้าง',
+    'Veil of Shadows พระเอกคือใคร',
+    'ตำนานรักนางพญางูขาว เล่นเป็นใคร',
+    'Kiku fanclub',
+    'แบรนด์ FRED Paris จวีจิ้งอี'
+  ];
+
+  for (const q of inDomainQueries) {
+    assert.equal(
+      isQueryInDomain(q),
+      true,
+      `Expected "${q}" to be recognized as in-domain`
+    );
+  }
+
+ 
+  const openDomainQueries = [
+    'วิธีทำต้มยำกุ้งน้ำข้น',
+    'สภาพอากาศ โตเกียว วันนี้',
+    'What is quantum computing?',
+    'Who won the 2022 FIFA World Cup?',
+    'Bitcoin price history and future outlook',
+    'Taylor Swift The Eras Tour setlist',
+    'ทฤษฎีสัมพัทธภาพของไอน์สไตน์คืออะไร',
+    'ประวัติศาสตร์อยุธยาตอนต้น',
+    'How to fix TypeError in JavaScript',
+    'สูตรทำข้าวมันไก่'
+  ];
+
+  for (const q of openDomainQueries) {
+    assert.equal(
+      classifyQueryDomain(q),
+      QUERY_DOMAINS.OPEN_DOMAIN,
+      `Expected "${q}" to be classified as OPEN_DOMAIN`
+    );
+    assert.equal(
+      isQueryInDomain(q),
+      false,
+      `Expected "${q}" to NOT be in-domain`
+    );
+  }
+});
+
+test('getContextualizedSearchQuery preserves open-domain queries without injecting artist tokens', () => {
+  const openQuery = 'วิธีทำแกงเขียวหวานไก่';
+  const result = getContextualizedSearchQuery(openQuery, 'chinese_web');
+  assert.equal(result, openQuery, 'Open-domain query should not have artist injected');
+  assert.equal(result.includes('鞠婧祎'), false);
+  assert.equal(result.includes('จวีจิ้งอี'), false);
+
+  const inDomainQuery = 'ผลงานเพลง 0.2s';
+  const inDomainResult = getContextualizedSearchQuery(inDomainQuery, 'chinese_web');
+  assert.ok(
+    inDomainResult.includes('鞠婧祎') || inDomainResult.includes('0.2s') || inDomainResult.includes('0.2秒'),
+    'In-domain query should be contextualized'
+  );
+});
+
+test('buildImageSearchQuery does not prepend artist tokens for open-domain queries', () => {
+  const openQuery = 'Eiffel Tower at night';
+  const imgQuery = buildImageSearchQuery(openQuery);
+  assert.equal(imgQuery, 'Eiffel Tower at night');
+  assert.equal(imgQuery.includes('鞠婧祎'), false);
+
+  const inDomainQuery = 'In Blossom drama poster';
+  const inDomainImgQuery = buildImageSearchQuery(inDomainQuery);
+  assert.ok(inDomainImgQuery.includes('鞠婧祎'), 'In-domain query should include artist name');
+});
+
+test('toolRouter detects OPEN_DOMAIN intent and routes general web/encyclopedia search tools', () => {
+  const openQuery = 'ทำไมท้องฟ้าถึงเป็นสีฟ้า';
+  const intents = dynamicToolRouter.detectIntents(openQuery).map(p => p.type);
+  assert.ok(
+    intents.includes('OPEN_DOMAIN'),
+    'Should detect OPEN_DOMAIN intent for general science query'
+  );
+
+  const tools = dynamicToolRouter.routeToolsForQuery(openQuery);
+  const toolNames = tools.map(t => t.function?.name || t.name);
+  assert.ok(toolNames.includes('web_search'), 'Should include web_search for open-domain queries');
+  assert.ok(
+    !toolNames.includes('search_discography'),
+    'Should not force search_discography on open-domain science question'
+  );
+});
+
+test('search_works matches plot concepts and synopses in Thai', async () => {
+ 
+  const res = await toolHandlers.search_works({ query: 'แฟนตาซี' });
+  assert.equal(res.status, 'success');
+  assert.ok(res.count > 0);
+  assert.ok(
+    res.works.some(w => (w.synopsis || '').includes('แฟนตาซี') || (w.titleEn || '').includes('Veil of Shadows'))
+  );
+});
+
+test('createCatalogMatcher handles unspaced Thai queries with stop phrases', () => {
+  const matcher = createCatalogMatcher('อยากดูซีรีส์แนวสืบคดี');
+ 
+  const haystack = 'ซีรีส์แฟนตาซีฟอร์มยักษ์ นำไปสู่การสืบคดีสไตล์หักเหลี่ยมซ่อนเงื่อน';
+  assert.equal(matcher(haystack), true);
+});

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

@@ -0,0 +1,57 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  CRITICAL_RUNTIME_FILES,
+  getPackagingIssues,
+  isCoveredByFiles,
+  matchesFilesPattern,
+} from '../../../scripts/verifyPackaging.js';
+
+const REPO_ROOT = fileURLToPath(new URL('../../../', import.meta.url));
+
+test('packaging guard covers the websearch crash regression (webSearch.js -> websearch/index.js)', () => {
+  const pkg = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf8'));
+  assert.ok(Array.isArray(pkg.files), 'package.json must define a "files" whitelist');
+  assert.ok(
+    isCoveredByFiles('server/agent/websearch/index.js', pkg.files),
+    'websearch/index.js must be packed or kiku-agent/kiku-mcp crash with ERR_MODULE_NOT_FOUND',
+  );
+  assert.ok(
+    isCoveredByFiles('server/agent/webSearch.js', pkg.files),
+    'webSearch.js must be packed',
+  );
+  for (const rel of CRITICAL_RUNTIME_FILES) {
+    assert.ok(
+      fs.existsSync(path.join(REPO_ROOT, rel)),
+      `critical runtime file must exist on disk: ${rel}`,
+    );
+    assert.ok(isCoveredByFiles(rel, pkg.files), `critical runtime file must be packed: ${rel}`);
+  }
+});
+
+test('packaging guard uses future-proof globs instead of per-directory enumeration', () => {
+  const pkg = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf8'));
+  const hasBroad = pkg.files.some((p) => p === 'server/**/*' || p === 'server/**/*.js');
+  assert.ok(hasBroad, 'package.json "files" must contain "server/**/*" or "server/**/*.js" so new subdirectories are packed automatically');
+  assert.ok(
+    matchesFilesPattern('server/agent/futureModule/nested.js', 'server/**/*.js'),
+    'broad glob must match future nested modules',
+  );
+  assert.ok(
+    matchesFilesPattern('server/agent/ink/App.jsx', 'server/**/*'),
+    'broad glob must match .jsx entries',
+  );
+});
+
+test('packaging guard reports zero issues for the release tree', () => {
+  const { issues } = getPackagingIssues({ rootDir: REPO_ROOT });
+  assert.deepEqual(issues, []);
+});
+
+test('packaging guard detects an unpacked runtime file', () => {
+  assert.equal(isCoveredByFiles('server/agent/websearch/index.js', ['server/agent/*.js']), false);
+  assert.equal(isCoveredByFiles('server/agent/cli.js', ['server/agent/*.js']), true);
+});

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

@@ -0,0 +1,61 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readdirSync, readFileSync } from 'node:fs';
+import { extname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const agentRoot = fileURLToPath(new URL('../', import.meta.url));
+const ignoredDirectories = new Set(['docs', 'tests']);
+const emojiPattern = /[\p{Extended_Pictographic}\p{Regional_Indicator}\uFE0F\u20E3]/gu;
+const approvedEmoji = new Set(['📖', '🎵', '📢', '🌸', '✨', '💬', '🎨', '📸', '🖼', '🔗']);
+
+function collectRuntimeSources(directory, output = []) {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    if (entry.isDirectory() && ignoredDirectories.has(entry.name)) continue;
+    const fullPath = join(directory, entry.name);
+    if (entry.isDirectory()) collectRuntimeSources(fullPath, output);
+    else if (['.js', '.jsx'].includes(extname(entry.name))) output.push(fullPath);
+  }
+  return output;
+}
+
+test('Kiku Agent runtime presentation only uses approved semantic emoji', () => {
+  const offenders = [];
+  for (const file of collectRuntimeSources(agentRoot)) {
+    const matches = readFileSync(file, 'utf8').match(emojiPattern) || [];
+    const unapproved = matches.filter(character => !approvedEmoji.has(character));
+    if (unapproved.length > 0) {
+      offenders.push(`${file.slice(agentRoot.length)}: ${[...new Set(unapproved)].join(' ')}`);
+    }
+  }
+
+  assert.deepEqual(offenders, []);
+});
+
+test('VirtualScreenBuffer performs flicker-free differential row rendering', async () => {
+  const { VirtualScreenBuffer } = await import('../ui.js');
+  const writes = [];
+  const buffer = new VirtualScreenBuffer(40, 5, s => writes.push(s));
+  buffer.clear();
+  buffer.setRow(0, 'Header');
+  buffer.setRow(1, 'Content A');
+  buffer.setRow(2, 'Content B');
+
+  
+  buffer.render();
+  assert.equal(buffer.forceFullRedraw, false);
+  assert.ok(writes.length > 0);
+
+
+  writes.length = 0;
+  buffer.setRow(1, 'Content A Updated');
+  assert.notEqual(buffer.rows[1], buffer.prevRows[1]);
+  assert.equal(buffer.rows[0], buffer.prevRows[0]);
+
+  
+  buffer.render();
+  assert.equal(buffer.rows[1], buffer.prevRows[1]);
+  assert.ok(writes.length > 0);
+  assert.ok(!writes[0].includes('\x1b[2K')); 
+});
+