niceeval 0.5.3 → 0.6.0

package/src/report/report.test.ts

@@ -1,20 +1,23 @@
 // niceeval/report 计算层的单元测试:全部用内存 fake(Snapshot / AttemptHandle 按
-// niceeval/results 的读取契约手工构造),专门覆盖 docs/reports.md 点名的坑 ——
+// niceeval/results 的读取契约手工构造),专门覆盖 docs/feature/reports/architecture.md 点名的坑 ——
 // 两级聚合 vs 平铺、pass@k、examScore 空真、skipped 稀释、scoreboard 固定分母与
 // 最长前缀、scatter/delta 的 null 语义、快照键对比、flag 维度与轴、
 // cases 的 redact/truncated、身份键去重、Selection warnings 随行。
 
 import { describe, expect, it } from "vitest";
 
-import type { AssertionResult, EvalResult, ResultOutcome, RunSummary } from "../types.ts";
-import type { AttemptHandle, RunDir, Selection, SelectionWarning, Snapshot } from "../results/index.ts";
+import type { AssertionResult, EvalResult, O11ySummary, Verdict } from "../types.ts";
+import type { AttemptHandle, Selection, SelectionWarning, Snapshot } from "../results/index.ts";
 import type { Dimension, MetricCell } from "./types.ts";
-import { costUSD, defineMetric, durationMs, examScore, passRate, tokens } from "./metrics.ts";
+import { costUSD, defineMetric, durationMs, examScore, passRate, tokens, turns } from "./metrics.ts";
 import { flag } from "./flag.ts";
 import { formatMetricValue } from "./format.ts";
 import {
-  CaseList,
+  AttemptList,
   DeltaTable,
+  EvalList,
+  ExperimentList,
+  GroupSummary,
   MetricBars,
   MetricLine,
   MetricMatrix,
@@ -23,18 +26,19 @@ import {
   RunOverview,
   Scoreboard,
 } from "./components.tsx";
+import { reasonFor } from "./compute.ts";
 
 // ───────────────────────── fake 数据(按 results 读取契约造)─────────────────────────
 
 let seq = 0;
 
 /** 造一条结果;默认给每条唯一 startedAt —— 身份键含 startedAt,免得普通样本被去重误伤。 */
-function res(id: string, outcome: ResultOutcome, extra: Partial<EvalResult> = {}): EvalResult {
+function res(id: string, verdict: Verdict, extra: Partial<EvalResult> = {}): EvalResult {
   seq += 1;
   return {
     id,
     agent: "agent-x",
-    outcome,
+    verdict,
     attempt: 0,
     startedAt: `2026-07-01T00:00:00.${String(seq).padStart(6, "0")}Z`,
     durationMs: 1000,
@@ -47,6 +51,24 @@ function softAssertion(name: string, score: number, extra: Partial<AssertionResu
   return { name, severity: "soft", score, passed: true, ...extra };
 }
 
+/** 最小合规 O11ySummary,只有 totalTurns 会变;供 turns 指标测试内联挂到 EvalResult.o11y。 */
+function o11ySummary(totalTurns: number): O11ySummary {
+  return {
+    totalTurns,
+    toolCalls: {},
+    totalToolCalls: 0,
+    filesRead: [],
+    filesModified: [],
+    shellCommands: [],
+    webFetches: [],
+    errors: [],
+    thinkingBlocks: 0,
+    compactions: 0,
+    durationMs: 0,
+    usage: { inputTokens: 0, outputTokens: 0 },
+  };
+}
+
 interface SnapSpec {
   experimentId: string;
   results: EvalResult[];
@@ -58,55 +80,46 @@ interface SnapSpec {
 
 let runSeq = 0;
 
-/** 最小构造:一个 run 装一个快照。runStartedAt 决定去重时谁是「最新 run」。 */
+/** 最小构造:一个快照目录装一个快照。runStartedAt 决定去重时谁是「最新快照」。 */
 function snap(spec: SnapSpec): Snapshot {
   runSeq += 1;
   const startedAt = spec.runStartedAt ?? `2026-06-01T00:00:00.${String(runSeq).padStart(3, "0")}Z`;
-  const summary: RunSummary = {
-    agent: spec.agent ?? "agent-x",
+  const dir = `/results/exp/snap-${runSeq}`;
+  const snapshot = {
+    experimentId: spec.experimentId,
     startedAt,
     completedAt: startedAt,
-    passed: 0,
-    failed: 0,
-    skipped: 0,
-    errored: 0,
-    durationMs: 0,
-    results: spec.results,
-  };
-  const runDir: RunDir = { dir: `/results/run-${runSeq}`, summary, attempts: [] };
-  const attempts: AttemptHandle[] = spec.results.map((r, i) => ({
+    agent: spec.agent ?? "agent-x",
+    model: spec.model,
+    schemaVersion: 1,
+    dir,
+    knownEvalIds: spec.knownEvalIds,
+  } as Snapshot;
+  const attempts: AttemptHandle[] = spec.results.map((r) => ({
     evalId: r.id,
     experimentId: r.experimentId ?? spec.experimentId,
     result: r,
-    ref: { run: `run-${runSeq}`, result: i },
-    runDir,
+    ref: { snapshot: `exp/snap-${runSeq}`, attempt: `${r.id}/a${r.attempt}` },
+    snapshot,
     events: async () => null,
     trace: async () => null,
-    o11y: async () => null,
+    o11y: async () => r.o11y ?? null,
+    agentSetup: async () => null,
     diff: async () => null,
     sources: async () => null,
   }));
-  runDir.attempts = attempts;
   const evals = new Map<string, AttemptHandle[]>();
   for (const attempt of attempts) {
     const list = evals.get(attempt.evalId);
     if (list) list.push(attempt);
     else evals.set(attempt.evalId, [attempt]);
   }
-  return {
-    experimentId: spec.experimentId,
-    startedAt,
-    agent: spec.agent ?? "agent-x",
-    model: spec.model,
-    schemaVersion: 1,
-    evals: [...evals.entries()].map(([id, list]) => ({ id, attempts: list })),
-    attempts,
-    runDir,
-    knownEvalIds: spec.knownEvalIds,
-  };
+  snapshot.evals = [...evals.entries()].map(([id, list]) => ({ id, attempts: list }));
+  snapshot.attempts = attempts;
+  return snapshot;
 }
 
-/** 手工造一个选集(warnings 随行的形状,filter 语义与 results 一致)。 */
+/** 手工造一个 Selection(warnings 随行的形状,filter 语义与 results 一致)。 */
 function selection(snapshots: Snapshot[], warnings: SelectionWarning[]): Selection {
   return {
     snapshots,
@@ -122,6 +135,187 @@ function selection(snapshots: Snapshot[], warnings: SelectionWarning[]): Selecti
   };
 }
 
+describe("ExperimentList.data", () => {
+  it("身份、flags、Eval 判定构成、官方两级聚合汇总指标,展开到 Eval 携带 locator 与证据能力", async () => {
+    const s = snap({
+      experimentId: "group/codex-e2b--mempal",
+      agent: "codex",
+      model: "gpt-5.4-mini",
+      runStartedAt: "2026-07-10T22:44:00.000Z",
+      results: [
+        res("memory/a", "failed", {
+          attempt: 0,
+          durationMs: 1_000,
+          assertions: [{ name: "gate", severity: "gate", passed: false, score: 0, detail: "wrong" }],
+          usage: { inputTokens: 10, outputTokens: 5, costUSD: 0.1 },
+          hasEvents: true,
+        }),
+        res("memory/a", "passed", {
+          attempt: 1,
+          durationMs: 2_000,
+          usage: { inputTokens: 20, outputTokens: 10, costUSD: 0.2 },
+        }),
+        res("memory/b", "errored", { error: "timeout", durationMs: 3_000 }),
+      ],
+    });
+    s.experiment = { id: s.experimentId, runs: 2, earlyExit: false, sandbox: "e2b:fast", budget: 2, flags: { cache: true } };
+
+    const items = await ExperimentList.data([s]);
+    expect(items).toHaveLength(1);
+    const item = items[0]!;
+    expect(item).toMatchObject({
+      experimentId: "group/codex-e2b--mempal",
+      agent: "codex",
+      model: "gpt-5.4-mini",
+      flags: { cache: true },
+      verdicts: { passed: 1, failed: 0, errored: 1, skipped: 0 },
+      evals: 2,
+      attempts: 3,
+      lastRunAt: "2026-07-10T22:44:00.000Z",
+    });
+    // 官方两级聚合口径:memory/a 题内均值 (0+1)/2=0.5,memory/b 题内 0;跨题均值 0.25
+    expect(item.passRate.value).toBeCloseTo(0.25);
+    expect(item.cost.samples).toBe(2); // 只有 memory/a 的两次 attempt 报了成本
+
+    const evalA = item.evalRows.find((e) => e.evalId === "memory/a")!;
+    expect(evalA.verdict).toBe("passed"); // 任一轮通过 → 该题通过
+    expect(evalA.attempts.map((a) => a.attempt)).toEqual([0, 1]);
+    expect(evalA.attempts[0]!.locator).toMatch(/^@1[0-9a-z]{7}$/);
+    expect(evalA.attempts[0]!.capabilities.execution).toBe(true); // attempt0 的 hasEvents:true
+    expect(evalA.attempts[1]!.capabilities.execution).toBe(false);
+    // 每次 attempt 独立编码,即使同一道题也不撞车
+    expect(evalA.attempts[0]!.locator).not.toBe(evalA.attempts[1]!.locator);
+
+    const evalB = item.evalRows.find((e) => e.evalId === "memory/b")!;
+    expect(evalB.verdict).toBe("errored");
+    expect(evalB.reason).toBe("timeout");
+  });
+
+  it("展开数组按 evalId 升序,顶层数组按 experimentId 升序", async () => {
+    const s1 = snap({ experimentId: "exp/b", results: [res("z", "passed"), res("a", "passed")] });
+    const s2 = snap({ experimentId: "exp/a", results: [res("x", "passed")] });
+    const items = await ExperimentList.data([s1, s2]);
+    expect(items.map((i) => i.experimentId)).toEqual(["exp/a", "exp/b"]);
+    expect(items.find((i) => i.experimentId === "exp/b")!.evalRows.map((e) => e.evalId)).toEqual(["a", "z"]);
+  });
+});
+
+describe("EvalList.data", () => {
+  it("每项一个 experimentId + evalId,判定/分数/成本耗时均值/失败原因与展开到 Attempt 都在", async () => {
+    const s = snap({
+      experimentId: "compare/codex",
+      results: [
+        res("weather/brooklyn", "failed", {
+          attempt: 0,
+          durationMs: 40_000,
+          usage: { inputTokens: 1, outputTokens: 1, costUSD: 0.02 },
+          assertions: [{ name: 'calledTool("get_weather")', severity: "gate", passed: false, score: 0, detail: "tool was never called" }],
+        }),
+        res("weather/brooklyn", "failed", {
+          attempt: 1,
+          durationMs: 42_000,
+          usage: { inputTokens: 1, outputTokens: 1, costUSD: 0.06 },
+          assertions: [{ name: 'calledTool("get_weather")', severity: "gate", passed: false, score: 0, detail: "tool was never called" }],
+        }),
+      ],
+    });
+    const items = await EvalList.data([s]);
+    expect(items).toHaveLength(1);
+    const item = items[0]!;
+    expect(item.evalId).toBe("weather/brooklyn");
+    expect(item.experimentId).toBe("compare/codex");
+    expect(item.verdict).toBe("failed");
+    expect(item.reason).toBe('calledTool("get_weather"): tool was never called');
+    expect(item.score.value).toBe(0); // examScore: failed → 0
+    expect(item.duration.value).toBeCloseTo(41_000); // 平均耗时
+    expect(item.cost.value).toBeCloseTo(0.04); // 平均成本
+    expect(item.attempts.map((a) => a.attempt)).toEqual([0, 1]);
+    expect(item.attempts[0]!.locator).not.toBe(item.attempts[1]!.locator);
+  });
+
+  it("同一个 eval id 出现在两个 experiment 上是两条不同结果,不合并", async () => {
+    const s1 = snap({ experimentId: "exp/a", results: [res("shared", "passed")] });
+    const s2 = snap({ experimentId: "exp/b", results: [res("shared", "failed")] });
+    const items = await EvalList.data([s1, s2]);
+    expect(items).toHaveLength(2);
+    expect(items.map((i) => `${i.experimentId}:${i.verdict}`).sort()).toEqual(["exp/a:passed", "exp/b:failed"]);
+  });
+});
+
+describe("AttemptList.data", () => {
+  it("每项一个 Attempt:身份、判定、assertions、耗时、成本、locator 与证据能力标记", async () => {
+    const s = snap({
+      experimentId: "exp/x",
+      results: [
+        res("A", "failed", {
+          durationMs: 5_000,
+          usage: { inputTokens: 1, outputTokens: 1, costUSD: 0.05 },
+          assertions: [{ name: "gate", severity: "gate", passed: false, score: 0, detail: "nope" }],
+          hasEvents: true,
+          hasSources: true,
+        }),
+      ],
+    });
+    const items = await AttemptList.data([s]);
+    expect(items).toHaveLength(1);
+    const item = items[0]!;
+    expect(item).toMatchObject({
+      evalId: "A",
+      experimentId: "exp/x",
+      attempt: 0,
+      agent: "agent-x",
+      verdict: "failed",
+      durationMs: 5_000,
+      costUSD: 0.05,
+    });
+    expect(item.assertions).toHaveLength(1);
+    expect(item.locator).toMatch(/^@1[0-9a-z]{7}$/);
+    // 证据能力:cheap 计算,不调用完整 loadAttemptEvidence——execution 来自 hasEvents,
+    // eval 来自 hasSources,diff 懒加载(fixture 的 diff() 恒返回 null → false)。
+    expect(item.capabilities).toEqual({ eval: true, execution: true, timing: false, diff: false });
+  });
+
+  it("redact 作用于 error 与断言 detail/evidence,不作用于身份字段", async () => {
+    const s = snap({
+      experimentId: "exp/x",
+      results: [
+        res("A", "errored", { error: "ENOENT /Users/me/repo/tool" }),
+        res("B", "failed", {
+          assertions: [
+            {
+              name: "includes",
+              severity: "gate",
+              score: 0,
+              passed: false,
+              detail: "missing text under /Users/me/repo/src",
+              evidence: "checked /Users/me/repo/src/app.ts",
+            },
+          ],
+        }),
+      ],
+    });
+    const items = await AttemptList.data([s], { redact: (text) => text.replaceAll("/Users/me/repo", "<repo>") });
+    const a = items.find((i) => i.evalId === "A")!;
+    expect(a.error).toBe("ENOENT <repo>/tool");
+    const b = items.find((i) => i.evalId === "B")!;
+    expect(b.assertions[0]!.detail).toBe("missing text under <repo>/src");
+    expect(b.assertions[0]!.evidence).toBe("checked <repo>/src/app.ts");
+    // 身份字段不经 redact
+    expect(items.every((i) => i.experimentId === "exp/x")).toBe(true);
+  });
+
+  it("不预设只看失败:passed 的 attempt 同样列出,原样携带 assertions", async () => {
+    const s = snap({
+      experimentId: "exp/x",
+      results: [res("A", "passed", { assertions: [{ name: "ok", severity: "gate", passed: true, score: 1 }] })],
+    });
+    const items = await AttemptList.data([s]);
+    expect(items).toHaveLength(1);
+    expect(items[0]).toMatchObject({ verdict: "passed" });
+    expect(items[0]!.assertions).toHaveLength(1);
+  });
+});
+
 // ───────────────────────── 两级聚合 ─────────────────────────
 
 describe("两级聚合引擎", () => {
@@ -146,7 +340,7 @@ describe("两级聚合引擎", () => {
       name: "pass@k",
       better: "higher",
       unit: "%",
-      value: (a) => (a.result.outcome === "skipped" ? null : a.result.outcome === "passed" ? 1 : 0),
+      value: (a) => (a.result.verdict === "skipped" ? null : a.result.verdict === "passed" ? 1 : 0),
       aggregate: { perEval: "max", across: "mean" },
     });
     const s = snap({
@@ -184,7 +378,7 @@ describe("两级聚合引擎", () => {
   it("where 不满足 → null,不进聚合", async () => {
     const onlyPassed = defineMetric({
       name: "only-passed",
-      where: (a) => a.result.outcome === "passed",
+      where: (a) => a.result.verdict === "passed",
       value: () => 5,
     });
     const s = snap({ experimentId: "exp/x", results: [res("A", "passed"), res("B", "failed")] });
@@ -339,6 +533,22 @@ describe("内置指标", () => {
     const dur = await MetricTable.data([s], { rows: "agent", columns: [durationMs] });
     expect(dur.rows[0].cells["duration"].value).toBe(2000); // (1000 + 3000)/2,errored 实测照算
   });
+
+  it("turns:读 o11y.totalTurns;o11y 缺失(未随发布带上)→ null,不是 0;skipped 不进聚合", async () => {
+    const s = snap({
+      experimentId: "exp/x",
+      results: [
+        res("A", "passed", { o11y: o11ySummary(12) }),
+        res("B", "failed"), // 没带 o11y(如 copySnapshots 漏选 artifact)→ null,不稀释成 0
+        res("C", "skipped", { o11y: o11ySummary(3) }), // skipped 恒 null,哪怕 o11y 在场
+      ],
+    });
+    const data = await MetricTable.data([s], { rows: "agent", columns: [turns] });
+    const cell = data.rows[0].cells["turns"];
+    expect(cell.value).toBe(12);
+    expect(cell.samples).toBe(1); // 只有 A 测得了(B 缺 o11y、C 是 skipped)
+    expect(cell.total).toBe(3); // total 是组内全部 attempt 数,不是「本该测得」的分母
+  });
 });
 
 // ───────────────────────── Scoreboard.data ─────────────────────────
@@ -468,10 +678,10 @@ describe("MetricScatter.data", () => {
 // ───────────────────────── flag():维度与轴 ─────────────────────────
 
 describe("flag()", () => {
-  const withFlags = (id: string, flags: Record<string, unknown> | undefined, outcome: ResultOutcome) =>
+  const withFlags = (id: string, flags: Record<string, unknown> | undefined, verdict: Verdict) =>
     snap({
       experimentId: id,
-      results: [res("A", outcome, { experimentId: id, experiment: { id, flags } })],
+      results: [res("A", verdict, { experimentId: id, experiment: { id, flags } })],
     });
 
   it("MetricLine.data:x 收 flag、按 experiment 聚合;未声明的作轴 x=null 报数", async () => {
@@ -512,6 +722,63 @@ describe("flag()", () => {
   });
 });
 
+// ───────────────────────── MetricTable.data:没有实体下钻 ─────────────────────────
+
+describe("MetricTable.data", () => {
+  it("rows: \"experiment\" 的 meta 不带 subRows —— MetricTable 只表达维度 × 指标,没有 expand", async () => {
+    const s = snap({
+      experimentId: "exp/x",
+      results: [res("A", "passed"), res("B", "failed")],
+    });
+    const data = await MetricTable.data([s], { rows: "experiment", columns: [passRate] });
+    expect(data.rows).toHaveLength(1);
+    expect(data.rows[0]!.meta).not.toHaveProperty("subRows");
+    // 展开到 Eval 是 ExperimentList 的职责,不在这里验证 —— 见 ExperimentList.data 的测试组。
+  });
+});
+
+// ───────────────────────── reasonFor(原因优先级)─────────────────────────
+// docs/feature/reports/show.md 裸 `show` 的 RESULT 列口径:error → skipReason → 未通过的 gate 断言。
+// ExperimentList / EvalList 的 evalRows.reason、AttemptList 的 attemptItemReason 都port这同一份材料,
+// 这里直接测 reasonFor 本身,不必再经 MetricTable 之类的中间组件绕一圈。
+
+describe("reasonFor", () => {
+  it("同一 result 同时含 error、失败 gate、失败 soft → 只显示 error", () => {
+    const result = res("A", "errored", {
+      error: "adapter crashed",
+      assertions: [
+        { name: "includes", severity: "gate", score: 0, passed: false, detail: "missing text" },
+        softAssertion("judge", 0.2, { passed: false }),
+      ],
+    });
+    expect(reasonFor(result)).toBe("adapter crashed");
+  });
+
+  it("skipReason 优先于 gate 断言,但让位给 error", () => {
+    const result = res("A", "skipped", {
+      skipReason: "missing fixture",
+      assertions: [{ name: "includes", severity: "gate", score: 0, passed: false }],
+    });
+    expect(reasonFor(result)).toBe("missing fixture");
+  });
+
+  it("多个失败 gate 按原始声明顺序全部保留,拼接成一行;失败 soft 不出现在 reason 里", () => {
+    const result = res("A", "failed", {
+      assertions: [
+        softAssertion("judge-first", 0.1, { passed: false }), // 声明顺序第一,但 soft 不进 reason
+        { name: "includes", severity: "gate", score: 0, passed: false, detail: "missing text" },
+        { name: "matches", severity: "gate", score: 0, passed: false }, // 无 detail,只有 name
+        softAssertion("judge-last", 0.3, { passed: false }), // soft 依旧不进 reason
+      ],
+    });
+    expect(reasonFor(result)).toBe("includes: missing text, matches");
+  });
+
+  it("都缺席 → 无原因", () => {
+    expect(reasonFor(res("A", "passed"))).toBeUndefined();
+  });
+});
+
 // ───────────────────────── RunOverview.data ─────────────────────────
 
 describe("RunOverview.data", () => {
@@ -553,6 +820,103 @@ describe("RunOverview.data", () => {
   });
 });
 
+// ───────────────────────── GroupSummary.data ─────────────────────────
+
+describe("GroupSummary.data", () => {
+  it("多 experiment、多 attempt、部分成本缺失、不同 startedAt:eval 级折叠计票(完整身份键)、总成本 null-safe 求和、lastRunAt 取组内最大值", async () => {
+    const expA = snap({
+      experimentId: "exp/a",
+      runStartedAt: "2026-07-01T08:00:00Z",
+      results: [
+        // "shared" 两轮:一败一过 → 折叠成 passed(与 exp/b 同名的 "shared" 各算各的,见下方独立测试)
+        res("shared", "failed", { attempt: 0 }),
+        res("shared", "passed", { attempt: 1, usage: { inputTokens: 1, outputTokens: 1, costUSD: 0.5 } }),
+        // "only-a" 只有 exp/a 跑过,失败、没报成本
+        res("only-a", "failed"),
+      ],
+    });
+    const expB = snap({
+      experimentId: "exp/b",
+      runStartedAt: "2026-07-03T08:00:00Z", // 比 exp/a 晚 —— lastRunAt 应取这个
+      results: [
+        // 与 exp/a 同名的 "shared":不同 experiment,必须独立计一票,不能被误合并
+        res("shared", "errored", { estimatedCostUSD: 0.2 }),
+      ],
+    });
+
+    const data = await GroupSummary.data([expA, expB]);
+
+    expect(data.experiments).toBe(2);
+    // 3 道题:exp/a 的 shared、exp/a 的 only-a、exp/b 的 shared —— 完整身份键各算各的
+    expect(data.evals).toBe(3);
+    expect(data.attempts).toBe(4); // 原始 attempt 计数:exp/a 2(shared)+1(only-a)+ exp/b 1(shared)
+    expect(data.verdicts).toEqual({ passed: 1, failed: 1, errored: 1, skipped: 0 });
+    // eval 级折叠通过率:1 / (1 + 1 + 1) = 1/3,不是 attempt 原始占比(1 passed / 4 attempts = 25%)
+    expect(data.passRate.value).toBeCloseTo(1 / 3, 10);
+    expect(data.passRate.display).toBe("33.3%");
+    expect(data.passRate.samples).toBe(3);
+    expect(data.passRate.total).toBe(3);
+    // 总成本 null-safe 求和:0.5(实测)+ 0.2(估算)= 0.7;only-a 的失败 attempt 没报成本,不计 0
+    expect(data.totalCostUSD).toBeCloseTo(0.7, 10);
+    // 最后运行时间:组内两个快照的 startedAt 取最大值(exp/b 更晚)
+    expect(data.lastRunAt).toBe(expB.startedAt);
+  });
+
+  it('跨 experiment 同名 eval 不合并:两个 experiment 各自的 "x" 独立计一票,不是被折成一票', async () => {
+    const a = snap({ experimentId: "exp/a", results: [res("x", "passed")] });
+    const b = snap({ experimentId: "exp/b", results: [res("x", "failed")] });
+    const data = await GroupSummary.data([a, b]);
+    expect(data.experiments).toBe(2);
+    expect(data.evals).toBe(2); // 只按 eval id 折叠(误把两个 experiment 的 "x" 当一道题)会变成 1
+    expect(data.verdicts).toEqual({ passed: 1, failed: 1, errored: 0, skipped: 0 });
+    expect(data.passRate.value).toBeCloseTo(0.5, 10); // 误合并会因为「任一轮过即过」变成 100%
+  });
+
+  it("全组没有任何 attempt 报成本 → totalCostUSD null,不编 0", async () => {
+    const s = snap({ experimentId: "exp/x", results: [res("A", "passed"), res("B", "failed")] });
+    const data = await GroupSummary.data([s]);
+    expect(data.totalCostUSD).toBeNull();
+  });
+
+  it("分母为 0(组内 eval 全部 skipped)→ passRate.value 为 null,不编 0%", async () => {
+    const s = snap({ experimentId: "exp/x", results: [res("A", "skipped"), res("B", "skipped")] });
+    const data = await GroupSummary.data([s]);
+    expect(data.verdicts).toEqual({ passed: 0, failed: 0, errored: 0, skipped: 2 });
+    expect(data.passRate.value).toBeNull();
+    expect(data.passRate.display).toBe("—");
+    expect(data.passRate.samples).toBe(0);
+    expect(data.passRate.total).toBe(2);
+  });
+
+  it("lastRunAt 只从传入的组 Selection 取值,不读全局最新 —— 组外快照更晚也不影响", async () => {
+    const inGroup = snap({
+      experimentId: "exp/a",
+      runStartedAt: "2026-07-01T08:00:00Z",
+      results: [res("A", "passed")],
+    });
+    const outOfGroup = snap({
+      experimentId: "exp/b",
+      runStartedAt: "2026-07-09T08:00:00Z",
+      results: [res("B", "passed")],
+    });
+    const sel = selection([inGroup, outOfGroup], []);
+    const scoped = sel.filter((s) => s.experimentId === "exp/a"); // 只留组内快照,模拟按实验组收窄的 Selection
+    const data = await GroupSummary.data(scoped);
+    expect(data.lastRunAt).toBe(inGroup.startedAt);
+    expect(data.lastRunAt).not.toBe(outOfGroup.startedAt);
+  });
+
+  it('MetricTable rows: "experiment" 的 verdicts meta 复用同一份 eval 级统计,行为不变(回归)', async () => {
+    const s = snap({
+      experimentId: "exp/x",
+      results: [res("A", "passed", { attempt: 0 }), res("A", "failed", { attempt: 1 }), res("B", "failed")],
+    });
+    const data = await MetricTable.data([s], { rows: "experiment", columns: [passRate] });
+    // A 两轮折成 passed(任一轮过即过),B 失败:1 passed / 1 failed
+    expect(data.rows[0].meta?.verdicts).toEqual({ passed: 1, failed: 1, errored: 0, skipped: 0 });
+  });
+});
+
 // ───────────────────────── DeltaTable.data ─────────────────────────
 
 describe("DeltaTable.data", () => {
@@ -622,61 +986,6 @@ describe("DeltaTable.data", () => {
   });
 });
 
-// ───────────────────────── CaseList.data ─────────────────────────
-
-describe("CaseList.data", () => {
-  it("默认只列 failed+errored;redact 作用于 error/detail/evidence;truncated 如实", async () => {
-    const s = snap({
-      experimentId: "exp/x",
-      results: [
-        res("A", "failed", {
-          assertions: [
-            {
-              name: "includes",
-              severity: "gate",
-              score: 0,
-              passed: false,
-              detail: "missing text under /Users/me/repo/src",
-              evidence: "checked /Users/me/repo/src/app.ts",
-            },
-            { name: "ok", severity: "gate", score: 1, passed: true }, // 通过的断言不列
-          ],
-        }),
-        res("B", "errored", { error: "ENOENT /Users/me/repo/tool" }),
-        res("C", "failed"),
-        res("D", "passed"),
-        res("E", "skipped"),
-      ],
-    });
-    const data = await CaseList.data([s], {
-      limit: 2,
-      redact: (text) => text.replaceAll("/Users/me/repo", "<repo>"),
-    });
-    expect(data.rows).toHaveLength(2);
-    expect(data.truncated).toBe(1); // C 被截;D/E 本就不在默认 outcomes 里
-
-    const [first, second] = data.rows;
-    expect(first.eval).toBe("A");
-    expect(first.outcome).toBe("failed");
-    expect(first.failedAssertions).toHaveLength(1);
-    expect(first.failedAssertions[0].detail).toBe("missing text under <repo>/src");
-    expect(first.failedAssertions[0].evidence).toBe("checked <repo>/src/app.ts");
-    expect(first.ref.result).toBe(0);
-
-    expect(second.eval).toBe("B");
-    expect(second.outcome).toBe("errored");
-    expect(second.error).toBe("ENOENT <repo>/tool");
-    expect(second.ref.result).toBe(1);
-  });
-
-  it("outcomes 可收窄;不传 limit 不截断", async () => {
-    const s = snap({ experimentId: "exp/x", results: [res("A", "failed"), res("B", "errored")] });
-    const onlyErrored = await CaseList.data([s], { outcomes: ["errored"] });
-    expect(onlyErrored.rows.map((r) => r.eval)).toEqual(["B"]);
-    expect(onlyErrored.truncated).toBe(0);
-  });
-});
-
 // ───────────────────────── 身份键去重 ─────────────────────────
 
 describe("身份键去重", () => {