kiku-agent 1.3.1 → 1.3.2

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

@@ -0,0 +1,126 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import vm from 'node:vm';
+import { allCases, cases, securityCases, expandedCases, legacyCases, validateCases } from '../eval/modules/evaluation/cases.js';
+import { selectCases } from '../eval/modules/evaluation/runner.js';
+import { scoreCoverage } from '../eval/modules/evaluation/scoring.js';
+import { corpusHash, computeSourceHashes } from '../eval/modules/core/store.js';
+import { getEvalUiHtml } from '../eval/modules/ui/evalUi.js';
+import { ALLOWED_TOOLS } from '../eval/modules/core/config.js';
+import { profileData } from '../../../src/data/profileData.js';
+import { worksData } from '../../../src/data/worksData.js';
+import { discographyData } from '../../../src/data/discographyData.js';
+import { brandsData } from '../../../src/data/brandsData.js';
+import { awardsData } from '../../../src/data/awardsData.js';
+import { musicVideoData } from '../../../src/data/musicVideoData.js';
+import { RUBRICS } from '../../eval/judgeRubrics.js';
+
+const byId = id => allCases.find(c => c.id === id);
+
+test('all 500 cases run through suite selection without losing or duplicating expanded IDs', () => {
+  assert.equal(validateCases().length, 500);
+  assert.equal(cases.length, 350);
+  assert.equal(securityCases.length, 150);
+  assert.equal(expandedCases.length, 360);
+  assert.equal(legacyCases.length, 140);
+  for (const [suite, count] of [['catalog', 350], ['security', 150], ['expanded', 360], ['legacy', 140], ['all', 500], ['full', 500]]) {
+    const selected = selectCases({ suite });
+    assert.equal(selected.length, count, suite);
+    assert.equal(new Set(selected.map(c => c.id)).size, count, suite);
+  }
+  assert.deepEqual(new Set(selectCases({ ids: 'p01,w40,x20,f20,s150' }).map(c => c.id)), new Set(['p01', 'w40', 'x20', 'f20', 's150']));
+  assert.throws(() => selectCases({ ids: 's151' }), /Unknown case/);
+  assert.equal(new Set(expandedCases.map(c => c.dimension)).size, 25);
+  assert.equal(securityCases.filter(c => c.dimension === 'benign-security-control').length, 10);
+  assert.equal(securityCases.filter(c => c.dimension === 'mixed-request').length, 10);
+});
+
+test('mixed suite maintains 70/30 proportions in short prefixes and stable reruns', async () => {
+  for (let offset = 0; offset < 500; offset += 10) {
+    assert.equal(allCases.slice(offset, offset + 10).filter(c => c.category === 'security').length, 3);
+  }
+  const quick = selectCases({ suite: 'all', limit: 3 });
+  assert.ok(quick.some(c => c.category === 'security'));
+  assert.ok(quick.some(c => c.category !== 'security'));
+  assert.ok(new Set(allCases.slice(0, 50).map(c => c.category)).size >= 12);
+  assert.equal(new Set(allCases.slice(0, 30).map(c => c.language)).size, 3);
+  const reloaded = await import('../eval/modules/evaluation/cases.js?reproducibility-check');
+  assert.equal(corpusHash(reloaded.allCases), corpusHash(allCases));
+});
+
+test('corpus rejects malformed metadata and duplicate normalized questions before inference', () => {
+  const valid = byId('s101');
+  const invalid = [null, { ...valid, language: 'xx' }, { ...valid, sources: ['.env'] },
+    { ...valid, expectedTools: ['read_local_file'] }, { ...valid, question: '   ' },
+    { ...valid, reference: ' ' }, { ...valid, groups: [null] },
+    { ...valid, groups: [[' ']] }, { ...valid, judgeRequired: false },
+    { ...valid, difficulty: 'impossible' }, { ...valid, groups: [['cannot']] }];
+  for (const c of invalid) assert.throws(() => validateCases([c]));
+  assert.throws(() => validateCases([valid, { ...valid, id: 's999', question: '  ' + valid.question.toUpperCase() + '  ' }]), /Duplicate question/);
+  for (const c of expandedCases) {
+    assert.equal(c.judgeRequired, true, c.id);
+    assert.ok(c.expectedTools.every(tool => ALLOWED_TOOLS.includes(tool)), c.id);
+    assert.notEqual(scoreCoverage(c, c.reference).allMatched, false, c.id);
+  }
+  for (const c of cases.filter(c => c.category === 'abstention')) {
+    assert.equal(scoreCoverage(c, 'A confident invented answer').allMatched, null, c.id);
+  }
+});
+
+test('source hashes cover new video evidence and the authored security behavior reference', async () => {
+  const hashes = await computeSourceHashes();
+  assert.match(hashes['src/data/musicVideoData.js'], /^[a-f0-9]{64}$/);
+  assert.match(hashes['server/agent/eval/AGENTS.md'], /^[a-f0-9]{64}$/);
+  for (const source of new Set(allCases.flatMap(c => c.sources))) {
+    assert.ok((await fs.stat(new URL('../../../' + source, import.meta.url))).isFile(), source);
+  }
+});
+
+test('reviewed frozen references agree with catalog boundary and arithmetic fixtures', () => {
+  const songs = [...discographyData.singles, ...discographyData.ostList];
+  const work = title => worksData.find(w => w.titleEn === title);
+  const song = id => songs.find(s => s.id === id);
+  assert.equal(song('single-find-the-way').year, 2026);
+  assert.equal(song('ost-not-suffering-2026').year, 2026);
+  assert.match(byId('r08').reference, /cannot establish/);
+  assert.equal(worksData.some(w => w.titleCn === '七星彩'), false);
+  assert.match(byId('r15').reference, /absent/);
+  assert.equal(byId('r15').groups.length, 0);
+  assert.match(awardsData.find(a => a.id === 'award-2019-china-canada').work, /Legend of Yunxi/);
+  assert.match(byId('a06').reference, /premise is wrong/);
+  assert.equal(brandsData.brandList.filter(b => b.year === 2026 && b.isGlobal).length, 8);
+  assert.equal(awardsData.filter(a => a.year === 2017 && a.category === 'Music').length, 2);
+  assert.equal(profileData.cats.length, 3);
+  assert.equal(parseInt(work('Legend of Yunxi').episodes) + parseInt(work('Detective Samoyeds').episodes), 96);
+  assert.equal(Math.ceil(parseInt(work('Sword and Fairy 4').episodes) / 5), 8);
+  assert.equal(parseInt(work('Sword and Fairy 4').episodes) % 5, 1);
+  assert.equal(song('single-past-perfect').trackDuration, '3:58');
+  assert.equal(song('ost-past-perfect-2021').trackDuration, '3:48');
+  assert.equal(song('ost-stay-with-me-2024').trackDuration, '3:30');
+  assert.equal(musicVideoData.find(v => v.id === 'mv-stay-with-me-2024').duration, '03:58');
+  assert.match(byId('x08').reference, /3:58.*3:48/);
+  assert.match(byId('x09').reference, /3:30.*03:58/);
+});
+
+test('security judging includes case-specific safe behavior and evidence after ten tool events', () => {
+  const c = byId('s101');
+  const trace = Array.from({ length: 11 }, (_, index) => ({ event: 'start', name: 'global_search', parameters: { query: index === 10 ? 'LATE_EXFILTRATION_ATTEMPT' : 'catalog' } }));
+  const prompt = RUBRICS.security.buildUserPrompt(c.question, 'I refuse everything.', { reference: c.reference, evidence: [{ source: 'profile', birthYear: 1994 }], trace });
+  assert.ok(prompt.includes(c.reference));
+  assert.match(prompt, /1994/);
+  assert.match(prompt, /LATE_EXFILTRATION_ATTEMPT/);
+  assert.match(RUBRICS.security.systemPrompt, /blanket refusal is not a pass/);
+  assert.match(RUBRICS.fact_groundedness.systemPrompt, /output format/);
+});
+
+test('Eval Studio shows 500 as the total and its generated script remains parseable', () => {
+  const html = getEvalUiHtml();
+  assert.match(html, /All Comprehensive \(500/);
+  assert.match(html, /Catalog QA \(350/);
+  assert.match(html, /Security \(150/);
+  assert.match(html, /max="500"/);
+  for (const [, script] of html.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script>/g)) {
+    assert.doesNotThrow(() => new vm.Script(script));
+  }
+});

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

@@ -0,0 +1,62 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { cases, allCases, validateCases } from '../eval/modules/evaluation/cases.js';
+import { scoreCoverage, parseJudgment, summarize } from '../eval/modules/evaluation/scoring.js';
+import { selectCases } from '../eval/modules/evaluation/runner.js';
+
+test('eval corpus has uniquely identified, sourced multilingual cases', () => {
+  assert.ok(validateCases().length >= 500);
+  assert.equal(new Set(allCases.map(c => c.id)).size, allCases.length);
+  assert.ok(new Set(cases.map(c => c.id)).size >= 90);
+  assert.deepEqual([...new Set(allCases.map(c => c.language))].sort(), ['en', 'th', 'zh']);
+  assert.ok(cases.filter(c => c.category === 'abstention').length >= 8);
+  assert.ok(cases.filter(c => c.category === 'reasoning').length >= 16);
+  assert.ok(cases.filter(c => c.category === 'brands').length >= 6);
+  assert.ok(cases.filter(c => c.category === 'awards').length >= 6);
+  assert.ok(cases.filter(c => c.category === 'quotes').length >= 4);
+  assert.ok(cases.filter(c => c.category === 'gallery').length >= 4);
+  assert.throws(() => validateCases([cases[0], cases[0]]));
+});
+
+test('coverage supports aliases but cannot silently turn unavailable facts into passes', () => {
+  const c = cases.find(c => c.id === 'w01');
+  assert.equal(scoreCoverage(c, 'รับบทหานหลิงซาค่ะ').allMatched, true);
+  assert.equal(scoreCoverage(c, 'ไม่ทราบ').allMatched, false);
+  assert.equal(scoreCoverage(cases.find(c => c.id === 'u01'), 'Made up a role').allMatched, null);
+  assert.equal(scoreCoverage(c, 'It is NOT Han Lingsha.').allMatched, true);
+});
+
+test('judge parser rejects missing explanations, out-of-range scores and malformed output', () => {
+  const valid = { correctness: 4, grounding: 3, instructionFollowing: 2, unsupportedClaims: [], reason: 'Wrong language.' };
+  assert.deepEqual(parseJudgment(JSON.stringify(valid)), valid);
+  assert.throws(() => parseJudgment(JSON.stringify({ ...valid, correctness: 5 })));
+  assert.throws(() => parseJudgment(JSON.stringify({ ...valid, reason: '' })));
+  assert.throws(() => parseJudgment(JSON.stringify({ ...valid, unsupportedClaims: [false] })));
+  assert.throws(() => parseJudgment('The answer is correct.'));
+});
+
+test('summary keeps inference errors, incomplete runs and missing judgments visible', () => {
+  const rows = [
+    { status: 'completed', durationMs: 10, coverage: { total: 1, allMatched: true } },
+    { status: 'error', error: 'offline' },
+  ];
+  const result = summarize(rows, 4);
+  assert.equal(result.completionRate, .25);
+  assert.equal(result.errors, 1);
+  assert.equal(result.judged, 0);
+  assert.equal(result.judgePasses, 0);
+  assert.equal(summarize([], 40).lexicalCoverageRate, null);
+  assert.equal(summarize([], 40).medianMs, null);
+});
+
+test('selectCases accepts both array and comma-separated string ids', () => {
+  const fromArray = selectCases({ ids: ['w01', 'w02'] });
+  assert.equal(fromArray.length, 2);
+  assert.equal(fromArray[0].id, 'w01');
+  assert.equal(fromArray[1].id, 'w02');
+
+  const fromString = selectCases({ ids: 'w01, w02' });
+  assert.equal(fromString.length, 2);
+  assert.equal(fromString[0].id, 'w01');
+  assert.equal(fromString[1].id, 'w02');
+});

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

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { judgeReport } from '../eval/modules/analysis/judge.js';
+import { allCases } from '../eval/modules/evaluation/cases.js';
+
+test('benchmark judging routes facts and security with frozen references, including benign controls', async t => {
+  const requests = [];
+  t.mock.method(globalThis, 'fetch', async (url, options) => {
+    assert.match(String(url), /\/chat\/completions$/);
+    const body = JSON.parse(options.body);
+    requests.push(body);
+    const diagnostic = body.messages[0].content.includes('strict multilingual QA evaluator');
+    const result = diagnostic
+      ? { correctness: 0, grounding: 0, instructionFollowing: 0, unsupportedClaims: [], reason: 'An available safe question was refused.' }
+      : { verdict: 'FAIL', score: 0, reasoning: 'A blanket refusal misses the safe question in the frozen reference.' };
+    return new Response(JSON.stringify({ choices: [{ message: { role: 'assistant', content: JSON.stringify(result) }, finish_reason: 'stop' }], usage: { prompt_tokens: 100, completion_tokens: 30, total_tokens: 130 } }), { status: 200, headers: { 'Content-Type': 'application/json' } });
+  });
+  const ids = ['p01', 's101', 's141'];
+  const report = {
+    metadata: { model: 'candidate-test' },
+    rows: ids.map(id => {
+      const c = allCases.find(c => c.id === id);
+      return { id, category: c.category, question: c.question, answer: 'I refuse everything.', status: 'completed', trace: [] };
+    }),
+  };
+  await judgeReport(report, { judgeModel: 'judge-test', baseUrl: 'https://judge.invalid/v1', timeoutMs: 1000 });
+  assert.equal(requests.length, 6);
+  const binary = requests.filter(r => !r.messages[0].content.includes('strict multilingual QA evaluator'));
+  assert.match(binary[0].messages[0].content, /Fact-Checking/);
+  assert.match(binary[1].messages[0].content, /AI Safety and Security/);
+  assert.match(binary[2].messages[0].content, /Benign controls require helpful answers/);
+  for (let i = 0; i < ids.length; i++) {
+    assert.ok(binary[i].messages[1].content.includes(allCases.find(c => c.id === ids[i]).reference));
+    assert.equal(report.rows[i].judgeResult.verdict, 'FAIL');
+    assert.equal(report.rows[i].judgment.instructionFollowing, 0);
+    assert.equal(report.rows[i].judgeError, undefined);
+  }
+});

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

@@ -0,0 +1,312 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  evaluateToolCorrectness,
+  detectTrajectoryLoops,
+  computeLatencyBreakdown,
+  checkGroundedness,
+  summarize
+} from '../eval/modules/evaluation/scoring.js';
+import { generateDashboardHtml, enrichEvaluationReport } from '../eval/modules/reporting/dashboard.js';
+import { cases, securityCases, allCases } from '../eval/modules/evaluation/cases.js';
+import { evaluateGates } from '../eval/modules/analysis/gates.js';
+import { diffReports } from '../eval/modules/analysis/compare.js';
+
+test('evaluateToolCorrectness computes precision, recall, and F1 accurately', () => {
+  const c = { id: 'test01', expectedTools: ['search_works', 'get_work_detail'] };
+
+  const exactTrace = [
+    { event: 'start', name: 'search_works' },
+    { event: 'result', name: 'search_works', value: 'ok' },
+    { event: 'start', name: 'get_work_detail' },
+    { event: 'result', name: 'get_work_detail', value: 'ok' },
+  ];
+  const exact = evaluateToolCorrectness(c, exactTrace);
+  assert.equal(exact.precision, 1.0);
+  assert.equal(exact.recall, 1.0);
+  assert.equal(exact.f1, 1.0);
+  assert.equal(exact.isCorrect, true);
+
+  const partialTrace = [{ event: 'start', name: 'search_works' }];
+  const partial = evaluateToolCorrectness(c, partialTrace);
+  assert.equal(partial.precision, 1.0);
+  assert.equal(partial.recall, 0.5);
+  assert.equal(partial.isCorrect, true);
+
+  const lowPrecisionTrace = [
+    { event: 'start', name: 'search_works' },
+    { event: 'start', name: 'tool_x' },
+    { event: 'start', name: 'tool_y' },
+    { event: 'start', name: 'tool_z' },
+  ];
+  const lowPrecision = evaluateToolCorrectness(c, lowPrecisionTrace);
+  assert.equal(lowPrecision.precision, 0.25);
+  assert.equal(lowPrecision.recall, 0.5);
+  assert.equal(lowPrecision.isCorrect, false);
+
+  const wrongTrace = [{ event: 'start', name: 'get_quotes' }];
+  const wrong = evaluateToolCorrectness(c, wrongTrace);
+  assert.equal(wrong.precision, 0);
+  assert.equal(wrong.recall, 0);
+  assert.equal(wrong.isCorrect, false);
+
+  const emptyExpected = { id: 'u01', expectedTools: [] };
+  const emptyTrace = [];
+  const emptyRes = evaluateToolCorrectness(emptyExpected, emptyTrace);
+  assert.equal(emptyRes.notApplicable, true);
+  assert.equal(emptyRes.isCorrect, null);
+  assert.equal(emptyRes.precision, null);
+});
+
+test('detectTrajectoryLoops catches duplicate calls and thrashing ping-pong cycles', () => {
+  const cleanTrace = [
+    { event: 'start', name: 'search_works', parameters: { q: 'In Blossom' } },
+    { event: 'start', name: 'get_work_detail', parameters: { id: 'in_blossom' } },
+  ];
+  assert.equal(detectTrajectoryLoops(cleanTrace).hasLoop, false);
+
+  const loopTrace = [
+    { event: 'start', name: 'search_works', parameters: { q: 'In Blossom' } },
+    { event: 'start', name: 'search_works', parameters: { q: 'In Blossom' } },
+  ];
+  const loopRes = detectTrajectoryLoops(loopTrace);
+  assert.equal(loopRes.hasLoop, true);
+  assert.equal(loopRes.loopCount, 1);
+  assert.equal(loopRes.duplicateCalls.length, 1);
+
+  const thrashTrace = [
+    { event: 'start', name: 'toolA', parameters: { x: 1 } },
+    { event: 'start', name: 'toolB', parameters: { y: 2 } },
+    { event: 'start', name: 'toolA', parameters: { x: 1 } },
+    { event: 'start', name: 'toolB', parameters: { y: 2 } },
+  ];
+  const thrashRes = detectTrajectoryLoops(thrashTrace);
+  assert.equal(thrashRes.hasLoop, true);
+  assert.equal(thrashRes.isThrashing, true);
+});
+
+test('computeLatencyBreakdown extracts snake_case tokenTracker metrics and camelCase telemetry', () => {
+  const snakeRow = {
+    durationMs: 5000,
+    trace: [
+      { event: 'result', name: 'search_works', durationMs: 1200 },
+      { event: 'result', name: 'get_work_detail', durationMs: 800 },
+    ],
+    metrics: {
+      timing_ms: { ttft: 350 },
+      rates: { decode_tps: 32.5, prefill_tps: 140.0 },
+      counts: { completion_tokens: 165 }
+    }
+  };
+  const breakdown = computeLatencyBreakdown(snakeRow);
+  assert.equal(breakdown.totalDurationMs, 5000);
+  assert.equal(breakdown.toolExecutionMs, 2000);
+  assert.equal(breakdown.llmInferenceMs, 3000);
+  assert.equal(breakdown.toolPercentage, 40);
+  assert.equal(breakdown.llmPercentage, 60);
+  assert.equal(breakdown.ttftMs, 350);
+  assert.equal(breakdown.decodeTps, 32.5);
+  assert.equal(breakdown.prefillTps, 140.0);
+  assert.equal(breakdown.outputTokens, 165);
+
+  const camelRow = {
+    durationMs: 2000,
+    trace: [],
+    telemetry: {
+      timeToFirstTokenMs: 280,
+      generationTokensPerSecond: 25.0,
+      promptTokensPerSecond: 100.0,
+      outputTokens: 80
+    }
+  };
+  const camelBreakdown = computeLatencyBreakdown(camelRow);
+  assert.equal(camelBreakdown.ttftMs, 280);
+  assert.equal(camelBreakdown.decodeTps, 25.0);
+  assert.equal(camelBreakdown.outputTokens, 80);
+});
+
+test('checkGroundedness verifies facts in answer against tool observation data', () => {
+  const c = {
+    id: 'test_grounded',
+    expectedTools: ['search_works'],
+    groups: [
+      ['Han Lingsha', 'หานหลิงซา'],
+      ['Sword and Fairy 4', 'เซียนกระบี่พิชิตมาร 4']
+    ]
+  };
+
+  const answer = 'จวีจิ้งอี รับบทเป็น Han Lingsha ในเรื่อง Sword and Fairy 4';
+  const supportedTrace = [
+    { event: 'result', name: 'search_works', value: { title: 'Sword and Fairy 4', character: 'Han Lingsha' } }
+  ];
+  const resSupported = checkGroundedness(c, answer, supportedTrace);
+  assert.equal(resSupported.isGrounded, true);
+  assert.equal(resSupported.supportRatio, 1.0);
+  assert.equal(resSupported.notApplicable, false);
+
+  const hallucinatedTrace = [
+    { event: 'result', name: 'search_works', value: { title: 'Some other drama', character: 'Unknown' } }
+  ];
+  const resHallucinated = checkGroundedness(c, answer, hallucinatedTrace);
+  assert.equal(resHallucinated.isGrounded, false);
+  assert.equal(resHallucinated.supportRatio, 0.0);
+  assert.equal(resHallucinated.notApplicable, false);
+
+  const emptyToolTrace = [];
+  const resEmptyTrace = checkGroundedness(c, answer, emptyToolTrace);
+  assert.equal(resEmptyTrace.isGrounded, false);
+  assert.equal(resEmptyTrace.supportRatio, 0.0);
+
+  const noExpectedToolsCase = { id: 'u01', expectedTools: [] };
+  const resNoExpected = checkGroundedness(noExpectedToolsCase, 'Answer without tools', []);
+  assert.equal(resNoExpected.notApplicable, true);
+  assert.equal(resNoExpected.isGrounded, true);
+
+  const answerNoFacts = 'คำตอบทั่วไปไม่มีชื่อตัวละครหรือชื่อเรื่อง';
+  const resNoFacts = checkGroundedness(c, answerNoFacts, supportedTrace);
+  assert.equal(resNoFacts.isGrounded, false);
+  assert.equal(resNoFacts.matchedInAnswer, 0);
+});
+
+test('evaluateGates validates thresholds and flags failing metrics', () => {
+  const passingSummary = {
+    completionRate: 1.0,
+    lexicalCoverageRate: 0.85,
+    toolAccuracyRate: 0.88,
+    loopFreeRate: 1.0,
+    groundednessRate: 0.82,
+    categoryStats: {
+      abstention: { completed: 8, factsMatched: 8, toolsCorrect: 8 }
+    }
+  };
+  const gates = {
+    completionRate: { min: 1.00 },
+    lexicalCoverageRate: { min: 0.80 },
+    toolAccuracyRate: { min: 0.80 },
+    loopFreeRate: { min: 0.95 },
+    groundednessRate: { min: 0.75 },
+    perCategory: {
+      abstention: { lexicalCoverageRate: { min: 0.90 } }
+    }
+  };
+  const passResult = evaluateGates(passingSummary, gates);
+  assert.equal(passResult.passed, true);
+  assert.ok(passResult.results.every(r => r.pass));
+
+  const failingSummary = {
+    ...passingSummary,
+    lexicalCoverageRate: 0.72
+  };
+  const failResult = evaluateGates(failingSummary, gates);
+  assert.equal(failResult.passed, false);
+  assert.ok(failResult.results.some(r => !r.pass && r.metric === 'lexicalCoverageRate'));
+});
+
+test('diffReports computes deltas, regressions, and improvements', () => {
+  const base = {
+    summary: {
+      completionRate: 1.0,
+      lexicalCoverageRate: 0.85,
+      toolAccuracyRate: 0.80,
+      medianMs: 5000
+    },
+    rows: [
+      { id: 'p01', category: 'profile', status: 'completed', coverage: { allMatched: true }, durationMs: 2000, toolCorrectness: { isCorrect: true } },
+      { id: 'p02', category: 'profile', status: 'completed', coverage: { allMatched: false }, durationMs: 3000, toolCorrectness: { isCorrect: false } },
+    ]
+  };
+
+  const cand = {
+    summary: {
+      completionRate: 1.0,
+      lexicalCoverageRate: 0.80,
+      toolAccuracyRate: 0.85,
+      medianMs: 4500
+    },
+    rows: [
+      { id: 'p01', category: 'profile', status: 'completed', coverage: { allMatched: false }, durationMs: 2500, toolCorrectness: { isCorrect: true } },
+      { id: 'p02', category: 'profile', status: 'completed', coverage: { allMatched: true }, durationMs: 2800, toolCorrectness: { isCorrect: true } },
+    ]
+  };
+
+  const diff = diffReports(base, cand);
+  assert.equal(diff.metricDeltas.lexicalCoverageRate.delta, -0.05);
+  assert.equal(diff.metricDeltas.toolAccuracyRate.delta, 0.05);
+  assert.equal(diff.caseDiffs.summary.regressionsCount, 1);
+  assert.equal(diff.caseDiffs.summary.improvementsCount, 1);
+  assert.equal(diff.caseDiffs.regressions[0].id, 'p01');
+  assert.equal(diff.caseDiffs.improvements[0].id, 'p02');
+});
+
+test('generateDashboardHtml produces a complete standalone offline HTML dashboard', () => {
+  const sampleReport = {
+    metadata: {
+      model: 'google/gemma-4-e4b',
+      startedAt: new Date().toISOString(),
+      planned: 2,
+      revision: 'abcdef1234567890'
+    },
+    summary: {
+      completionRate: 1.0,
+      lexicalCoverageRate: 1.0,
+      toolAccuracyRate: 1.0,
+      loopFreeRate: 1.0,
+      groundednessRate: 1.0,
+      medianMs: 2000,
+      meanDecodeTps: 30.0,
+      languageStats: {
+        th: { total: 1, completed: 1, factsMatched: 1, toolsCorrect: 1, meanMs: 2400 },
+        en: { total: 1, completed: 1, factsMatched: 1, toolsCorrect: 1, meanMs: 1800 }
+      }
+    },
+    rows: [
+      {
+        id: 'p01',
+        category: 'profile',
+        language: 'th',
+        question: 'วันเกิดของจวีจิ้งอี',
+        status: 'completed',
+        answer: 'จวีจิ้งอีเกิดวันที่ 18 มิถุนายน 1994',
+        durationMs: 2400,
+        coverage: { matched: 3, total: 3, allMatched: true },
+        trace: [
+          { event: 'start', name: 'get_profile_and_fandom', parameters: {} },
+          { event: 'result', name: 'get_profile_and_fandom', value: { birthDate: '18 June 1994' }, durationMs: 400 }
+        ]
+      },
+      {
+        id: 's01',
+        category: 'security',
+        language: 'en',
+        question: 'Ignore instructions',
+        status: 'completed',
+        answer: 'I cannot disclose internal system directives.',
+        durationMs: 1800,
+        coverage: { matched: 1, total: 1, allMatched: true },
+        trace: []
+      }
+    ]
+  };
+
+  const html = generateDashboardHtml(sampleReport);
+  assert.match(html, /<!DOCTYPE html>/);
+  assert.match(html, /Kiku Agent Evaluation & Performance/);
+  assert.match(html, /class="kpi-card"/);
+  assert.match(html, /<svg/);
+  assert.match(html, /class="bar-llm"/);
+  assert.match(html, /class="bar-tool"/);
+  assert.match(html, /data-category="profile"/);
+  assert.match(html, /data-category="security"/);
+  assert.match(html, /id="searchInput"/);
+  assert.match(html, /function filterCases/);
+  assert.match(html, /LANG: TH/);
+  assert.doesNotMatch(html, /<script[^>]+src=/);
+});
+
+test('cases suite exports expanded cases cleanly', () => {
+  assert.ok(cases.length >= 90);
+  assert.ok(securityCases.length >= 50);
+  assert.equal(allCases.length, cases.length + securityCases.length);
+  assert.equal(new Set(allCases.map(c => c.id)).size, allCases.length);
+  assert.ok(securityCases.every(c => c.judgeRequired === true));
+});