kiku-agent 1.3.1 → 1.3.2

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

@@ -0,0 +1,178 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  extractArticleDate,
+  classifySource,
+  classifyTopics,
+  dedupeNewsItems,
+  rankNewsItems,
+  mergeNewsResults,
+  newsFingerprint,
+} from '../newsIntelligence.js';
+import { checkNewsWatch, loadWatchState, saveWatchState } from '../newsWatch.js';
+
+const NOW = new Date('2026-09-12T12:00:00Z');
+
+test('extractArticleDate parses ISO, Chinese, Thai BE, and English dates', () => {
+  const iso = extractArticleDate({ title: 'Ju Jingyi new drama 2026-09-01 announced', snippet: '' }, { now: NOW });
+  assert.equal(iso.source, 'iso');
+  assert.equal(iso.date.toISOString().slice(0, 10), '2026-09-01');
+
+  const zh = extractArticleDate({ title: '鞠婧祎 2026年9月10日 发新歌', snippet: '' }, { now: NOW });
+  assert.equal(zh.source, 'zh');
+  assert.equal(zh.date.toISOString().slice(0, 10), '2026-09-10');
+
+  const thBE = extractArticleDate({ title: 'จวีจิ้งอีปล่อยเพลงใหม่ 12 ก.ย. 2568', snippet: '' }, { now: NOW });
+  assert.equal(thBE.source, 'th');
+  assert.equal(thBE.date.toISOString().slice(0, 10), '2025-09-12', 'Buddhist Era 2568 must convert to CE 2025');
+
+  const thFull = extractArticleDate({ title: '', snippet: '12 กันยายน 2026 จวีจิ้งอีคว้ารางวัล' }, { now: NOW });
+  assert.equal(thFull.source, 'th');
+  assert.equal(thFull.date.toISOString().slice(0, 10), '2026-09-12');
+
+  const en1 = extractArticleDate({ title: 'Ju Jingyi appears at event Sep 12, 2026', snippet: '' }, { now: NOW });
+  assert.equal(en1.source, 'en');
+  assert.equal(en1.date.toISOString().slice(0, 10), '2026-09-12');
+
+  const en2 = extractArticleDate({ title: '', snippet: '12 September 2026 studio update' }, { now: NOW });
+  assert.equal(en2.date.toISOString().slice(0, 10), '2026-09-12');
+});
+
+test('extractArticleDate prefers RSS pubDate and supports relative dates', () => {
+  const rss = extractArticleDate({ publishedAt: '2026-09-08T06:30:00Z', title: 'x 2026-01-01' }, { now: NOW });
+  assert.equal(rss.source, 'rss');
+  assert.equal(rss.date.toISOString().slice(0, 10), '2026-09-08');
+
+  const enRel = extractArticleDate({ title: 'Ju Jingyi new single posted 3 hours ago', snippet: '' }, { now: NOW });
+  assert.equal(enRel.source, 'relative');
+  assert.equal(enRel.date.toISOString(), '2026-09-12T09:00:00.000Z');
+
+  const zhRel = extractArticleDate({ title: '鞠婧祎工作室 5小时前 发布', snippet: '' }, { now: NOW });
+  assert.equal(zhRel.date.toISOString(), '2026-09-12T07:00:00.000Z');
+
+  const thRel = extractArticleDate({ title: 'จวีจิ้งอี 2 วันที่แล้ว', snippet: '' }, { now: NOW });
+  assert.equal(thRel.date.toISOString(), '2026-09-10T12:00:00.000Z');
+
+  const none = extractArticleDate({ title: 'Ju Jingyi something happened', snippet: '' }, { now: NOW });
+  assert.equal(none.date, null);
+  assert.equal(none.source, null);
+});
+
+test('classifySource assigns trust tiers to official, press, and community hosts', () => {
+  assert.deepEqual(classifySource('https://weibo.com/u/123456'), { tier: 1, label: 'official' });
+  assert.deepEqual(classifySource('https://m.weibo.cn/status/abc'), { tier: 1, label: 'official' });
+  assert.deepEqual(classifySource('https://www.youtube.com/watch?v=x'), { tier: 1, label: 'official' });
+  assert.equal(classifySource('https://www.thairath.co.th/entertain/x').tier, 2);
+  assert.equal(classifySource('https://ent.sohu.com/a/1').tier, 2);
+  assert.deepEqual(classifySource('https://fanblog.example.com/post'), { tier: 3, label: 'community' });
+});
+
+test('classifyTopics tags music, drama, brand, award, and event coverage', () => {
+  assert.equal(classifyTopics({ title: 'Ju Jingyi new single MV released', snippet: '' }).primary, 'music');
+  assert.equal(classifyTopics({ title: 'จวีจิ้งอี รับบท leading role ซีรีส์ใหม่', snippet: '' }).primary, 'drama');
+  assert.equal(classifyTopics({ title: 'Ju Jingyi named brand ambassador', snippet: '' }).primary, 'brand');
+  assert.ok(classifyTopics({ title: 'Ju Jingyi wins award', snippet: '' }).tags.includes('award'));
+  assert.equal(classifyTopics({ title: 'Unrelated headline', snippet: '' }).primary, 'general');
+});
+
+test('dedupeNewsItems collapses near-duplicate stories and keeps distinct ones', () => {
+  const a = { title: 'Ju Jingyi releases new single 0.2s topping three regional charts', snippet: 'The single topped charts this week across regional platforms.', url: 'https://press-a.com/1' };
+  const b = { title: 'Ju Jingyi releases new single 0.2s topping three regional charts!', snippet: 'The single topped charts this week across regional platforms.', url: 'https://press-b.com/2' };
+  const c = { title: 'Ju Jingyi opening fanmeeting tour in Bangkok next month', snippet: 'Tickets go on sale for the Bangkok fanmeeting tour next month.', url: 'https://press-c.com/3' };
+
+  const kept = dedupeNewsItems([a, b, c]);
+  assert.equal(kept.length, 2);
+  assert.equal(kept[0].url, 'https://press-a.com/1');
+  assert.equal(kept[1].url, 'https://press-c.com/3');
+
+  const urlDupes = dedupeNewsItems([
+    { ...a, url: 'https://x.com/same?utm=1' },
+    { ...a, url: 'https://x.com/same?utm=2' },
+  ]);
+  assert.equal(urlDupes.length, 1, 'URL normalization must drop same-article copies');
+});
+
+test('rankNewsItems sorts by recency, filters by cutoff, and applies officialOnly', () => {
+  const fresh = { title: 'fresh official weibo post', snippet: '', url: 'https://weibo.com/u/1/1', publishedAt: '2026-09-12T10:00:00Z' };
+  const monthOld = { title: 'older press story', snippet: '', url: 'https://www.thairath.co.th/e/2', publishedAt: '2026-08-10T00:00:00Z' };
+  const undated = { title: 'undated fan blog post', snippet: '', url: 'https://blog.example.com/3' };
+
+  const ranked = rankNewsItems([monthOld, undated, fresh], { now: NOW });
+  assert.equal(ranked[0].title, fresh.title, 'fresh items must outrank older and undated ones');
+
+  const cutoffFiltered = rankNewsItems([monthOld, fresh], { now: NOW, cutoff: new Date('2026-09-01T00:00:00Z') });
+  assert.equal(cutoffFiltered.length, 1);
+  assert.equal(cutoffFiltered[0].title, fresh.title);
+
+  const official = rankNewsItems([fresh, monthOld], { now: NOW, officialOnly: true });
+  assert.equal(official.length, 1);
+  assert.equal(official[0].tier, 1);
+});
+
+test('mergeNewsResults fuses RSS and web groups with dedup and budget', () => {
+  const rss = [
+    { title: 'Studio announces comeback single', snippet: 'Official studio announcement of the comeback single this month.', url: 'https://press-a.com/comeback', publishedAt: '2026-09-11T00:00:00Z' },
+    { title: 'Drama filming wraps', snippet: 'The drama filming has wrapped after three months of production.', url: 'https://press-b.com/drama', publishedAt: '2026-09-05T00:00:00Z' },
+  ];
+  const web = [
+    { title: 'Studio announces comeback single', snippet: 'Official studio announcement of the comeback single this month.', url: 'https://aggregator.example/comeback' },
+    { title: 'Brand ambassador campaign launches', snippet: 'New brand ambassador campaign launches with a nationwide rollout.', url: 'https://press-c.com/brand', publishedAt: '2026-09-09T00:00:00Z' },
+  ];
+
+  const { items, totalUnique } = mergeNewsResults({
+    groups: [{ name: 'news-rss', results: rss }, { name: 'web', results: web }],
+    now: NOW,
+    budget: 10,
+  });
+  assert.equal(totalUnique, 3, 'same story from two groups must collapse to one');
+  assert.equal(items[0].title, 'Studio announces comeback single', 'freshest official story must rank first');
+  assert.ok(items[0].via, 'merge must record which group each item came from');
+});
+
+function tmpStatePath() {
+  return path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'kiku-news-')), 'watch-state.json');
+}
+
+test('checkNewsWatch detects first-run items, zero delta on repeat, and fresh items on change', async () => {
+  const statePath = tmpStatePath();
+  const fetcher = () => Promise.resolve([
+    { title: 'Ju Jingyi comeback stage confirmed for this weekend', snippet: 'Comeback stage confirmed with a special performance lineup.', url: 'https://press-a.com/1', publishedAt: '2026-09-11T00:00:00Z' },
+  ]);
+
+  const first = await checkNewsWatch({ topic: 'comeback', days: 7, fetcher, statePath, now: NOW });
+  assert.equal(first.fresh.length, 1);
+
+  const second = await checkNewsWatch({ topic: 'comeback', days: 7, fetcher, statePath, now: new Date(NOW.getTime() + 60000) });
+  assert.equal(second.fresh.length, 0, 'unchanged stories must not re-appear as fresh');
+
+  const changedFetcher = () => Promise.resolve([
+    { title: 'Ju Jingyi comeback stage confirmed for this weekend', snippet: 'Comeback stage confirmed with a special performance lineup.', url: 'https://press-a.com/1', publishedAt: '2026-09-11T00:00:00Z' },
+    { title: 'Ju Jingyi surprise digital single drops at midnight', snippet: 'A surprise digital single drops at midnight with an accompanying music video.', url: 'https://press-a.com/2', publishedAt: '2026-09-12T09:00:00Z' },
+  ]);
+  const third = await checkNewsWatch({ topic: 'comeback', days: 7, fetcher: changedFetcher, statePath, now: new Date(NOW.getTime() + 120000) });
+  assert.equal(third.fresh.length, 1, 'only the genuinely new story counts as fresh');
+  assert.equal(third.fresh[0].url, 'https://press-a.com/2');
+
+  const persisted = loadWatchState(statePath);
+  assert.ok(persisted.watches['comeback'].lastHashes.length >= 1);
+});
+
+test('watch state persists snapshots across processes', () => {
+  const statePath = tmpStatePath();
+  const state = loadWatchState(statePath);
+  state.watches['music'] = { lastHashes: ['abc'], lastCheckedAt: '2026-09-12T00:00:00.000Z', lastCount: 3 };
+  saveWatchState(state, statePath);
+
+  const reloaded = loadWatchState(statePath);
+  assert.equal(reloaded.watches['music'].lastHashes[0], 'abc');
+  assert.equal(reloaded.watches['music'].lastCount, 3);
+});
+
+test('newsFingerprint is stable for identical items', () => {
+  const item = { title: 'identical headline for fingerprint check', snippet: 'same body text' };
+  assert.equal(newsFingerprint(item), newsFingerprint({ ...item }));
+  assert.notEqual(newsFingerprint(item), newsFingerprint({ title: 'different headline entirely', snippet: 'other body' }));
+});

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

@@ -0,0 +1,99 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { DynamicToolRouter, TOOL_CLUSTERS } from '../toolRouter.js';
+import { ContextCompactor, estimateTokenCount } from '../contextCompactor.js';
+import { AgentMemory } from '../memory.js';
+import { getUnifiedProfile, getUnifiedWorks, getUnifiedDiscography } from '../../mcp/dataAdapter.js';
+import { eventBus, Events } from '../eventBus.js';
+
+test('DynamicToolRouter filters tools based on prompt intent', () => {
+  const router = new DynamicToolRouter();
+  
+  const mediaTools = router.routeToolsForQuery('เปิดเพลงของจวีจิ้งอีหน่อย');
+  assert.ok(mediaTools.some(t => t.function.name === 'play_music'));
+  assert.ok(mediaTools.some(t => t.function.name === 'search_discography'));
+  assert.ok(mediaTools.length < router.allTools.length);
+
+  const dramaTools = router.routeToolsForQuery('Ju Jingyi In Blossom drama synopsis');
+  assert.ok(dramaTools.some(t => t.function.name === 'search_works'));
+  assert.ok(dramaTools.some(t => t.function.name === 'get_work_detail'));
+
+  const fallbackTools = router.routeToolsForQuery('สวัสดีครับ');
+  assert.ok(fallbackTools.some(t => t.function.name === 'global_search'));
+  assert.ok(fallbackTools.length <= 10);
+});
+
+test('ContextCompactor calculates tokens and summarizes history without losing system message', () => {
+  const compactor = new ContextCompactor({ maxTokens: 50, keepRecentMessages: 2 });
+  const messages = [
+    { role: 'system', content: 'You are Kiku AI.' },
+    { role: 'user', content: 'Who is Ju Jingyi?' },
+    { role: 'assistant', content: 'Ju Jingyi is a singer and actress.' },
+    { role: 'user', content: 'Tell me about her songs.' },
+    { role: 'assistant', content: 'She has many solo singles.' },
+    { role: 'user', content: 'What is her latest drama in 2026?' },
+  ];
+
+  const tokens = estimateTokenCount(messages);
+  assert.ok(tokens > 0);
+
+  const compacted = compactor.compact(messages, { maxTokens: 20, keepRecentMessages: 2 });
+  assert.equal(compacted[0].role, 'system');
+  assert.equal(compacted[0].content, 'You are Kiku AI.');
+  assert.equal(compacted[compacted.length - 1].content, 'What is her latest drama in 2026?');
+  assert.ok(compacted.some(m => m.content.includes('[CONVERSATION CONTEXT SUMMARY')));
+});
+
+test('AgentMemory scores fact relevance and applies recency weighting', () => {
+  const memory = new AgentMemory();
+  const f1 = memory.addFact('Ju Jingyi won Top Female Singer in 2026', {
+    category: 'awards',
+    tags: ['singer', 'award', '2026'],
+    confidence: 'high'
+  });
+  const f2 = memory.addFact('Ju Jingyi starred in Legend of White Snake', {
+    category: 'drama',
+    tags: ['drama', 'white snake'],
+    confidence: 'high'
+  });
+
+  const relevant = memory.getRelevantFacts('awards 2026', 2);
+  assert.ok(relevant.length > 0);
+  assert.equal(relevant[0].content, f1.content);
+
+  const context = memory.buildMemoryContext('white snake drama');
+  assert.ok(context.includes('Legend of White Snake'));
+});
+
+test('SSOT DataAdapter provides consistent and valid records for MCP', () => {
+  const profile = getUnifiedProfile();
+  assert.equal(profile.nameCn, '鞠婧祎');
+  assert.ok(profile.fandomName.includes('Miju'));
+
+  const works = getUnifiedWorks();
+  assert.ok(works.length > 10);
+  assert.ok(works.some(w => w.year >= 2024));
+
+  const songs = getUnifiedDiscography();
+  assert.ok(songs.length > 20);
+});
+
+test('EventBus emits AGENT_PLAN lifecycle events for TUI Task Planning', () => {
+  const emitted = [];
+  const unsub1 = eventBus.on(Events.AGENT_PLAN_START, (d) => emitted.push({ type: 'start', data: d }));
+  const unsub2 = eventBus.on(Events.AGENT_PLAN_STEP_UPDATE, (d) => emitted.push({ type: 'update', data: d }));
+  const unsub3 = eventBus.on(Events.AGENT_PLAN_COMPLETE, (d) => emitted.push({ type: 'complete', data: d }));
+
+  eventBus.emit(Events.AGENT_PLAN_START, { planId: 'p1', steps: [{ id: 's1', state: 'pending' }] });
+  eventBus.emit(Events.AGENT_PLAN_STEP_UPDATE, { planId: 'p1', stepId: 's1', state: 'running' });
+  eventBus.emit(Events.AGENT_PLAN_COMPLETE, { planId: 'p1' });
+
+  assert.equal(emitted.length, 3);
+  assert.equal(emitted[0].type, 'start');
+  assert.equal(emitted[1].data.state, 'running');
+  assert.equal(emitted[2].type, 'complete');
+
+  unsub1();
+  unsub2();
+  unsub3();
+});

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

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

@@ -0,0 +1,39 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import { SETTINGS_FILE } from '../appPaths.js';
+import {
+  savePersistedActiveProvider,
+  savePersistedProviderModel,
+  getPersistedActiveProvider,
+  loadPersistedSettings,
+  CLOUD_PROVIDERS,
+} from '../config.js';
+import { LLMClient } from '../llmClient.js';
+
+test('Provider and Model settings persist across restarts', () => {
+  const originalGroqModel = CLOUD_PROVIDERS.groq.defaultModel;
+  const originalLmStudioModel = CLOUD_PROVIDERS.lmstudio.defaultModel;
+
+  try {
+    savePersistedActiveProvider('groq', 'openai/gpt-oss-120b');
+    savePersistedProviderModel('groq', 'llama-3.3-70b-versatile');
+
+    assert.equal(getPersistedActiveProvider(), 'groq');
+    const settings = loadPersistedSettings();
+    assert.equal(settings.activeProvider, 'groq');
+    assert.equal(settings.providerModels?.groq, 'llama-3.3-70b-versatile');
+
+    const client = new LLMClient();
+    assert.equal(client.provider, 'groq');
+    assert.equal(client.model, 'llama-3.3-70b-versatile');
+
+    client.switchProvider('openrouter', { model: 'openrouter/auto' });
+    assert.equal(getPersistedActiveProvider(), 'openrouter');
+  } finally {
+    try { if (fs.existsSync(SETTINGS_FILE)) fs.unlinkSync(SETTINGS_FILE); } catch {}
+    CLOUD_PROVIDERS.groq.defaultModel = originalGroqModel || 'openai/gpt-oss-120b';
+    CLOUD_PROVIDERS.lmstudio.defaultModel = originalLmStudioModel || 'google/gemma-4-e4b';
+    loadPersistedSettings();
+  }
+});