kiku-agent 1.3.0 → 1.3.2

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

@@ -0,0 +1,190 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  acquireRunLock,
+  archiveSessionReport,
+  createSaver,
+  loadReportWithBackups,
+  rotateBackups,
+  writeBlockedReport,
+} from '../eval/modules/core/store.js';
+
+function makeRow(id) {
+  return {
+    id,
+    category: 'music',
+    language: 'en',
+    question: `q-${id}`,
+    status: 'completed',
+    answer: `a-${id}`,
+    coverage: { matched: 1, total: 1, allMatched: true, missing: [] },
+    toolCorrectness: { isCorrect: true, notApplicable: false },
+    trajectoryHealth: { hasLoop: false },
+    groundedness: { isGrounded: true, notApplicable: false, supportRatio: 1 },
+    durationMs: 100,
+    latencyBreakdown: { llmInferenceMs: 10, toolExecutionMs: 5, decodeTps: 30 },
+  };
+}
+
+async function makeTempDir() {
+  return fs.mkdtemp(path.join(os.tmpdir(), 'kiku-store-test-'));
+}
+
+test('createSaver flushes the report atomically and recomputes the summary', async () => {
+  const dir = await makeTempDir();
+  const outPath = path.join(dir, 'live.json');
+  const report = { metadata: { caseIds: ['c1', 'c2'] }, rows: [] };
+  const save = createSaver(outPath, report);
+
+  report.rows.push(makeRow('c1'));
+  await save(report.rows[0], { force: true });
+
+  const written = JSON.parse(await fs.readFile(outPath, 'utf8'));
+  assert.equal(written.rows.length, 1);
+  assert.equal(written.summary.planned, 2);
+  assert.ok(written.summary.completed === 1);
+  const files = await fs.readdir(dir);
+  assert.ok(!files.includes('live.json.tmp'), 'tmp file must be renamed away');
+});
+
+test('createSaver does not flush before the cadence when rows are appended', async () => {
+  const dir = await makeTempDir();
+  const outPath = path.join(dir, 'live.json');
+  const report = { metadata: { caseIds: ['c1'] }, rows: [] };
+  const save = createSaver(outPath, report);
+
+  await assert.rejects(() => fs.readFile(outPath, 'utf8'));
+  report.rows.push(makeRow('c1'));
+  await save(report.rows[0]);
+  await assert.rejects(() => fs.readFile(outPath, 'utf8'));
+
+  await save(null, { force: true });
+  const written = JSON.parse(await fs.readFile(outPath, 'utf8'));
+  assert.equal(written.rows.length, 1);
+});
+
+test('a finished report is archived exactly once across saver instances', async () => {
+  const dir = await makeTempDir();
+  const outPath = path.join(dir, 'live.json');
+  const report = {
+    metadata: { caseIds: ['c1', 'c2'], finishedAt: new Date().toISOString() },
+    rows: [makeRow('c1'), makeRow('c2')],
+  };
+
+  const save1 = createSaver(outPath, report);
+  await save1(null, { force: true });
+  const save2 = createSaver(outPath, report);
+  await save2(null, { force: true });
+  const save3 = createSaver(outPath, report);
+  await save3(null, { force: true });
+
+  const historyFiles = (await fs.readdir(path.join(dir, 'history'))).filter(f => f.startsWith('run_'));
+  assert.equal(historyFiles.length, 1);
+  assert.ok(report.metadata.archivedAt, 'live report must record archivedAt');
+});
+
+test('archiveSessionReport marks incomplete runs as partial', async () => {
+  const dir = await makeTempDir();
+  const outPath = path.join(dir, 'live.json');
+  const report = {
+    metadata: { caseIds: ['c1', 'c2', 'c3'], finishedAt: new Date().toISOString() },
+    rows: [makeRow('c1')],
+  };
+
+  const archivePath = await archiveSessionReport(report, outPath);
+  assert.ok(archivePath);
+  const archived = JSON.parse(await fs.readFile(archivePath, 'utf8'));
+  assert.equal(archived.metadata.archivedPartial, true);
+
+  const second = await archiveSessionReport(report, outPath);
+  assert.equal(second, null, 'already-archived reports must not be re-archived');
+});
+
+test('archiveSessionReport stamps complete runs as non-partial with unique names', async () => {
+  const dir = await makeTempDir();
+  const outPath = path.join(dir, 'live.json');
+  const report = {
+    metadata: { caseIds: ['c1'], finishedAt: new Date().toISOString() },
+    rows: [makeRow('c1')],
+  };
+
+  const archivePath = await archiveSessionReport(report, outPath);
+  assert.ok(archivePath);
+  const archived = JSON.parse(await fs.readFile(archivePath, 'utf8'));
+  assert.equal(archived.metadata.archivedPartial, false);
+  assert.match(path.basename(archivePath), /run_\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}-\d{3}\.json/);
+});
+
+test('writeBlockedReport writes a sibling .blocked.json and never touches the live report', async () => {
+  const dir = await makeTempDir();
+  const outPath = path.join(dir, 'live.json');
+  const liveContent = JSON.stringify({ metadata: {}, rows: [makeRow('c1')] }, null, 2);
+  await fs.writeFile(outPath, liveContent);
+
+  const blockedPath = await writeBlockedReport(outPath, { reason: 'LM Studio offline', planned: 5 });
+  assert.equal(blockedPath, path.join(dir, 'live.blocked.json'));
+  assert.equal(await fs.readFile(outPath, 'utf8'), liveContent, 'live report must stay untouched');
+
+  const blocked = JSON.parse(await fs.readFile(blockedPath, 'utf8'));
+  assert.equal(blocked.status, 'blocked');
+  assert.equal(blocked.reason, 'LM Studio offline');
+  assert.equal(blocked.planned, 5);
+});
+
+test('rotateBackups keeps a bounded chain without a duplicate .bak copy', async () => {
+  const dir = await makeTempDir();
+  const outPath = path.join(dir, 'live.json');
+
+  await fs.writeFile(outPath, 'v1');
+  await rotateBackups(outPath, 3);
+  await fs.writeFile(outPath, 'v2');
+  await rotateBackups(outPath, 3);
+  await fs.writeFile(outPath, 'v3');
+  await rotateBackups(outPath, 3);
+
+  assert.equal(await fs.readFile(path.join(`${outPath}.bak.1`), 'utf8'), 'v3');
+  assert.equal(await fs.readFile(path.join(`${outPath}.bak.2`), 'utf8'), 'v2');
+  assert.equal(await fs.readFile(path.join(`${outPath}.bak.3`), 'utf8'), 'v1');
+  await assert.rejects(() => fs.stat(`${outPath}.bak`), 'legacy duplicate .bak must no longer be written');
+});
+
+test('loadReportWithBackups prefers the live file then .bak.1 then .bak', async () => {
+  const dir = await makeTempDir();
+  const outPath = path.join(dir, 'live.json');
+  const report = { metadata: {}, rows: [makeRow('c1')] };
+
+  assert.equal(await loadReportWithBackups(outPath), null);
+
+  await fs.writeFile(`${outPath}.bak.1`, JSON.stringify(report));
+  const fromBak1 = await loadReportWithBackups(outPath);
+  assert.equal(fromBak1.rows[0].id, 'c1');
+
+  await fs.writeFile(outPath, JSON.stringify({ metadata: {}, rows: [makeRow('c2')] }));
+  const fromLive = await loadReportWithBackups(outPath);
+  assert.equal(fromLive.rows[0].id, 'c2');
+});
+
+test('acquireRunLock serializes writers and recovers stale locks', async () => {
+  const dir = await makeTempDir();
+  const outPath = path.join(dir, 'live.json');
+
+  const lock = await acquireRunLock(outPath);
+  await assert.rejects(
+    () => acquireRunLock(outPath),
+    error => error.status === 409
+  );
+  await lock.release();
+
+  const second = await acquireRunLock(outPath);
+  await second.release();
+
+  const lockPath = `${outPath}.lock`;
+  await fs.writeFile(lockPath, '999999', { flag: 'wx' });
+  const staleTime = new Date(Date.now() - 2 * 60 * 60 * 1000);
+  await fs.utimes(lockPath, staleTime, staleTime);
+  const staleLock = await acquireRunLock(outPath);
+  await staleLock.release();
+});

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

@@ -0,0 +1,179 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { getEvalUiHtml } from '../eval/modules/ui/evalUi.js';
+import { handleEvalApiRequest } from '../eval/modules/server/evalApi.js';
+
+test('evalUi generator produces valid HTML with essential studio components', () => {
+  const html = getEvalUiHtml();
+  assert.ok(typeof html === 'string');
+  assert.ok(html.includes('Kiku Eval Studio'));
+  assert.ok(html.includes('/api/eval/events'));
+  assert.ok(html.includes('/api/eval/status'));
+  assert.ok(html.includes('id="btnStart"'));
+  assert.ok(html.includes('id="btnStop"'));
+  assert.ok(html.includes('id="casesTableBody"'));
+  assert.ok(html.includes('id="detailDrawer"'));
+  assert.ok(html.includes('id="kpiPassAt1"'));
+  assert.ok(html.includes('id="compareModal"'));
+  assert.ok(html.includes('id="playgroundModal"'));
+  assert.ok(html.includes('id="suitesModal"'));
+  assert.ok(html.includes('id="arenaModal"'));
+  assert.ok(html.includes('id="judgeModal"'));
+  assert.ok(html.includes('id="studioAlertModal"'));
+  assert.ok(html.includes('id="studioPromptModal"'));
+  assert.ok(!html.includes('alert('), 'evalUi must not use browser alert dialogs');
+  assert.ok(!html.includes('prompt('), 'evalUi must not use browser prompt dialogs');
+  assert.ok(!/[\p{Extended_Pictographic}]/u.test(html), 'evalUi must enforce zero emoji policy');
+});
+
+function createMockHttp() {
+  const headers = {};
+  let body = '';
+  let statusCode = 200;
+
+  const res = {
+    writeHead(code, h = {}) {
+      statusCode = code;
+      Object.assign(headers, h);
+    },
+    setHeader(k, v) {
+      headers[k] = v;
+    },
+    end(data = '') {
+      body += data;
+    },
+    write(chunk = '') {
+      body += chunk;
+    },
+    destroy() {},
+  };
+
+  return { res, getResult: () => ({ statusCode, headers, body }) };
+}
+
+test('handleEvalApiRequest handles /eval route and serves HTML', async () => {
+  const req = { url: '/eval', method: 'GET', on() {} };
+  const { res, getResult } = createMockHttp();
+
+  const handled = await handleEvalApiRequest(req, res);
+  assert.equal(handled, true);
+  const result = getResult();
+  assert.equal(result.statusCode, 200);
+  assert.ok(result.headers['Content-Type'].includes('text/html'));
+  assert.ok(result.body.includes('Kiku Eval Studio'));
+});
+
+test('handleEvalApiRequest handles /api/eval/status route', async () => {
+  const req = { url: '/api/eval/status', method: 'GET', on() {} };
+  const { res, getResult } = createMockHttp();
+
+  const handled = await handleEvalApiRequest(req, res);
+  assert.equal(handled, true);
+  const result = getResult();
+  assert.equal(result.statusCode, 200);
+  assert.ok(result.headers['Content-Type'].includes('application/json'));
+  const parsed = JSON.parse(result.body);
+  assert.equal(parsed.running, false);
+});
+
+test('handleEvalApiRequest handles /api/eval/cases and /api/eval/suites routes with dynamic counts', async () => {
+  const req = { url: '/api/eval/cases', method: 'GET', on() {} };
+  const { res, getResult } = createMockHttp();
+
+  const handled = await handleEvalApiRequest(req, res);
+  assert.equal(handled, true);
+  const result = getResult();
+  assert.equal(result.statusCode, 200);
+  const list = JSON.parse(result.body);
+  assert.equal(list.length, 500);
+  assert.ok(list.some(c => c.id === 'w01'));
+
+  const reqSuites = { url: '/api/eval/suites', method: 'GET', on() {} };
+  const mockSuites = createMockHttp();
+  assert.equal(await handleEvalApiRequest(reqSuites, mockSuites.res), true);
+  const suites = JSON.parse(mockSuites.getResult().body);
+  assert.equal(suites.catalog.count, 350);
+  assert.equal(suites.all.count, 500);
+  assert.equal(suites.security.count, 150);
+  assert.equal(suites.expanded.count, 360);
+  assert.equal(suites.legacy.count, 140);
+});
+
+test('handleEvalApiRequest handles /api/eval/history and /api/eval/custom-suites routes', async () => {
+  const reqHistory = { url: '/api/eval/history', method: 'GET', on() {} };
+  const mockHist = createMockHttp();
+  assert.equal(await handleEvalApiRequest(reqHistory, mockHist.res), true);
+  const histList = JSON.parse(mockHist.getResult().body);
+  assert.ok(Array.isArray(histList));
+
+  const reqSuites = { url: '/api/eval/custom-suites', method: 'GET', on() {} };
+  const mockSuites = createMockHttp();
+  assert.equal(await handleEvalApiRequest(reqSuites, mockSuites.res), true);
+  const suitesList = JSON.parse(mockSuites.getResult().body);
+  assert.ok(Array.isArray(suitesList));
+  assert.ok(suitesList.length >= 1);
+});
+
+test('handleEvalApiRequest handles /api/eval/judge-rubric and /api/eval/matrix routes', async () => {
+  const reqRubric = { url: '/api/eval/judge-rubric', method: 'GET', on() {} };
+  const mockRubric = createMockHttp();
+  assert.equal(await handleEvalApiRequest(reqRubric, mockRubric.res), true);
+  const rubric = JSON.parse(mockRubric.getResult().body);
+  assert.ok(Array.isArray(rubric.criteria));
+  assert.ok(rubric.criteria.length >= 4);
+
+  const reqMatrix = { url: '/api/eval/matrix', method: 'GET', on() {} };
+  const mockMatrix = createMockHttp();
+  assert.equal(await handleEvalApiRequest(reqMatrix, mockMatrix.res), true);
+  const matrix = JSON.parse(mockMatrix.getResult().body);
+  assert.ok(Array.isArray(matrix));
+});
+
+test('handleEvalApiRequest handles export routes for CSV, PNG, and JSON with UUID filenames', async () => {
+  const uuidPattern = /attachment; filename="[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.(csv|png|json)"/;
+
+  const reqCsv = { url: '/api/eval/export/csv', method: 'GET', on() {} };
+  const mockCsv = createMockHttp();
+  assert.equal(await handleEvalApiRequest(reqCsv, mockCsv.res), true);
+  const csvRes = mockCsv.getResult();
+  assert.equal(csvRes.statusCode, 200);
+  assert.ok(csvRes.headers['Content-Type'].includes('text/csv'));
+  assert.ok(csvRes.body.includes('id,category,language,status'));
+  assert.match(csvRes.headers['Content-Disposition'], uuidPattern);
+  assert.ok(csvRes.headers['Content-Disposition'].endsWith('.csv"'));
+
+  const reqPng = { url: '/api/eval/export/png', method: 'GET', on() {} };
+  const mockPng = createMockHttp();
+  assert.equal(await handleEvalApiRequest(reqPng, mockPng.res), true);
+  const pngRes = mockPng.getResult();
+  assert.equal(pngRes.statusCode, 200);
+  assert.ok(pngRes.headers['Content-Type'].includes('image/png'));
+  assert.match(pngRes.headers['Content-Disposition'], uuidPattern);
+  assert.ok(pngRes.headers['Content-Disposition'].endsWith('.png"'));
+
+  const reqJson = { url: '/api/eval/export/json', method: 'GET', on() {} };
+  const mockJson = createMockHttp();
+  assert.equal(await handleEvalApiRequest(reqJson, mockJson.res), true);
+  const jsonRes = mockJson.getResult();
+  assert.equal(jsonRes.statusCode, 200);
+  assert.ok(jsonRes.headers['Content-Type'].includes('application/json'));
+  assert.match(jsonRes.headers['Content-Disposition'], uuidPattern);
+  assert.ok(jsonRes.headers['Content-Disposition'].endsWith('.json"'));
+});
+
+test('handleEvalApiRequest /api/eval/start with retryErrors processes gracefully without wiping dataset', async () => {
+  const req = {
+    url: '/api/eval/start',
+    method: 'POST',
+    on(event, cb) {
+      if (event === 'data') cb(Buffer.from(JSON.stringify({ retryErrors: true })));
+      if (event === 'end') cb();
+    }
+  };
+  const { res, getResult } = createMockHttp();
+  const handled = await handleEvalApiRequest(req, res);
+  assert.equal(handled, true);
+  const result = getResult();
+  assert.ok([200, 400, 409].includes(result.statusCode));
+});
+

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

@@ -0,0 +1,186 @@
+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';
+
+// These tests exercise feedback routes directly without an admin key, so opt in
+// to the test-admin bypass explicitly instead of relying on test-mode sniffing.
+process.env.WEBCHAT_ALLOW_TEST_ADMIN = 'true';
+
+import {
+  FeedbackLearning,
+  extractAnswerFeatures,
+  detectAnswerLanguage,
+  FEEDBACK_MIN_SAMPLES,
+} from '../feedbackLearning.js';
+import { AgentMemory } from '../memory.js';
+
+function tempStore() {
+  return mkdtemp(path.join(os.tmpdir(), 'kiku-feedback-')).then(dir => ({
+    dir,
+    store: new FeedbackLearning({ storagePath: path.join(dir, 'answer_feedback.json') }),
+  }));
+}
+
+const SHORT_BULLET = '## สรุป\n- ประเด็นหนึ่ง\n- ประเด็นสอง\nดู https://www.youtube.com/watch?v=abcdefghijk';
+const LONG_PLAIN = ('คำตอบที่ยาวมากและไม่มีโครงสร้างอะไรเลย '.repeat(120)).trim();
+
+test('feature extraction detects structure, links, and length buckets', () => {
+  const f = extractAnswerFeatures(SHORT_BULLET, ['search_works']);
+  assert.equal(f.lengthBucket, 'short');
+  assert.equal(f.hasHeaders, true);
+  assert.equal(f.hasBullets, true);
+  assert.equal(f.videoLinks, 1);
+  assert.equal(f.language, 'th');
+  assert.equal(f.usedDeepResearch, false);
+
+  const deep = extractAnswerFeatures(SHORT_BULLET, ['run_deep_research']);
+  assert.equal(deep.usedDeepResearch, true);
+
+  const plain = extractAnswerFeatures(LONG_PLAIN, []);
+  assert.equal(plain.lengthBucket, 'long');
+  assert.equal(plain.hasHeaders, false);
+  assert.equal(plain.hasBullets, false);
+  assert.equal(detectAnswerLanguage('Hello world this is English'), 'en');
+});
+
+test('learned prefer directive emerges after enough likes', async () => {
+  const { dir, store } = await tempStore();
+  try {
+    for (let i = 0; i < FEEDBACK_MIN_SAMPLES - 1; i++) {
+      const r = store.record({ rating: 'like', answer: SHORT_BULLET, toolsUsed: ['search_works'] });
+      assert.equal(r.directives.length, 0, 'no directive below threshold');
+    }
+    const r = store.record({ rating: 'like', answer: SHORT_BULLET, toolsUsed: ['search_works'] });
+    assert.ok(r.directives.length > 0);
+    assert.ok(r.directives.some(d => d.kind === 'prefer'));
+    assert.equal(r.totals.like, FEEDBACK_MIN_SAMPLES);
+    assert.match(store.buildStyleContext(), /ตอบแนวนี้/);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('sustained dislikes of long plain answers produce an avoid directive', async () => {
+  const { dir, store } = await tempStore();
+  try {
+    let last = null;
+    for (let i = 0; i < FEEDBACK_MIN_SAMPLES; i++) {
+      last = store.record({ rating: 'dislike', answer: LONG_PLAIN, toolsUsed: [] });
+    }
+    assert.ok(last.directives.some(d => d.kind === 'avoid' && /ยืดเยื้อ|ข้อความล้วน/.test(d.text)));
+    assert.match(store.buildStyleContext(), /หลีกเลี่ยงแนวนี้/);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('mixed feedback below threshold learns nothing', async () => {
+  const { dir, store } = await tempStore();
+  try {
+    store.record({ rating: 'like', answer: SHORT_BULLET });
+    store.record({ rating: 'dislike', answer: SHORT_BULLET });
+    const stats = store.getStats();
+    assert.equal(stats.directives.length, 0);
+    assert.equal(store.buildStyleContext(), '');
+    assert.equal(stats.totals.like, 1);
+    assert.equal(stats.totals.dislike, 1);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('feedback record rejects invalid ratings and persists across reloads', async () => {
+  const { dir, store } = await tempStore();
+  try {
+    assert.throws(() => store.record({ rating: 'meh', answer: 'x' }), /rating must be/);
+    store.record({ rating: 'like', answer: SHORT_BULLET, messageId: 'msg_1' });
+    const reloaded = new FeedbackLearning({ storagePath: path.join(dir, 'answer_feedback.json') });
+    assert.equal(reloaded.getStats().totals.like, 1);
+    assert.equal(reloaded.getStats().recentCount, 1);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('learned directives flow into agent memory context', () => {
+  const memory = new AgentMemory();
+  assert.equal(memory.buildFeedbackStyleContext(), '');
+  memory.applyFeedbackDirectives([
+    { id: 'prefer:fmt:bullets', kind: 'prefer', text: 'ใช้ bullet สรุปประเด็นสำคัญ', support: 6 },
+    { id: 'avoid:len:long', kind: 'avoid', text: 'หลีกเลี่ยงคำตอบที่ยาวยืดเยื้อ', support: 5 },
+  ]);
+  assert.match(memory.buildFeedbackStyleContext(), /bullet/);
+  assert.match(memory.buildMemoryContext('เพลง'), /Learned answer-style preferences/);
+  assert.match(memory.buildMemoryContext('เพลง'), /bullet/);
+});
+
+function mockReq(body) {
+  const handlers = {};
+  return {
+    on: (ev, cb) => { handlers[ev] = cb; },
+    _flush: () => {
+      const s = Buffer.from(JSON.stringify(body));
+      handlers.data?.(s);
+      handlers.end?.();
+    },
+  };
+}
+
+function mockRes() {
+  return {
+    headersSent: false,
+    statusCode: null,
+    body: null,
+    writeHead(code) { this.statusCode = code; },
+    end(str) { this.body = str; },
+  };
+}
+
+test('POST /api/feedback records rating and returns learned directives', async () => {
+  const { dir, store } = await tempStore();
+  try {
+    const { handleFeedbackRoute, handleFeedbackStatsRoute, setFeedbackStore } = await import('../../web-chat/routes/feedbackRoute.js');
+    setFeedbackStore(store);
+
+    for (let i = 0; i < FEEDBACK_MIN_SAMPLES; i++) {
+      const req = mockReq({
+        rating: 'like',
+        query: 'เพลงล่าสุด',
+        answer: SHORT_BULLET,
+        tools: ['search_discography'],
+        model: 'google/gemma-4-e4b',
+        persona: 'default',
+        sessionId: 'sess_test',
+        messageId: `msg_${i}`,
+      });
+      const res = mockRes();
+      const pending = handleFeedbackRoute(req, res);
+      req._flush();
+      await pending;
+      assert.equal(res.statusCode, 200);
+      const json = JSON.parse(res.body);
+      assert.equal(json.status, 'ok');
+      assert.equal(json.rating, 'like');
+    }
+    const statsReq = mockReq({});
+    const statsRes = mockRes();
+    await handleFeedbackStatsRoute(statsReq, statsRes);
+    const stats = JSON.parse(statsRes.body);
+    assert.equal(stats.status, 'ok');
+    assert.equal(stats.totals.like, FEEDBACK_MIN_SAMPLES);
+    assert.ok(stats.directives.length > 0);
+
+    const badReq = mockReq({ rating: 'meh' });
+    const badRes = mockRes();
+    const badPending = handleFeedbackRoute(badReq, badRes);
+    badReq._flush();
+    await badPending;
+    assert.equal(badRes.statusCode, 400);
+  } finally {
+    const { setFeedbackStore } = await import('../../web-chat/routes/feedbackRoute.js');
+    setFeedbackStore(null);
+    await rm(dir, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,44 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import os from 'node:os';
+import { mkdtemp, rm } from 'node:fs/promises';
+
+import { getKikuDataDir } from '../appPaths.js';
+import { runDoctor } from '../doctor.js';
+
+test('app data path honors explicit and platform-standard locations', () => {
+  assert.equal(getKikuDataDir({ KIKU_DATA_DIR: '/tmp/custom-kiku' }, 'linux'), path.normalize('/tmp/custom-kiku'));
+  assert.equal(getKikuDataDir({ KIKU_DATA_DIR: '.kiku-data' }, 'linux'), path.join(os.homedir(), '.kiku-data'));
+  assert.equal(getKikuDataDir({ XDG_DATA_HOME: '/tmp/xdg' }, 'linux'), path.join('/tmp/xdg', 'kiku-agent'));
+  assert.equal(getKikuDataDir({ APPDATA: 'C:\\Users\\Miju\\AppData\\Roaming' }, 'win32'), path.join('C:\\Users\\Miju\\AppData\\Roaming', 'kiku-agent'));
+  assert.equal(getKikuDataDir({ LOCALAPPDATA: 'C:\\Users\\Miju\\AppData\\Local' }, 'win32'), path.join('C:\\Users\\Miju\\AppData\\Local', 'kiku-agent'));
+});
+
+test('doctor treats LM Studio and audio dependencies as optional', async () => {
+  const dataDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-doctor-test-'));
+  try {
+    const report = await runDoctor({
+      client: { async checkConnection() { return { connected: false, models: [] }; } },
+      dataDir,
+    });
+    assert.equal(report.ok, true);
+    assert.equal(report.checks.find(check => check.id === 'lmstudio').required, false);
+    assert.equal(report.checks.find(check => check.id === 'ffmpeg').required, false);
+    assert.equal(report.checks.find(check => check.id === 'node').ok, true);
+  } finally {
+    await rm(dataDir, { recursive: true, force: true });
+  }
+});
+
+test('published production dependencies contain no native audio or Node 22 Ink stack', () => {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync(path.resolve(here, '..', '..', '..', 'package.json'), 'utf8'));
+  for (const dependency of ['speaker', 'ffmpeg-static', 'fluent-ffmpeg', '@distube/ytdl-core', 'ink']) {
+    assert.equal(pkg.dependencies?.[dependency], undefined, `${dependency} must not be a production dependency`);
+    assert.equal(pkg.optionalDependencies?.[dependency], undefined, `${dependency} must not install by default as optional`);
+  }
+  assert.ok(pkg.devDependencies.ink, 'Ink may remain available for local UI development');
+});