niceeval 0.6.0 → 0.6.2

package/src/report/dual-render.test.tsx

@@ -1,3 +1,4 @@
+// cases: docs/engineering/unit-tests/reports/cases.md
 // 双面验收:每个官方组件对同一份数据,web 面(renderToStaticMarkup)与 text 面
 // 给出一致判读 —— 排序方向随 better、samples < total 角标、缺数据 — 不补 0、
 // 截断如实报剩余;text 面形态以内联快照锁定(照 report-components.mdx 的示例形态)。
@@ -35,13 +36,14 @@ import {
   costUSD,
   defineComponent,
   defineReport,
+  endToEndPassRate,
   isReportDefinition,
   padEnd,
-  passRate,
+  taskPassRate,
   renderReportToText,
   stringWidth,
 } from "./index.ts";
-import { CostPassRateComparison } from "./built-ins/index.ts";
+import { ExperimentComparison } from "./built-ins/index.ts";
 import { renderReportToStaticHtml } from "./web.ts";
 import { createTextContext, renderNodeToText, validateReportTree } from "./tree.ts";
 import {
@@ -69,7 +71,7 @@ describe("RunOverview 双面", () => {
 
   it("text 面形态:头行(含通过率)+ 判定行 + 警告行", () => {
     expect(term).toMatchInlineSnapshot(`
-      "2 experiments · 12 evals · 48 attempts · Pass rate 70% 46/48 · composed from 2 runs · latest 2026-07-01T11:30:00Z
+      "2 experiments · 12 evals · 48 attempts · End-to-end pass rate 70% 46/48 · composed from 2 runs · latest 2026-07-01T11:30:00Z
       passed 36 · failed 8 · errored 2 · skipped 2 · no data · 4m 21s
       ! snapshot covers 9 of 12 evals seen in history; re-run \`niceeval exp compare/bub\` for a full snapshot"
     `);
@@ -89,13 +91,14 @@ describe("RunOverview 双面", () => {
 
 // fixtures.overviewData 是手工摆好的终值,只验证渲染面「原样显示 MetricCell,不重算」;
 // 下面这组用真实 Selection 走一遍 RunOverview.data(= compute.ts 的 overviewData()),
-// 专门验证 totals.passRate 本身的计算口径 —— 三种通过率公式在这个 fixture 上各不相同:
-//   两级聚合(唯一官方口径,docs/feature/reports/architecture.md「指标聚合不变量」):eval a 题内 2/3 通过、eval b 题内 1,
-//     跨题均值 (2/3 + 1) / 2 = 5/6 ≈ 83.3%
-//   attempt 原始占比(旧 bug 公式,曾经的 RunOverview 现场重算):3 passed / (3 passed + 1 failed) = 75%
-//   eval 折叠投票(evalLevelStats,GroupSummary/MetricTable meta 的口径):a、b 都折成 passed → 2/2 = 100%
-// 三个数互不相同,任何一处偷懒复用另一个公式都会在这里露馅。
-describe("RunOverview.data · passRate 两级聚合口径", () => {
+// 专门验证 totals.passRate 本身的计算口径 —— 四种通过率公式在这个 fixture 上各不相同:
+//   默认端到端两级聚合:eval a 题内 2/3、eval b 题内 1、eval c errored=0,
+//     跨题均值 (2/3 + 1 + 0) / 3 = 5/9 ≈ 55.6%
+//   条件 taskPassRate 排除 errored:(2/3 + 1) / 2 = 5/6 ≈ 83.3%
+//   端到端 attempt 平铺:3 passed / (3 passed + 1 failed + 1 errored) = 60%
+//   eval 折叠投票:a、b passed,c errored → 2/3 ≈ 66.7%
+// 四个数互不相同,任何一处偷懒复用另一个公式都会在这里露馅。
+describe("RunOverview.data · endToEndPassRate 两级聚合口径", () => {
   function fakeVaryingAttemptsContext(): { selection: Selection; attempts: { evalId: string; result: { verdict: EvalResult["verdict"] } }[] } {
     const dir = "/results/compare_bub/snap-1";
     const base = {
@@ -106,7 +109,7 @@ describe("RunOverview.data · passRate 两级聚合口径", () => {
       schemaVersion: 1,
       dir,
     };
-    const mk = (evalId: string, verdict: "passed" | "failed" | "skipped", attemptIndex: number, minute: number) => ({
+    const mk = (evalId: string, verdict: "passed" | "failed" | "errored" | "skipped", attemptIndex: number, minute: number) => ({
       evalId,
       experimentId: "compare/bub",
       result: {
@@ -133,8 +136,10 @@ describe("RunOverview.data · passRate 两级聚合口径", () => {
       mk("algebra/a", "passed", 2, 2),
       // eval b:1 attempt 通过 → 题内 1
       mk("algebra/b", "passed", 0, 3),
-      // eval c:1 attempt 跳过 —— 两级聚合与 eval 折叠计票都要把它排除在分母外
-      mk("algebra/c", "skipped", 0, 4),
+      // eval c:1 attempt errored —— 默认端到端记 0,条件 taskPassRate 才排除
+      mk("algebra/c", "errored", 0, 4),
+      // eval d:1 attempt 跳过 —— 两级聚合与 eval 折叠计票都要把它排除在分母外
+      mk("algebra/d", "skipped", 0, 5),
     ];
     const evalIds = [...new Set(attempts.map((a) => a.evalId))];
     const snapshot: Snapshot = {
@@ -146,18 +151,18 @@ describe("RunOverview.data · passRate 两级聚合口径", () => {
     return { selection, attempts };
   }
 
-  it("totals.passRate = 两级聚合 83.3%,既不等于 attempt 原始占比 75%,也不等于 eval 折叠投票 100%", async () => {
+  it("totals.passRate = 端到端两级聚合 55.6%,不排除 errored,也不复用平铺或 eval 折叠投票", async () => {
     const { selection, attempts } = fakeVaryingAttemptsContext();
     const data = await RunOverview.data(selection);
 
-    expect(data.totals.passRate.value).toBeCloseTo(5 / 6, 10);
-    expect(data.totals.passRate.display).toBe("83.3%");
-    expect(data.totals.passRate.samples).toBe(4); // 5 attempts - 1 skipped(不进桶)
-    expect(data.totals.passRate.total).toBe(5);
+    expect(data.totals.passRate.value).toBeCloseTo(5 / 9, 10);
+    expect(data.totals.passRate.display).toBe("55.6%");
+    expect(data.totals.passRate.samples).toBe(5); // 6 attempts - 1 skipped(errored 进桶且记 0)
+    expect(data.totals.passRate.total).toBe(6);
 
     // attempt 原始占比(旧 bug 公式):必须与两级聚合不同,证明没有从 passed/failed/errored 现算
     const attemptFraction = data.totals.passed / (data.totals.passed + data.totals.failed + data.totals.errored);
-    expect(attemptFraction).toBeCloseTo(0.75, 10);
+    expect(attemptFraction).toBeCloseTo(0.6, 10);
     expect(attemptFraction).not.toBeCloseTo(data.totals.passRate.value as number, 3);
 
     // eval 折叠投票(evalLevelStats,GroupSummary 的口径):也必须与两级聚合不同
@@ -165,20 +170,9 @@ describe("RunOverview.data · passRate 两级聚合口径", () => {
       attempts.map((a) => ({ verdict: a.result.verdict, key: a.evalId })),
       (r) => r.key,
     );
-    expect(stats.passRate).toBeCloseTo(1, 10);
+    expect(stats.passRate).toBeCloseTo(2 / 3, 10);
     expect(stats.passRate).not.toBeCloseTo(data.totals.passRate.value as number, 3);
   });
-
-  it("web 面与 text 面显示同一个 passRate.display,覆盖率角标(4/5)两面一致", async () => {
-    const { selection } = fakeVaryingAttemptsContext();
-    const data = await RunOverview.data(selection);
-    const html = renderToStaticMarkup(<RunOverview data={data} />);
-    const term = text(<RunOverview data={data} />);
-    for (const face of [html, term]) {
-      expect(face).toContain(data.totals.passRate.display);
-      expect(face).toContain("4/5");
-    }
-  });
 });
 
 // ───────────────────────── GroupSummary ─────────────────────────
@@ -189,7 +183,7 @@ describe("GroupSummary 双面", () => {
 
   it("text 面形态:一行头(通过率 + experiment/eval 数 + failed/errored + 总成本)+ 最后运行时间", () => {
     expect(term).toMatchInlineSnapshot(`
-      "Pass rate 60% 5/6 · 2 experiments · 6 evals · failed 1 · errored 1 · $1.50
+      "End-to-end pass rate 60% 5/6 · 2 experiments · 6 evals · failed 1 · errored 1 · $1.50
       latest 2026-07-01T11:30:00Z"
     `);
   });
@@ -237,9 +231,9 @@ describe("GroupSummary 双面", () => {
     expect(term).toContain("errored 1");
   });
 
-  it("zh-CN locale:web 面走中文字典(通过率/失败/错误/总成本/实验数),text 面同理;display 数字不本地化", () => {
+  it("zh-CN locale:web 面走中文字典(端到端成功率/失败/错误/总成本/实验数),text 面同理;display 数字不本地化", () => {
     const zhHtml = renderToStaticMarkup(<GroupSummary data={groupSummaryData} locale="zh-CN" />);
-    expect(zhHtml).toContain("通过率");
+    expect(zhHtml).toContain("端到端成功率");
     expect(zhHtml).toContain("失败");
     expect(zhHtml).toContain("错误");
     expect(zhHtml).toContain("总成本");
@@ -248,7 +242,7 @@ describe("GroupSummary 双面", () => {
 
     const zhCtx = createTextContext({ width: 80, locale: "zh-CN" });
     const zhTerm = renderNodeToText(<GroupSummary data={groupSummaryData} />, zhCtx);
-    expect(zhTerm).toContain("通过率");
+    expect(zhTerm).toContain("端到端成功率");
     expect(zhTerm).toContain("失败 1");
     expect(zhTerm).toContain("错误 1");
     expect(zhTerm).toContain("60%");
@@ -462,17 +456,22 @@ describe("AttemptList 双面", () => {
   const html = renderToStaticMarkup(<AttemptList items={attemptListItems} />);
   const term = text(<AttemptList items={attemptListItems} />);
 
-  it("两面同口径:判定符 + locator + 证据能力标记 + 断言/error 明细 + 下钻命令一致", () => {
-    for (const piece of ["roots-correct", "expected x=2, got x=3", "TypeError", "@1a4a4a4", "@1c1c1c1"]) {
+  it("两面同口径:判定符 + locator + 主失败/error 摘要一致", () => {
+    for (const piece of ["roots-correct", "expected x=2", "received x=3", "TypeError", "@1a4a4a4", "@1c1c1c1"]) {
       expect(html).toContain(piece);
       expect(term).toContain(piece);
     }
+    // 结构化 error 只显示一层摘要:stack / cause / diagnostics 属于 locator 下钻详情,
+    // 随数据携带但不塞进比较列表(docs/feature/reports/library.md「AttemptList」)。
+    for (const face of [html, term]) {
+      expect(face).not.toContain("adapter.ts:42"); // error.stack
+      expect(face).not.toContain("sandbox teardown timed out"); // diagnostics[].message
+    }
     // web 面走证据室路由(#/attempt/@<locator>);text 面只列 locator 本身,不重复整条命令
     // (docs/feature/reports/architecture.md「text 输出只在整份报告末尾给一次命令模板」)。
     expect(html).toContain('href="#/attempt/@1a4a4a4"');
-    // 证据能力标记两面一致:failedAttempt 有 eval/execution/timing,erroredAttempt 只有 execution
-    expect(term).toContain("[E,X,⏱]");
-    expect(html).toContain("[E,X,⏱]");
+    expect(term).not.toMatch(/\[[EXD⏱,]+\]/);
+    expect(html).not.toMatch(/\[[EXD⏱,]+\]/);
   });
 
   it("total > items.length 时两面都如实报剩余数量", () => {
@@ -482,7 +481,7 @@ describe("AttemptList 双面", () => {
     expect(termTrunc).toContain("2 more not shown");
   });
 
-  it("text 面截断超长 assertion evidence,并保留 locator 作为完整证据入口", () => {
+  it("比较列表不内联 assertion evidence，并保留 locator 作为完整证据入口", () => {
     const longEvidence = "x".repeat(2_000);
     const item = {
       ...attemptListItems[0],
@@ -490,17 +489,17 @@ describe("AttemptList 双面", () => {
     };
     const out = text(<AttemptList items={[item]} />);
     expect(out).toContain(item.locator);
-    expect(out.replace(/\s+/g, " ")).toContain(`open ${item.locator} for full evidence`);
     expect(out).not.toContain(longEvidence);
     expect(out.length).toBeLessThan(1_000);
   });
 
-  it("text 面是逐条卡片,不是 renderTableText 的产物:空行分隔每个 attempt、断言明细逐级缩进——共享表格渲染器不产生这种嵌套形状", () => {
+  it("text 面每个 attempt 只显示一条有界结果摘要，不展开完整断言列表", () => {
     const blocks = term.split("\n\n");
-    expect(blocks).toHaveLength(attemptListItems.length); // 每个 attempt 独立一块,块间空行分隔;表格行之间不留空行
+    expect(blocks).toHaveLength(attemptListItems.length);
     const lines = term.split("\n");
-    expect(lines.some((l) => /^  \S/.test(l))).toBe(true); // 断言行缩进两格
-    expect(lines.some((l) => /^    \S/.test(l))).toBe(true); // 断言 detail 再缩进两格,是卡片的层级,不是列
+    expect(lines.some((l) => /^  \S/.test(l))).toBe(true);
+    expect(lines.some((l) => /^    \S/.test(l))).toBe(false);
+    expect(term).not.toContain("strong-evidence");
   });
 });
 
@@ -525,6 +524,16 @@ describe("EvalList 双面", () => {
     expect(blocks).toHaveLength(evalListItems.length);
     expect(term.split("\n").some((l) => /^  \S/.test(l))).toBe(true); // 展开到 attempt 的行缩进两格
   });
+
+  // bug: memory/eval-parent-repeats-attempt-failure.md
+  it("Eval 父行不复述 Attempt 失败摘要,失败题仍显示题级平均值", () => {
+    const reason = "roots-correct · expected x=2 · received x=3";
+    for (const face of [html, term]) {
+      expect(face.split(reason)).toHaveLength(2);
+      expect(face).toContain("32.0s avg");
+      expect(face).toContain("$0.12 avg");
+    }
+  });
 });
 
 describe("ExperimentList 双面", () => {
@@ -536,15 +545,59 @@ describe("ExperimentList 双面", () => {
       expect(html).toContain(piece);
       expect(term).toContain(piece);
     }
-    // 官方两级聚合 passRate.display 两面同一个数字,不各自重算
+    // 官方两级聚合 endToEndPassRate.display 两面同一个数字,不各自重算
     expect(html).toContain("50%");
     expect(term).toContain("50%");
   });
 
-  it("text 面是逐条卡片,不是 renderTableText 的产物:空行分隔每个 experiment、展开到 eval 的行缩进——表格没有这层嵌套", () => {
+  it("text 面先给比较表,再按 experiment 给 Eval / Attempt 父子表", () => {
     const blocks = term.split("\n\n");
-    expect(blocks).toHaveLength(experimentListItems.length);
-    expect(term.split("\n").some((l) => /^  \S/.test(l))).toBe(true); // 展开到 eval 的行缩进两格
+    expect(blocks).toHaveLength(experimentListItems.length + 1);
+    expect(blocks[0]).toContain("Model");
+    expect(blocks[0]).toContain("Avg");
+    expect(blocks[1]!.match(/algebra\/quadratic/g)).toHaveLength(1);
+    expect(blocks[1]).toMatch(/✗ failed\s+algebra\/quadratic[\s\S]*├─ @1a4a4a4[\s\S]*└─ @1b5b5b5/);
+  });
+
+  // bug: memory/eval-parent-repeats-attempt-failure.md
+  it("web 的 Eval 父行使用固定题级汇总,失败摘要只在 Attempt 子行出现", () => {
+    const reason = "roots-correct · expected x=2 · received x=3";
+    expect(html.split(reason)).toHaveLength(3); // 两个 failed Attempt,各显示一次
+    expect(html).toContain('<span class="nre-eval-rollup">32.0s avg · $0.12 avg</span>');
+    expect(term).toMatch(/✗ failed\s+algebra\/quadratic\s+32\.0s avg\s+\$0\.12 avg/);
+  });
+
+  it("Result 是两行收口的预览:received 携带整份多行源码时既不逐行铺表也不无限折行", () => {
+    const fatAttempt = {
+      ...experimentListItems[0]!.evalRows[0]!.attempts[0]!,
+      assertions: [{
+        name: "includes(/['\"]use cache['\"];?/)",
+        groupPath: ["Catalog reads use use-cache directive and products cache tag"],
+        severity: "gate" as const,
+        score: 0,
+        outcome: "failed" as const,
+        expected: "matches /['\"]use cache['\"];?/",
+        received: `\n// next.config.ts\n${"import type { NextConfig } from 'next';\n\n".repeat(50)}`,
+      }],
+    };
+    const fatItems = [{
+      ...experimentListItems[0]!,
+      evalRows: [{
+        ...experimentListItems[0]!.evalRows[0]!,
+        attempts: [fatAttempt],
+      }],
+    }];
+    const detail = renderNodeToText(<ExperimentList items={fatItems} />, createTextContext({ width: 100 }))
+      .split("\n\n")
+      .at(-1)!;
+    const lines = detail.split("\n");
+    // 表头 1 + eval 父行 1 + attempt 子行 ≤2(Result 列 maxLines: 2),外加 experimentId 头行
+    expect(lines.length).toBeLessThanOrEqual(6);
+    expect(detail).toContain("…");
+    expect(lines.every((l) => l.trim().length > 0)).toBe(true); // 值里的空行不进表
+    // 优先级让位:语义标题先截(全称不再出现),事实字段(expected/received)最后截
+    expect(detail).not.toContain("Catalog reads use use-cache directive and products cache tag");
+    expect(detail).toContain("expected");
   });
 });
 
@@ -892,8 +945,8 @@ function fakeContext(): { selection: Selection; results: Results } {
 }
 
 /**
- * 三份快照、三个 experiment("compare/bub"、"other/codex"、"solo"),全部通过、无成本——
- * 一个多实验 Selection 夹具:ExperimentList 出三项,MetricScatter 三个点都无成本
+ * 五份快照、两个双配置目录组 + 一个根目录单例组,全部通过、无成本——
+ * 一个多实验 Selection 夹具:ExperimentList 出五项,MetricScatter 五个点都无成本
  * (0 可画点,如实走空态)。`filter` 落实真实语义(不像 fakeContext 那样恒等返回自己)。
  */
 function fakeMultiGroupContext(): { selection: Selection; results: Results } {
@@ -936,7 +989,9 @@ function fakeMultiGroupContext(): { selection: Selection; results: Results } {
 
   const snapshots = [
     mkSnapshot("compare/bub", "bub", "compare_bub/snap-1"),
+    mkSnapshot("compare/codex", "codex", "compare_codex/snap-1"),
     mkSnapshot("other/codex", "codex", "other_codex/snap-1"),
+    mkSnapshot("other/bub", "bub", "other_bub/snap-1"),
     mkSnapshot("solo", "bub", "solo/snap-1"),
   ];
 
@@ -987,11 +1042,11 @@ describe("defineReport + 渲染入口", () => {
     const out = await renderReportToText(report, fakeContext(), { width: 100 });
     // RunOverview(data 形态,预计算)
     expect(out).toContain("1 experiment · 2 evals · 2 attempts");
-    // ExperimentList:主行 + eval 级折叠计票 + 失败诊断(locator 徽标带证据能力标记)
-    expect(out).toContain("compare/bub · bub");
-    expect(out).toContain("1 passed / 1 failed");
+    // ExperimentList:主行 + eval 级折叠计票 + 逐 Attempt locator 与失败诊断
+    expect(out).toMatch(/compare\/bub\s+default\s+bub/);
+    expect(out).toMatch(/1 passed[\s\S]*?\/ 1\s+failed/);
     expect(out).toContain("50%");
-    expect(out).toMatch(/✗ algebra\/y\s+@[0-9a-z]+✗/);
+    expect(out).toMatch(/✗ failed\s+algebra\/y[\s\S]*└─ @[0-9a-z]+/);
     // 自己的口径:成绩单
     expect(out).toContain("考试成绩单");
     expect(out).toContain("bub");
@@ -1041,7 +1096,7 @@ describe("defineReport + 渲染入口", () => {
     // selection-form 的官方组件(ExperimentList/EvalList/AttemptList 没有 selection-form,
     // 这条契约不适用于它们)。
     expect(() =>
-      renderToStaticMarkup(<MetricScatter selection={selection} points="experiment" x={costUSD} y={passRate} />),
+      renderToStaticMarkup(<MetricScatter selection={selection} points="experiment" x={costUSD} y={taskPassRate} />),
     ).toThrow(/received unresolved \(selection-form\) props/);
   });
 });
@@ -1051,12 +1106,12 @@ describe("defineReport + 渲染入口", () => {
 // ts-expect-error 注释对应一处编译错误。直接标注 Props 类型(而非 JSX)——JSX 的 union
 // 属性检查对「缺必填字段」较宽松,直接的类型赋值才严格钉住互斥不变量:同时传 data 与
 // selection、或两者都不传、或 selection 形态缺必填计算选项,全部编译失败。正向 JSX 用法由
-// CostPassRateComparison / defineReport 报告在同一文件里编译验证。
+// ExperimentComparison / defineReport 报告在同一文件里编译验证。
 function metricScatterPropsTypeChecks(selection: Selection, data: ScatterData): void {
   const ok1: MetricScatterProps = { data }; // 合法:data 形态
-  const ok2: MetricScatterProps = { selection, points: "experiment", series: "agent", x: costUSD, y: passRate }; // 合法:selection 形态
+  const ok2: MetricScatterProps = { selection, points: "experiment", series: "agent", x: costUSD, y: taskPassRate }; // 合法:selection 形态
   // @ts-expect-error 同时传 data 与 selection:非法
-  const bad1: MetricScatterProps = { data, selection, points: "experiment", x: costUSD, y: passRate };
+  const bad1: MetricScatterProps = { data, selection, points: "experiment", x: costUSD, y: taskPassRate };
   // @ts-expect-error data 与 selection 都不传:非法
   const bad2: MetricScatterProps = { pointHref: () => "/x" };
   // @ts-expect-error selection 形态缺必填的 x / y:非法
@@ -1070,56 +1125,132 @@ function metricScatterPropsTypeChecks(selection: Selection, data: ScatterData):
 
 void metricScatterPropsTypeChecks;
 
-// ───────────────────────── CostPassRateComparison(内置默认报告)─────────────────────────
+// ───────────────────────── ExperimentComparison(内置默认报告)─────────────────────────
 
-describe("CostPassRateComparison", () => {
-  it("是普通 ReportDefinition;text 面 = 成本×通过率散点 + 实验列表,别无它物", async () => {
-    expect(isReportDefinition(CostPassRateComparison)).toBe(true);
-    const out = await renderReportToText(CostPassRateComparison, fakeContext(), { width: 100 });
+describe("ExperimentComparison", () => {
+  it("是普通 ReportDefinition;单组 text 面 = 组摘要 + 成本×端到端成功率散点 + 实验列表", async () => {
+    expect(isReportDefinition(ExperimentComparison)).toBe(true);
+    const out = await renderReportToText(ExperimentComparison, fakeContext(), { width: 100 });
     // 散点:fakeContext 无成本数据 → 0 可画点,显式说明缺哪两个指标(而不是画一张空图)
     expect(out).toContain("No data to plot");
     expect(out).not.toContain("better → upper right");
     // 实验列表主行 + eval 级折叠计票 + 失败诊断(ExperimentList.data 在 build() 里直接 await)
-    expect(out).toContain("compare/bub · bub");
-    expect(out).toContain("1 passed / 1 failed");
+    // 组已由 section 标题 "compare" 标注,列表行传 relativeTo=组键 去掉前缀,只显示 id 末段
+    expect(out).toMatch(/^compare$/m);
+    expect(out).toMatch(/^\s*bub\s+default\s+bub/m);
+    expect(out).not.toContain("compare/bub");
+    expect(out).toMatch(/1 passed[\s\S]*?\/ 1\s+failed/);
     expect(out).toContain("50%");
-    expect(out).toMatch(/✗ algebra\/y\s+@[0-9a-z]+✗/);
-    // 只有两个直接业务组件:没有 RunOverview / GroupSummary / Section 分组
+    expect(out).toMatch(/✗ failed\s+algebra\/y[\s\S]*└─ @[0-9a-z]+/);
+    // 单组直接进入详情，不出现多组查看命令
     expect(out).not.toContain("Current verdicts");
+    expect(out).not.toContain("niceeval show --experiment");
   });
 
-  it("web 面:散点空态 + 实验列表 <details> 展开区,无 <script>,无 Section 分组", async () => {
-    const html = await renderReportToStaticHtml(CostPassRateComparison, fakeContext());
+  it("web 面:完整组索引 + 首组 panel + 实验列表 <details> 展开区,无 <script>", async () => {
+    const html = await renderReportToStaticHtml(ExperimentComparison, fakeContext());
+    expect(html).toContain("nre-experiment-group-tabs");
+    expect(html).toMatch(/<details[^>]*data-nre-experiment-group-panel="0"[^>]*\sopen=""/);
     expect(html).toContain("nre-metric-scatter");
     expect(html).toContain("nre-scatter-empty"); // 0 可画点的空态
-    expect(html).toContain('<li class="nre-experiment-entry">');
+    expect(html).toContain('<details class="nre-experiment-entry">');
+    // 行标签去掉组前缀只显示 id 末段;完整 id 仍留在 data-sort-value 作排序/身份键
+    expect(html).toMatch(/nre-experiment-id[^>]*>\s*bub\s*<\/b>/);
+    expect(html).toContain('data-sort-value="compare/bub"');
+    expect(html).toContain("nre-experiment-head");
+    expect(html).toContain('data-nre-experiment-filter=""');
     expect(html).toContain("nre-experiment-evals");
-    expect(html).not.toContain("nre-section");
     expect(html).not.toContain("<script");
   });
 
   it("locale 变体:en / zh-CN 都渲染(chrome 分语言),散点空态两面同一事实", async () => {
-    const zhHtml = await renderReportToStaticHtml(CostPassRateComparison, fakeContext(), { locale: "zh-CN" });
-    expect(zhHtml).toContain("成功率"); // passRate 的 zh-CN label(ExperimentList 主行)
-    const enHtml = await renderReportToStaticHtml(CostPassRateComparison, fakeContext(), { locale: "en" });
-    expect(enHtml).toContain("Pass rate");
-    const zhText = await renderReportToText(CostPassRateComparison, fakeContext(), { locale: "zh-CN" });
+    const zhHtml = await renderReportToStaticHtml(ExperimentComparison, fakeContext(), { locale: "zh-CN" });
+    expect(zhHtml).toContain("端到端成功率");
+    const enHtml = await renderReportToStaticHtml(ExperimentComparison, fakeContext(), { locale: "en" });
+    expect(enHtml).toContain("End-to-end pass rate");
+    const zhText = await renderReportToText(ExperimentComparison, fakeContext(), { locale: "zh-CN" });
     expect(zhText).toContain("没有可绘制的数据"); // 散点空态 zh
-    const enText = await renderReportToText(CostPassRateComparison, fakeContext(), { locale: "en" });
+    const enText = await renderReportToText(ExperimentComparison, fakeContext(), { locale: "en" });
     expect(enText).toContain("No data to plot");
   });
 
-  it("多实验 fixture:每个 experiment 一项,散点如实处理全部无成本", async () => {
-    const out = await renderReportToText(CostPassRateComparison, fakeMultiGroupContext(), { width: 100 });
-    // 三个 experiment 的身份行都出现(experimentId · agent,不再截短成最后一段)
-    expect(out).toContain("compare/bub · bub");
-    expect(out).toContain("other/codex · codex");
-    expect(out).toContain("solo · bub");
-    // 散点空态(三点都无成本)
-    expect(out).toContain("No data to plot");
-    // 没有组分 Section 标题(不再按目录前缀分组)
-    expect(out).not.toMatch(/^compare$/m);
-    const html = await renderReportToStaticHtml(CostPassRateComparison, fakeMultiGroupContext());
-    expect(html).not.toContain("nre-section");
+  it("多组 fixture:text 只给组索引与命令;web 保留全部独立 panel", async () => {
+    const out = await renderReportToText(ExperimentComparison, fakeMultiGroupContext(), { width: 100 });
+    expect(out).toContain("Experiment groups");
+    expect(out).toContain("niceeval show --experiment compare");
+    expect(out).toContain("niceeval show --experiment other");
+    expect(out).toContain("niceeval show --experiment solo");
+    expect(out).not.toMatch(/compare\/bub\s+default\s+bub/);
+    expect(out).not.toContain("No data to plot");
+    const html = await renderReportToStaticHtml(ExperimentComparison, fakeMultiGroupContext());
+    expect(html.match(/data-nre-experiment-group-panel=/g)).toHaveLength(3);
+    expect(html.match(/<details[^>]*nre-experiment-group-panel[^>]*\sopen=""/g)).toHaveLength(1);
+    expect(html).toContain("compare/bub");
+    expect(html).toContain("other/codex");
+    expect(html).toContain("solo");
+  });
+
+  it(".data():组内三个子块 = 对该组单独调用 GroupSummary / MetricScatter / ExperimentList", async () => {
+    const { selection } = fakeContext();
+    const data = await ExperimentComparison.data(selection);
+    expect(data.groups).toHaveLength(1);
+    expect(data.groups[0]!.key).toBe("compare");
+    expect(data.groups[0]!.summary).toEqual(await GroupSummary.data(selection));
+    expect(data.groups[0]!.scatter).toEqual(
+      await MetricScatter.data(selection, { points: "experiment", series: "agent", x: costUSD, y: endToEndPassRate }),
+    );
+    expect(data.groups[0]!.experiments).toEqual(await ExperimentList.data(selection));
+  });
+
+  it(".data():计算前按完整父路径分区,两个目录组和根目录单例互不串数据或 refs", async () => {
+    const { selection } = fakeMultiGroupContext();
+    const data = await ExperimentComparison.data(selection);
+    expect(data.groups.map((group) => group.key)).toEqual(["compare", "other", "solo"]);
+
+    for (const group of data.groups) {
+      const groupSelection = selection.filter((snapshot) => {
+        const slash = snapshot.experimentId.lastIndexOf("/");
+        const key = slash === -1 ? snapshot.experimentId : snapshot.experimentId.slice(0, slash);
+        return key === group.key;
+      });
+      expect(group.summary).toEqual(await GroupSummary.data(groupSelection));
+      expect(group.scatter).toEqual(
+        await MetricScatter.data(groupSelection, {
+          points: "experiment",
+          series: "agent",
+          x: costUSD,
+          y: endToEndPassRate,
+        }),
+      );
+      expect(group.experiments).toEqual(await ExperimentList.data(groupSelection));
+      expect(group.scatter.rows.every((row) => group.experiments.some((item) => item.experimentId === row.key))).toBe(
+        true,
+      );
+    }
+
+    expect(data.groups.find((group) => group.key === "compare")!.experiments.map((item) => item.experimentId)).toEqual([
+      "compare/bub",
+      "compare/codex",
+    ]);
+    expect(data.groups.find((group) => group.key === "other")!.experiments.map((item) => item.experimentId)).toEqual([
+      "other/bub",
+      "other/codex",
+    ]);
+    expect(data.groups.find((group) => group.key === "solo")!.experiments.map((item) => item.experimentId)).toEqual([
+      "solo",
+    ]);
+  });
+
+  it("组合件形态:<ExperimentComparison data={await .data(selection)}/> 与裸跑(build 面)渲染同一事实", async () => {
+    const data = await ExperimentComparison.data(fakeContext().selection);
+    const asComponent = defineReport(() => <ExperimentComparison data={data} />);
+    // text 面逐字相等:同一份数据、同一套子组件口径
+    const componentText = await renderReportToText(asComponent, fakeContext(), { width: 100 });
+    const bareText = await renderReportToText(ExperimentComparison, fakeContext(), { width: 100 });
+    expect(componentText).toBe(bareText);
+    // web 面同一事实
+    const componentHtml = await renderReportToStaticHtml(asComponent, fakeContext());
+    const bareHtml = await renderReportToStaticHtml(ExperimentComparison, fakeContext());
+    expect(componentHtml).toBe(bareHtml);
   });
 });

package/src/report/flag.ts

@@ -1,8 +1,15 @@
-// flag():把 experiment 声明的 flags 当维度或轴(docs/feature/reports/library.md「维度与 flags」)。
+// flag() / config():把 experiment 声明的变量当维度或轴(docs/feature/reports/library.md「维度与 flags」)。
 // 变量来自配置,不来自命名 —— 报告不解析 experiment id 字符串抠变量。
+// flag() 只读 `ExperimentDef.flags` 里显式声明的 KV;model / reasoningEffort / budget / runs
+// 这类顶层运行配置不在 flags 里,用 config() 读快照的 ExperimentRunInfo 投影。
 
-import type { FlagRef } from "./types.ts";
+import type { ConfigRef, FlagRef } from "./types.ts";
 
+/**
+ * 把 experiment 声明的一个 flag 当分组维度(series / rows / columns / points 槽)或数值轴
+ * (MetricLine 的 x 槽)。只读 `ExperimentDef.flags` 里显式声明的 KV;未声明的 experiment
+ * 分组归 `(unset)`,作轴不画点并报告缺失。
+ */
 export function flag(
   name: string,
   opts?: {
@@ -16,3 +23,24 @@ export function flag(
   }
   return { kind: "flag", name, label: opts?.label, unit: opts?.unit };
 }
+
+/**
+ * 把一项顶层运行配置当分组维度或数值轴,与 {@link flag} 同一套用法。读快照的
+ * `ExperimentRunInfo` 投影(可用键是那张接口的字段全集),外加桥接到快照顶层权威字段的
+ * `model` / `agent` 两个键。未投影的值分组归 `(unset)`,作轴不画点并报告缺失。
+ */
+export function config(
+  name: string,
+  opts?: {
+    /** 组标签 / 轴标签;函数形态把投影值折成组名(如 `(v) => \`effort ${v}\``)。 */
+    label?: string | ((value: string | number | boolean) => string);
+    unit?: string;
+  },
+): ConfigRef {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error(
+      "config: name must be a non-empty string (an ExperimentRunInfo field, or the bridged \"model\" / \"agent\" keys).",
+    );
+  }
+  return { kind: "config", name, label: opts?.label, unit: opts?.unit };
+}