niceeval 0.9.1 → 0.10.2

package/src/report/{dual-render.test.tsx → runtime/dual-render.test.tsx}

@@ -7,9 +7,9 @@
 import { renderToStaticMarkup } from "react-dom/server";
 import { describe, expect, it } from "vitest";
 
-import type { EvalResult, Verdict } from "../types.ts";
-import type { AttemptHandle, Results, Scope, ScopeWarning, Snapshot } from "../results/index.ts";
-import { makeScope } from "../results/select.ts";
+import type { EvalResult, Verdict } from "../../types.ts";
+import type { AttemptHandle, Results, Scope, ScopeWarning, Snapshot } from "../../results/index.ts";
+import { makeScope } from "../../results/select.ts";
 import {
   createTextContext,
   defineComponent,
@@ -18,36 +18,31 @@ import {
   validateReportTree,
   ResolveMemo,
   type ReportNode,
-} from "./tree.ts";
+} from "../definition/tree.ts";
+import { buildReportMeta, defineReport, FALLBACK_REPORT_TITLE, resolveReportTitle } from "../definition/report.ts";
 import {
-  buildReportMeta,
-  defineReport,
-  FALLBACK_REPORT_TITLE,
   pickReportPage,
   renderReportToText,
+  renderReportTreeToText,
+  ReportPageNeedsLocatorError,
   ReportPageNotFoundError,
-  resolveReportTitle,
-} from "./report.ts";
-import { renderReportToStaticHtml } from "./web.ts";
-import {
-  AttemptList,
-  CopyFixPrompt,
-  ExperimentComparison,
-  ExperimentList,
-  FailureList,
-  Hero,
-  MetricBars,
-  MetricMatrix,
-  MetricScatter,
-  MetricTable,
-  ScopeSummary,
-  ScopeWarnings,
-  TraceWaterfall,
-} from "./components.tsx";
-import { Col, Row, Section, Style, Tab, Table, Tabs, Text } from "./primitives.tsx";
-import { attemptListData, metricScatterData } from "./compute.ts";
-import { costUSD, defineMetric, endToEndPassRate } from "./metrics.ts";
-import builtInReport, { standard } from "./built-in/index.tsx";
+} from "./text.ts";
+import { renderReportToStaticHtml, renderReportTreeToStaticHtml } from "./web.ts";
+import { AttemptList, ExperimentList, FailureList } from "../components/entity-lists/index.tsx";
+import { CopyFixPrompt, Hero, ScopeWarnings, TraceWaterfall } from "../components/site-components/index.tsx";
+import { ExperimentComparison, ScopeSummary } from "../components/summaries/index.tsx";
+import { MetricBars, MetricMatrix, MetricScatter, MetricTable } from "../components/metric-views/index.tsx";
+import { AttemptDetail } from "../components/attempt-detail/index.tsx";
+import { Col, Grid, Row, Section, Stat, Style, Tab, Table, Tabs, Text } from "../definition/primitives.tsx";
+import { stringWidth } from "../model/text-layout.ts";
+import { attemptListData, experimentListData } from "../components/entity-lists/compute.ts";
+import { metricScatterData } from "../components/metric-views/compute.ts";
+import { scopeSummaryData } from "../components/summaries/compute.ts";
+import { costUSD, defineMetric, endToEndPassRate } from "../model/metrics.ts";
+import { label } from "../model/flag.ts";
+import builtInReport, { standard, standardAttemptPage } from "../built-in/index.tsx";
+import type { AttemptEvidence } from "../../results/attempt-evidence.ts";
+import { encodeAttemptLocator } from "../../results/locator.ts";
 
 // ───────────────────────── fake 数据 ─────────────────────────
 
@@ -133,13 +128,32 @@ function resultsOf(snapshots: Snapshot[]): Results {
   } as unknown as Results;
 }
 
+/** 最小 AttemptEvidence fixture:只用于验证 standardAttemptPage 的渲染管线接线,不摆事实。 */
+function attemptEvidenceOf(): AttemptEvidence {
+  const identity = { experimentId: "exp/a", snapshotStartedAt: "2026-07-01T00:00:00.000Z", evalId: "eval/one", attempt: 0 };
+  return {
+    locator: encodeAttemptLocator(identity),
+    identity,
+    result: { id: "eval/one", agent: "agent-x", verdict: "passed" as Verdict, attempt: 0, durationMs: 1000, assertions: [] },
+    events: null,
+    evalSource: null,
+    execution: null,
+    diff: null,
+    trace: null,
+    artifactPaths: { dir: "/results/exp/a/eval-one/a0" },
+    capabilities: { source: false, execution: false, timing: false, diff: false },
+  };
+}
+
 /** 管线便捷入口:resolve + validate + text 渲染,报告声明用最小 meta。 */
 async function renderTreeText(node: ReportNode, scope: Scope, width = 100): Promise<string> {
   const definition = defineReport(node);
-  const resolved = await resolveReportTree(pickReportPage(definition).content, {
+  const page = pickReportPage(definition);
+  const resolved = await resolveReportTree(page.content, {
     scope,
     results: resultsOf(scope.snapshots),
-    report: buildReportMeta(definition, scope, "report"),
+    report: buildReportMeta(definition, scope),
+    page: { id: page.id, input: "scope" },
     memo: new ResolveMemo(),
   });
   validateReportTree(resolved);
@@ -336,14 +350,14 @@ describe("组合组件(函数形态)", () => {
     expect(composed).toBe(manual);
   });
 
-  it("ctx.results 可自行挑 Snapshot[] 喂 input;ctx.report 携带走完回退链的 title 与当前 pageId", async () => {
+  it("ctx.results 可自行挑 Snapshot[] 喂 input;ctx.report 携带走完回退链的 title,ctx.page 携带当前页 id", async () => {
     const named = snap({ experimentId: "hist/a", name: "Memory Evals", results: [res("q", "passed")] });
     const scope = scopeOf([named]);
     const Meta = defineComponent((_props: Record<never, never>, ctx) => {
       const history = ctx.results.experiments[0]!.snapshots;
       return (
         <Col>
-          <Text>{`title=${typeof ctx.report.title === "string" ? ctx.report.title : "?"} page=${ctx.report.pageId}`}</Text>
+          <Text>{`title=${typeof ctx.report.title === "string" ? ctx.report.title : "?"} page=${ctx.page.id}`}</Text>
           <ScopeSummary input={history} />
         </Col>
       );
@@ -507,13 +521,13 @@ describe("text/web 双面同源", () => {
         res("algebra/retry", "passed", { attempt: 1 }),
       ],
     });
-    const text = await renderTreeText(<ExperimentList relativeTo="grp" />, scopeOf([s]), 160);
+    const text = await renderTreeText(<ExperimentList />, scopeOf([s]), 160);
     expect(text.match(/algebra\/retry/g)).toHaveLength(1); // Eval 父行只出现一次
     expect(text).toContain("├─");
     expect(text).toContain("└─");
     // 失败摘要只在 Attempt 子行(父行不复述)
     expect(text.match(/equals\(42\)/g)).toHaveLength(1);
-    // relativeTo:行标签只显示末段
+    // 行标签默认缩成最短唯一后缀
     expect(text).toContain("exp-a");
   });
 });
@@ -659,6 +673,281 @@ describe("Table 与文本排版原语", () => {
   });
 });
 
+// ───────────────────────── Grid / Stat / Section.meta ─────────────────────────
+
+describe("Grid / Stat / Section.meta", () => {
+  const ctx = (width = 100) => createTextContext({ width });
+
+  it("展平数组 / Fragment,空分支不占格,任意 ReportNode 可作 cell,Col 内多个 Stat 保持同一格", () => {
+    const groups = ["a", "b"];
+    const tree = (
+      <Grid columns={4}>
+        {groups.map((g) => (
+          <Stat key={g} label={g} value={g} />
+        ))}
+        {null}
+        {undefined}
+        {false}
+        <>
+          <Text>free block</Text>
+        </>
+        <Col>
+          <Stat label="col-stat-1" value="1" />
+          <Stat label="col-stat-2" value="2" />
+        </Col>
+      </Grid>
+    );
+    const text = renderNodeToText(tree, ctx());
+    const html = renderToStaticMarkup(tree as never);
+    // a, b, free block, Col(两个 Stat) = 4 格;空分支不占格
+    expect((html.match(/nre-grid-cell/g) ?? []).length).toBe(4);
+    for (const face of [text, html]) {
+      expect(face).toContain("free block");
+      expect(face).toContain("col-stat-1");
+      expect(face).toContain("col-stat-2");
+    }
+    // 两面 cell 顺序一致:a 在 b 之前,free block 在 Col 之前
+    expect(text.indexOf("a")).toBeLessThan(text.indexOf("b"));
+    expect(text.indexOf("free block")).toBeLessThan(text.indexOf("col-stat-1"));
+  });
+
+  it("全部子节点为空分支时 0 格,text 面输出空串", () => {
+    const tree = <Grid columns={3}>{[null, false, undefined]}</Grid>;
+    expect(renderNodeToText(tree, ctx())).toBe("");
+  });
+
+  for (const bad of [0, -1, 1.5, NaN, Infinity]) {
+    it(`columns={${bad}} 给完整用户反馈`, () => {
+      const tree = <Grid columns={bad}>{<Stat label="x" value="y" />}</Grid>;
+      expect(() => renderNodeToText(tree, ctx())).toThrow(/columns/);
+      expect(() => renderToStaticMarkup(tree as never)).toThrow(/columns/);
+    });
+  }
+
+  it("columns=1 与 columns 大于 cell 数都正常渲染;variant / density 默认 plain / regular", () => {
+    const single = <Grid columns={1}>{[<Stat key="a" label="a" value="1" />, <Stat key="b" label="b" value="2" />]}</Grid>;
+    expect(renderNodeToText(single, ctx())).toContain("a");
+    const roomy = (
+      <Grid columns={99}>
+        <Stat label="only" value="1" />
+      </Grid>
+    );
+    const html = renderToStaticMarkup(roomy as never);
+    expect(html).toContain("nre-grid--plain");
+    expect(html).toContain("nre-grid--regular");
+    expect(html).toContain('style="--nre-grid-max-columns:99"');
+  });
+
+  it("web 初始 HTML 含全部格、稳定 root/cell/variant/density class 与最大列数事实,无 JS 也完整可读", () => {
+    const tree = (
+      <Grid columns={3} variant="boxed" density="compact">
+        <Stat label="one" value="1" />
+        <Stat label="two" value="2" />
+        <Stat label="three" value="3" />
+      </Grid>
+    );
+    const html = renderToStaticMarkup(tree as never);
+    expect(html).toContain("nre-grid--boxed");
+    expect(html).toContain("nre-grid--compact");
+    expect(html).toContain('style="--nre-grid-max-columns:3"');
+    expect((html.match(/nre-grid-cell/g) ?? []).length).toBe(3);
+    expect(html).toContain("one");
+    expect(html).toContain("two");
+    expect(html).toContain("three");
+    expect(html).not.toMatch(/<script/);
+    expect(html).not.toContain("hydrat");
+  });
+
+  it("boxed 每个 cell 四边完整;plain 只去掉边框与内边距,不改变列数与内容宽", () => {
+    const tree = (variant: "plain" | "boxed") => (
+      <Grid columns={2} variant={variant}>
+        <Stat label="left" value="1" />
+        <Stat label="right" value="2" />
+      </Grid>
+    );
+    const boxed = renderNodeToText(tree("boxed"), ctx(80));
+    const plain = renderNodeToText(tree("plain"), ctx(80));
+    expect(boxed.match(/┌/g)?.length).toBe(2);
+    expect(boxed.match(/┐/g)?.length).toBe(2);
+    expect(boxed.match(/└/g)?.length).toBe(2);
+    expect(boxed.match(/┘/g)?.length).toBe(2);
+    expect(plain).not.toContain("┌");
+    expect(plain).toContain("left");
+    expect(plain).toContain("right");
+    for (const line of [...boxed.split("\n"), ...plain.split("\n")]) {
+      expect(stringWidth(line)).toBeLessThanOrEqual(80);
+    }
+  });
+
+  it("compact 不合并或丢弃字段,label/value/detail 三者仍全部可见", () => {
+    const text = renderNodeToText(
+      <Grid columns={2} variant="boxed" density="compact">
+        <Stat label="label-x" value="value-x" detail="detail-x" />
+        <Stat label="label-y" value="value-y" detail="detail-y" />
+      </Grid>,
+      ctx(80),
+    );
+    for (const token of ["label-x", "value-x", "detail-x", "label-y", "value-y", "detail-y"]) {
+      expect(text).toContain(token);
+    }
+  });
+
+  it("text 宽面使用声明列数,继续收窄降为一列,不丢任何 cell", () => {
+    const cells = Array.from({ length: 6 }, (_, i) => <Stat key={i} label={`s${i}`} value={i} />);
+    const wide = renderNodeToText(<Grid columns={6}>{cells}</Grid>, ctx(200));
+    for (let i = 0; i < 6; i++) expect(wide).toContain(`s${i}`);
+    const narrow = renderNodeToText(<Grid columns={6}>{cells}</Grid>, ctx(15));
+    for (let i = 0; i < 6; i++) expect(narrow).toContain(`s${i}`);
+  });
+
+  it("Stat:LocalizedText、number(按 locale 格式化)、null(—)、数字 0、detail 省略与四种 tone", () => {
+    const html0 = renderToStaticMarkup(<Stat label="zero" value={0} /> as never);
+    expect(html0).toContain(">0<");
+    expect(html0).not.toContain("—");
+    const htmlNull = renderToStaticMarkup(<Stat label="none" value={null} /> as never);
+    expect(htmlNull).toContain("—");
+    const htmlNumber = renderToStaticMarkup(<Stat label="n" value={1234} /> as never);
+    expect(htmlNumber).toContain("1,234"); // 默认 locale "en"
+    const htmlLocalized = renderToStaticMarkup(<Stat label={{ en: "Label", "zh-CN": "标签" }} value="v" /> as never);
+    expect(htmlLocalized).toContain("Label");
+    // detail 省略:text 面不留空行(恰好两行:label、value)
+    const textNoDetail = renderNodeToText(<Stat label="l" value="v" />, ctx());
+    expect(textNoDetail.split("\n")).toEqual(["l", "v"]);
+    const textWithDetail = renderNodeToText(<Stat label="l" value="v" detail="d" />, ctx());
+    expect(textWithDetail.split("\n")).toEqual(["l", "v", "d"]);
+    for (const tone of ["neutral", "positive", "negative", "warning"] as const) {
+      const html = renderToStaticMarkup(<Stat label="t" value="v" tone={tone} /> as never);
+      expect(html).toContain(`nre-stat--${tone}`);
+    }
+    // tone 不出现在 text 面(不新造 ANSI 颜色协议,不泄露内部词)
+    const textToned = renderNodeToText(<Stat label="t" value="v" tone="positive" />, ctx());
+    expect(textToned).not.toMatch(/positive|negative|warning|neutral/);
+  });
+
+  it("Section.meta:web 面同行(header 结构),text 面同行右对齐;省略 meta 时旧行为不变", () => {
+    const withMeta = (
+      <Section title="Title" meta="6/6 done">
+        <Text>body</Text>
+      </Section>
+    );
+    const html = renderToStaticMarkup(withMeta as never);
+    expect(html).toContain("nre-section-header");
+    expect(html).toContain("nre-section-meta");
+    expect(html).toContain("Title");
+    expect(html).toContain("6/6 done");
+    const text = renderNodeToText(withMeta, ctx());
+    const firstLine = text.split("\n")[0];
+    expect(firstLine).toContain("Title");
+    expect(firstLine).toContain("6/6 done");
+    expect(stringWidth(firstLine)).toBeLessThanOrEqual(100);
+
+    // 放不下时以两格缩进换行(meta 本身够长,createTextContext 最窄也钳在 20 列)
+    const longMeta = (
+      <Section title="Title" meta="this meta text is intentionally too long to fit on the title line">
+        <Text>body</Text>
+      </Section>
+    );
+    const narrowText = renderNodeToText(longMeta, ctx(20));
+    const lines = narrowText.split("\n");
+    expect(lines[0]).toBe("Title");
+    expect(lines[1]!.startsWith("  ")).toBe(true);
+    expect(narrowText).toContain("intentionally");
+
+    // 省略 meta:旧结构不变(裸 <h2>,无 header 包裹)
+    const withoutMeta = (
+      <Section title="Plain">
+        <Text>body</Text>
+      </Section>
+    );
+    const htmlPlain = renderToStaticMarkup(withoutMeta as never);
+    expect(htmlPlain).not.toContain("nre-section-header");
+    expect(htmlPlain).toContain('<h2 class="nre-section-title">Plain</h2>');
+  });
+
+  it("目标运行总览示例:恰好 100 显示列时两个 Grid 都降为三列,21 个 Stat 全部存在且索引递增,逐行不越界", () => {
+    const groupStats: Array<[string, string, string]> = [
+      ["平均净 R / case", "+0.479 R", "累计 +2.877 R"],
+      ["单笔期望", "+0.093 R", "已成交交易"],
+      ["Episode 胜率", "66.7%", "4 / 6 cases"],
+      ["MFE / MAE", "0.87 / 0.71", "捕获 4.3%"],
+      ["交易胜率", "41.9%", "13 / 31 笔"],
+      ["持有 / 回撤", "1.5 / 1.47 R", "bars / max DD"],
+      ["方向命中", "66.7%", "cutoff → horizon"],
+      ["完成率", "100.0%", "6 / 6"],
+      ["Profit Factor", "1.29", "盈利 R / 亏损 R"],
+      ["执行成本", "$1.09", "0 bps"],
+      ["参与 / 成交", "100.0% / 100.0%", "6 个方向订单"],
+      ["耗时 / 首次决策", "207.4 s / B0.8", "34.7 tools · 84927 tokens"],
+    ];
+    const compactStats: Array<[string, string]> = [
+      ["初始 1H", "0 bars"],
+      ["初始日线", "250 bars"],
+      ["初始周线", "104 bars"],
+      ["回放窗口", "— sessions"],
+      ["回放 1H", "20 bars"],
+      ["首次决策", "B0 起自主决定"],
+      ["待成交窗口", "— bars"],
+      ["强平提醒", "T-5 → T-1"],
+      ["长桥日 / 周回填", "0 / 0"],
+    ];
+    const cols: ReportNode[] = [];
+    for (let i = 0; i < groupStats.length; i += 2) {
+      const [a, b] = [groupStats[i]!, groupStats[i + 1]!];
+      cols.push(
+        <Col key={i}>
+          <Stat label={a[0]} value={a[1]} detail={a[2]} tone="positive" />
+          <Stat label={b[0]} value={b[1]} detail={b[2]} tone="positive" />
+        </Col>,
+      );
+    }
+    const tree = (
+      <Section title="运行总览" meta="6/6 完成 · 31 笔完整交易">
+        <Grid columns={6} variant="boxed">
+          {cols}
+        </Grid>
+        <Grid columns={9} variant="boxed" density="compact">
+          {compactStats.map(([label, value]) => (
+            <Stat key={label} label={label} value={value} />
+          ))}
+        </Grid>
+      </Section>
+    );
+    const text = renderNodeToText(tree, ctx(100));
+    for (const line of text.split("\n")) {
+      expect(stringWidth(line)).toBeLessThanOrEqual(100);
+    }
+    // 全部 21 个 Stat 都存在(声明序不丢格)
+    for (const [label] of [...groupStats, ...compactStats]) {
+      expect(text.indexOf(label), `缺少 ${label}`).toBeGreaterThan(-1);
+    }
+    // row-major 顺序:3 列的一整个物理行文本互相交织(同一 box 行内左右并排打印),
+    // 但物理行与物理行之间是严格顺序的(用 \n\n 隔开)——按行分组断言 min/max 递增,
+    // 比断言展平后的逐字段顺序更贴合实际排版,不会把「同一行内左右并排」误判成乱序。
+    // lastIndexOf:第二个 Grid 的「首次决策」是第一个 Grid「耗时 / 首次决策」的子串,
+    // indexOf 会先命中那个子串——两个 Grid 各自的真实位置都是各自标签的最后一次出现。
+    const rowIndexRange = (labels: string[]): { min: number; max: number } => {
+      const indices = labels.map((label) => text.lastIndexOf(label));
+      return { min: Math.min(...indices), max: Math.max(...indices) };
+    };
+    const grid1Rows = [
+      groupStats.slice(0, 6).map((s) => s[0]),
+      groupStats.slice(6, 12).map((s) => s[0]),
+    ].map(rowIndexRange);
+    const grid2Rows = [
+      compactStats.slice(0, 3).map((s) => s[0]),
+      compactStats.slice(3, 6).map((s) => s[0]),
+      compactStats.slice(6, 9).map((s) => s[0]),
+    ].map(rowIndexRange);
+    for (let i = 1; i < grid1Rows.length; i++) expect(grid1Rows[i]!.min).toBeGreaterThan(grid1Rows[i - 1]!.max);
+    for (let i = 1; i < grid2Rows.length; i++) expect(grid2Rows[i]!.min).toBeGreaterThan(grid2Rows[i - 1]!.max);
+    // Grid 1(6 列声明)整体先于 Grid 2(9 列声明,compact)
+    expect(grid2Rows[0]!.min).toBeGreaterThan(grid1Rows[grid1Rows.length - 1]!.max);
+    // 两个 Grid 都降到三列:每个 boxed cell 四边完整,6 + 9 = 15 个 cell 对应 5+3=... 实际按 3 列计数四角
+    expect(text.match(/┌/g)?.length).toBe(6 + 9);
+    expect(text.match(/└/g)?.length).toBe(6 + 9);
+  });
+});
+
 // ───────────────────────── Tabs ─────────────────────────
 
 describe("Tabs", () => {
@@ -755,6 +1044,55 @@ describe("defineReport 装载规范化", () => {
     expect(() => defineReport({ title: {}, content: null })).toThrow(/no non-empty value/);
   });
 
+  it("page 省略 input 规范化为 scope + navigation:true;显式 attempt 必须 navigation:false", () => {
+    const definition = defineReport({
+      pages: [
+        { id: "report", title: "Report", content: null },
+        { id: "attempt", title: "Attempt", input: "attempt", navigation: false, content: null },
+      ],
+    });
+    expect(definition.pages[0]).toMatchObject({ input: "scope", navigation: true });
+    expect(definition.pages[1]).toMatchObject({ input: "attempt", navigation: false });
+
+    expect(() =>
+      defineReport({
+        pages: [
+          // @ts-expect-error input:"attempt" 必须显式 navigation:false;这里模拟无类型 JS 输入
+          { id: "a", title: "A", input: "attempt", content: null },
+        ],
+      }),
+    ).toThrow(/navigation: false/);
+    expect(() =>
+      defineReport({
+        pages: [
+          // @ts-expect-error navigation:true 与 input:"attempt" 互斥;这里模拟无类型 JS 输入
+          { id: "a", title: "A", input: "attempt", navigation: true, content: null },
+        ],
+      }),
+    ).toThrow(/navigation: false/);
+  });
+
+  it("navigation: false 的 scope-input page 不进导航但仍是普通 scope page", () => {
+    const definition = defineReport({
+      pages: [
+        { id: "report", title: "Report", content: null },
+        { id: "hidden", title: "Hidden", navigation: false, content: null },
+      ],
+    });
+    expect(definition.pages[1]).toMatchObject({ input: "scope", navigation: false });
+  });
+
+  it("一份 definition 最多一张 attempt-input page,第二张同类 page 装载报错", () => {
+    expect(() =>
+      defineReport({
+        pages: [
+          { id: "a1", title: "A1", input: "attempt", navigation: false, content: null },
+          { id: "a2", title: "A2", input: "attempt", navigation: false, content: null },
+        ],
+      }),
+    ).toThrow(/at most one input: "attempt" page/);
+  });
+
   it("{src} 资产拒绝 .. 路径段、绝对路径与 ~;inline/src 互斥", () => {
     expect(() => defineReport({ content: null, scripts: [{ src: "../x.js" }] })).toThrow(/not allowed/);
     expect(() => defineReport({ content: null, scripts: [{ src: "/abs.js" }] })).toThrow(/not allowed/);
@@ -786,6 +1124,34 @@ describe("defineReport 装载规范化", () => {
     expect(pickReportPage(single, "report").id).toBe("report");
   });
 
+  it("pickReportPage 缺省跳过 navigation:false 的页,只挑第一张可导航页;可用列表也只含可导航页", () => {
+    const definition = defineReport({
+      pages: [
+        { id: "hidden", title: "Hidden", navigation: false, content: null },
+        { id: "overview", title: "Overview", content: null },
+        { id: "attempt", title: "Attempt", input: "attempt", navigation: false, content: null },
+      ],
+    });
+    expect(pickReportPage(definition).id).toBe("overview");
+    try {
+      pickReportPage(definition, "typo");
+      expect.unreachable();
+    } catch (e) {
+      expect(e).toBeInstanceOf(ReportPageNotFoundError);
+      expect((e as ReportPageNotFoundError).available).toEqual(["overview"]);
+    }
+  });
+
+  it("显式选择 attempt-input page 但没有 locator:ReportPageNeedsLocatorError", () => {
+    const definition = defineReport({
+      pages: [
+        { id: "report", title: "Report", content: null },
+        { id: "attempt", title: "Attempt", input: "attempt", navigation: false, content: null },
+      ],
+    });
+    expect(() => pickReportPage(definition, "attempt")).toThrow(ReportPageNeedsLocatorError);
+  });
+
   it("标题回退链:def.title → 唯一且相同的快照 name → 内置文案「Eval 运行结果 / Eval Results」;en 相同 zh 不同也落内置文案", () => {
     const named = snap({ experimentId: "t/a", name: "Memory Evals", results: [res("q", "passed")] });
     const definition = defineReport(<ScopeSummary />);
@@ -823,13 +1189,14 @@ describe("defineReport 装载规范化", () => {
 // ───────────────────────── 内建报告 ─────────────────────────
 
 describe("内建报告", () => {
-  it("三页普通 defineReport:页 id、页名与逐页组件构成和 built-in.md 全文一致", () => {
+  it("四页普通 defineReport:页 id、页名与逐页组件构成和 built-in.md 全文一致,第四页是不进导航的 attempt-input page", () => {
     expect(builtInReport.kind).toBe("report");
-    expect(builtInReport.pages.map((p) => p.id)).toEqual(["report", "attempts", "traces"]);
+    expect(builtInReport.pages.map((p) => p.id)).toEqual(["report", "attempts", "traces", "attempt"]);
     expect(builtInReport.pages.map((p) => p.title)).toEqual([
       { en: "Report", "zh-CN": "报告" },
       "Attempts",
       { en: "Traces", "zh-CN": "追踪" },
+      "Attempt",
     ]);
     // 逐页组件构成:每页一个 Col,children 按 built-in.md 全文的声明序,全部是公开组件。
     const childTypes = (content: unknown) => {
@@ -837,7 +1204,7 @@ describe("内建报告", () => {
       expect(col.type).toBe(Col);
       return col.props.children;
     };
-    const [reportPage, attemptsPage, tracesPage] = builtInReport.pages;
+    const [reportPage, attemptsPage, tracesPage, attemptPage] = builtInReport.pages;
     expect(childTypes(reportPage!.content).map((c) => c.type)).toEqual([
       Hero,
       ScopeWarnings,
@@ -848,6 +1215,16 @@ describe("内建报告", () => {
     expect(attemptsChildren.map((c) => c.type)).toEqual([Hero, ScopeWarnings, AttemptList]);
     expect(attemptsChildren[2]!.props.filter).toBe(true);
     expect(childTypes(tracesPage!.content).map((c) => c.type)).toEqual([Hero, ScopeWarnings, TraceWaterfall]);
+    // 第四页是参数化详情页:content 就是裸 AttemptDetail(不套 Col),input/navigation 与文档一致。
+    // defineReport 规范化会重建页对象(id/title/content 逐字段拷贝),所以整页对象不可能与
+    // 具名导出 standardAttemptPage 保持引用相等;但 content 字段是原样透传,同引用证明
+    // standard.tsx 确实把 standardAttemptPage 整个复用进了 pages 数组,不是另抄一份同形的
+    // <AttemptDetail /> JSX(两次书写同样的 JSX 字面量在运行时是两个不同的 element 对象)。
+    expect(attemptPage!.content).toBe(standardAttemptPage.content);
+    expect(attemptPage).toEqual(standardAttemptPage);
+    expect(attemptPage!.input).toBe("attempt");
+    expect(attemptPage!.navigation).toBe(false);
+    expect((attemptPage!.content as { type: unknown }).type).toBe(AttemptDetail);
   });
 
   it("与 --report 同内容文件完全等价:同一棵页树经同一条管线渲染出逐字节相同的两面", async () => {
@@ -876,6 +1253,7 @@ describe("内建报告", () => {
           title: { en: "Traces", "zh-CN": "追踪" },
           content: <Col><Hero /><ScopeWarnings /><TraceWaterfall /></Col>,
         },
+        { id: "attempt", title: "Attempt", input: "attempt" as const, navigation: false as const, content: <AttemptDetail /> },
       ],
     });
     for (const pageId of ["report", "attempts", "traces"]) {
@@ -886,22 +1264,55 @@ describe("内建报告", () => {
         await renderReportToStaticHtml(user, ctx, { pageId }),
       );
     }
+    // 第四页(attempt-input,不能经 pageId 挑选)另走 tree 级渲染入口逐字节比对。
+    const evidence = attemptEvidenceOf();
+    const page = { id: "attempt", input: "attempt" as const, locator: evidence.locator, evidence };
+    const treeCtx = { scope, results: resultsOf([s1, s2]), report: buildReportMeta(builtInReport, scope), page };
+    expect(await renderReportTreeToText(standardAttemptPage.content, treeCtx, { width: 120 })).toBe(
+      await renderReportTreeToText(<AttemptDetail />, treeCtx, { width: 120 }),
+    );
+    expect(await renderReportTreeToStaticHtml(standardAttemptPage.content, treeCtx)).toBe(
+      await renderReportTreeToStaticHtml(<AttemptDetail />, treeCtx),
+    );
   });
 
-  it("首页 text 面多组时只输出组索引与单组查看命令;单组时输出散点与实验列表;页首是 Hero 的标题与 meta 行", async () => {
-    const g1 = snap({ experimentId: "compare/a", results: [res("q", "passed")] });
-    const g2 = snap({ experimentId: "dev/b", results: [res("q", "failed")] });
-    const multi = await renderReportToText(
-      builtInReport,
-      { scope: scopeOf([g1, g2]), results: resultsOf([g1, g2]) },
-      { width: 120 },
-    );
+  it("首页 web/text 两面都展示完整 Scope,不同深度目录的 experiment 同屏且行标签缩成最短唯一后缀;无组选择器或组索引", async () => {
+    const g1 = snap({ experimentId: "compare/alpha-exp", results: [res("q", "passed")] });
+    const g2 = snap({ experimentId: "dev/beta-exp", results: [res("q", "failed")] });
+    const ctx = { scope: scopeOf([g1, g2]), results: resultsOf([g1, g2]) };
+
+    const text = await renderReportToText(builtInReport, ctx, { width: 120 });
     // Hero text 面:标题行(回退链终点)+ 最后运行 meta 行在页首
-    expect(multi.split("\n")[0]).toBe("Eval Results");
-    expect(multi).toContain("Last run");
-    expect(multi).toContain("niceeval show --exp compare");
-    expect(multi).toContain("niceeval show --exp dev");
-    expect(multi).not.toContain("Eval / Attempt"); // 不倾倒组内 experiment 明细
+    expect(text.split("\n")[0]).toBe("Eval Results");
+    expect(text).toContain("Last run");
+    // 完整 Scope 直接展示:两个不同路径的 experiment 都可见,不是组索引 + 单组查看命令;
+    // 行标签是各自末段(两个 id 互不撞名,不必加长),不带父路径。
+    expect(text).toContain("alpha-exp");
+    expect(text).toContain("beta-exp");
+    expect(text).not.toContain("compare/alpha-exp");
+    expect(text).not.toContain("dev/beta-exp");
+    expect(text).not.toContain("niceeval show --exp compare");
+    expect(text).not.toContain("niceeval show --exp dev");
+    expect(text).not.toContain("niceeval exp compare");
+    expect(text).not.toContain("niceeval exp dev");
+
+    const html = await renderReportToStaticHtml(builtInReport, ctx);
+    expect(html).not.toContain('role="tablist"');
+    expect(html).not.toContain("data-nre-experiment-group");
+    expect(html).toContain(">alpha-exp</b>");
+    expect(html).toContain(">beta-exp</b>");
+    // 完整 id 仍是排序键,只是不再重复出现在显示文字里
+    expect(html).toContain('data-sort-value="compare/alpha-exp"');
+    expect(html).toContain('data-sort-value="dev/beta-exp"');
+  });
+
+  it("0/1/多 experiment 均可渲染;0 个时三个叶子组件各自显示自己的空态", async () => {
+    const empty = { scope: scopeOf([]), results: resultsOf([]) };
+    const emptyText = await renderReportToText(builtInReport, empty, { width: 120 });
+    expect(emptyText).toContain("No data to plot Cost × Pass rate"); // MetricScatter 零点空态
+    expect(emptyText).toContain("No attempts"); // ExperimentList 零行空态
+    const emptyHtml = await renderReportToStaticHtml(builtInReport, empty);
+    expect(emptyHtml).toContain("No data to plot Cost × Pass rate");
 
     const priced = snap({
       experimentId: "compare/priced",
@@ -912,12 +1323,149 @@ describe("内建报告", () => {
       { scope: scopeOf([priced]), results: resultsOf([priced]) },
       { width: 140 },
     );
-    expect(single).toContain("Eval / Attempt"); // 单组直接进入组内详情
+    expect(single).toContain("Eval / Attempt"); // 单 experiment 直接展示散点与实验明细
     // 成本轴(better: lower)反向渲染,「更好」恒指向右上;两轴都声明 better → 提示在场
     expect(single).toContain("better → upper right");
   });
 });
 
+// ───────────────────────── ExperimentComparison(组合组件)─────────────────────────
+
+describe("ExperimentComparison(组合组件)", () => {
+  /** 展开树里 [ScopeSummary, MetricScatter, ExperimentList] 三个已解析元素。 */
+  async function resolveComparisonChildren(
+    node: ReportNode,
+    snapshots: Snapshot[],
+  ): Promise<Array<{ props: { data: unknown } }>> {
+    const scope = scopeOf(snapshots);
+    const definition = defineReport(node);
+    const page = pickReportPage(definition);
+    const resolved = (await resolveReportTree(page.content, {
+      scope,
+      results: resultsOf(snapshots),
+      report: buildReportMeta(definition, scope),
+      page: { id: page.id, input: "scope" },
+      memo: new ResolveMemo(),
+    })) as unknown as { props: { children: Array<{ props: { data: unknown } }> } };
+    return resolved.props.children;
+  }
+
+  it("等价于手写的 Col<ScopeSummary/MetricScatter/ExperimentList>:同一份 input 下两棵树渲染逐字节相同(text 与 web)", async () => {
+    const a = snap({ experimentId: "cmp/a", agent: "bub", results: [res("q", "passed")] });
+    const b = snap({ experimentId: "cmp/b", agent: "codex", results: [res("q", "failed")] });
+    const ctx = { scope: scopeOf([a, b]), results: resultsOf([a, b]) };
+
+    const viaCompose = defineReport(<ExperimentComparison />);
+    const viaHandwritten = defineReport(
+      <Col>
+        <ScopeSummary />
+        <MetricScatter points="experiment" series="agent" x={costUSD} y={endToEndPassRate} />
+        <ExperimentList filter />
+      </Col>,
+    );
+    expect(await renderReportToText(viaCompose, ctx, { width: 120 })).toBe(
+      await renderReportToText(viaHandwritten, ctx, { width: 120 }),
+    );
+    expect(await renderReportToStaticHtml(viaCompose, ctx)).toBe(await renderReportToStaticHtml(viaHandwritten, ctx));
+  });
+
+  it("不同深度目录的 experiments 一律进同一份 data;展开树里 ScopeSummary / MetricScatter / ExperimentList 的解析结果与直接调用三个函数深等", async () => {
+    const g1a = snap({ experimentId: "compare/a", agent: "bub", results: [res("q", "passed")] });
+    const g1b = snap({ experimentId: "compare/b", agent: "codex", results: [res("q", "failed")] });
+    const g2 = snap({ experimentId: "bench/long/x", results: [res("q", "passed")] });
+    const solo = snap({ experimentId: "standalone", results: [res("q", "failed")] });
+    const all = [g1a, g1b, g2, solo];
+    const [summaryEl, scatterEl, listEl] = await resolveComparisonChildren(<ExperimentComparison />, all);
+    expect(listEl.props.data).toEqual(await experimentListData(all));
+    expect(summaryEl.props.data).toEqual(await scopeSummaryData(all));
+    expect(scatterEl.props.data).toEqual(
+      await metricScatterData(all, { points: "experiment", series: "agent", x: costUSD, y: endToEndPassRate }),
+    );
+  });
+
+  it("series 缺省解析:Scope 内任一 experiment 声明 labels.line 时全图 line,完全无 line 时 agent;显式 series 覆盖缺省", async () => {
+    const withCost = { usage: { inputTokens: 1, outputTokens: 1, costUSD: 0.1 } };
+    const withLine = snap({ experimentId: "series/with-line", results: [res("q", "passed", withCost)] });
+    withLine.experiment = { runs: 1, earlyExit: false, selectedEvalIds: ["q"], labels: { line: "codex" } };
+    const withoutLine = snap({ experimentId: "series/plain", results: [res("q", "passed", withCost)] });
+
+    const textWithLine = await renderTreeText(<ExperimentComparison />, scopeOf([withLine, withoutLine]));
+    expect(textWithLine).toContain("grouped by line");
+
+    const textNoLine = await renderTreeText(<ExperimentComparison />, scopeOf([withoutLine]));
+    expect(textNoLine).toContain("grouped by agent");
+
+    const textExplicit = await renderTreeText(<ExperimentComparison series="agent" />, scopeOf([withLine]));
+    expect(textExplicit).toContain("grouped by agent");
+  });
+
+  it("connect 缺省跟随 series 解析:默认 line 时同 series 两点连线,默认 agent 时不连线", async () => {
+    const withCost = { usage: { inputTokens: 1, outputTokens: 1, costUSD: 0.1 } };
+    const lineA = snap({ experimentId: "connect/a", agent: "codex", results: [res("q", "passed", withCost)] });
+    lineA.experiment = { runs: 1, earlyExit: false, selectedEvalIds: ["q"], labels: { line: "codex" } };
+    const lineB = snap({ experimentId: "connect/b", agent: "codex", results: [res("q", "failed", withCost)] });
+    lineB.experiment = { runs: 1, earlyExit: false, selectedEvalIds: ["q"], labels: { line: "codex" } };
+    // 同一个 agent 分两个 experiment,声明 line 时归同一条线;位移摘要行(└ Pass rate …)只在
+    // connect 开时出现(scatterText 的 connect 分支),是比裸 "→" 更可靠的标记
+    // ("better → upper right" 提示行本身也含 "→",不能用来判连线)。
+    const connected = await renderTreeText(<ExperimentComparison />, scopeOf([lineA, lineB]));
+    expect(connected).toContain("grouped by line");
+    expect(connected).toContain("└ Pass rate");
+
+    const plainA = snap({ experimentId: "connect/plain-a", agent: "codex", results: [res("q", "passed", withCost)] });
+    const plainB = snap({ experimentId: "connect/plain-b", agent: "codex", results: [res("q", "failed", withCost)] });
+    const unconnected = await renderTreeText(<ExperimentComparison />, scopeOf([plainA, plainB]));
+    expect(unconnected).toContain("grouped by agent");
+    expect(unconnected).not.toContain("└ Pass rate");
+  });
+
+  it("line 缺省对整个 Scope 生效:混入一个声明 line 的实验后,没声明的实验落 (missing) 而非回退 agent;显式 series 覆盖全部", async () => {
+    const lineA = snap({ experimentId: "mem/codex-baseline", agent: "codex", results: [res("q", "passed")] });
+    lineA.experiment = { runs: 1, earlyExit: false, selectedEvalIds: ["q"], labels: { line: "codex", memory: "baseline" } };
+    const lineB = snap({ experimentId: "mem/codex-mempal", agent: "codex", results: [res("q", "failed")] });
+    lineB.experiment = { runs: 1, earlyExit: false, selectedEvalIds: ["q"], labels: { line: "codex", memory: "mempal" } };
+    const plain = snap({ experimentId: "dev/one", agent: "codex", results: [res("q", "passed")] });
+    const all = [lineA, lineB, plain];
+
+    const [, scatterEl] = await resolveComparisonChildren(<ExperimentComparison />, all);
+    const scatterData = scatterEl.props.data as { seriesDimension?: string; rows: Array<{ key: string; series?: string }> };
+    expect(scatterData.seriesDimension).toBe("line");
+    const byKey = new Map(scatterData.rows.map((r) => [r.key, r.series]));
+    expect(byKey.get("mem/codex-baseline")).toBe("codex");
+    expect(byKey.get("dev/one")).toBe("(missing)");
+
+    const [, explicitScatterEl] = await resolveComparisonChildren(<ExperimentComparison series={label("memory")} />, all);
+    expect((explicitScatterEl.props.data as { seriesDimension?: string }).seriesDimension).toBe("memory");
+  });
+
+  it("ExperimentList 行标签默认缩成 Scope 内的最短唯一后缀,不改变 ScopeSummary / MetricScatter 输出或排序键", async () => {
+    const a = snap({ experimentId: "compare/a", agent: "bub", results: [res("q", "passed")] });
+    const b = snap({ experimentId: "compare/b", agent: "codex", results: [res("q", "failed")] });
+    const ctx = { scope: scopeOf([a, b]), results: resultsOf([a, b]) };
+
+    const definition = defineReport(<ExperimentComparison />);
+    const html = await renderReportToStaticHtml(definition, ctx);
+    expect(html).toContain(">a</b>");
+    expect(html).toContain(">b</b>");
+    expect(html).toContain('data-sort-value="compare/a"');
+    expect(html).toContain('data-sort-value="compare/b"');
+
+    // 换成末段撞名的一对(a/run、b/run 都叫 run)时两行都要加长到能区分为止,不是随口断言。
+    const dupeA = snap({ experimentId: "compare/x/run", agent: "bub", results: [res("q", "passed")] });
+    const dupeB = snap({ experimentId: "compare/y/run", agent: "codex", results: [res("q", "failed")] });
+    const dupeHtml = await renderReportToStaticHtml(definition, { scope: scopeOf([dupeA, dupeB]), results: resultsOf([dupeA, dupeB]) });
+    expect(dupeHtml).toContain(">x/run</b>");
+    expect(dupeHtml).toContain(">y/run</b>");
+
+    // ScopeSummary / MetricScatter 完全不受行标签缩短影响
+    const [summaryEl, scatterEl] = await resolveComparisonChildren(<ExperimentComparison />, [a, b]);
+    expect(summaryEl.props.data).toEqual(await scopeSummaryData([a, b]));
+    expect(scatterEl.props.data).toEqual(
+      await metricScatterData([a, b], { points: "experiment", series: "agent", x: costUSD, y: endToEndPassRate }),
+    );
+  });
+});
+
 // ───────────────────────── extends 与内建视图集合 ─────────────────────────
 
 describe("extends 与内建视图集合", () => {
@@ -944,7 +1492,7 @@ describe("extends 与内建视图集合", () => {
 
     // ctx.report.title 取 extends 上声明的 title
     const s = snap({ experimentId: "compare/a", results: [res("q", "passed")] });
-    expect(buildReportMeta(branded, scopeOf([s]), "report").title).toBe("Memory Evals");
+    expect(buildReportMeta(branded, scopeOf([s])).title).toBe("Memory Evals");
   });
 
   it("无外壳字段的 extends 与内建逐页两面渲染逐字节相同", async () => {