niceeval 0.9.1 → 0.10.2

package/src/report/{report.test.ts → components/compute.test.ts}

@@ -4,15 +4,15 @@
 // skipped=null、null≠0、Scoreboard 固定分母(notRun/unscorable 分开)、权重最长前缀、
 // 身份键去重、现刻水位、自定义指标 where/aggregate、evalGroup 完整父路径、verdict 权威、
 // MetricCell 诚实、缺 artifact 指标、repeatedFailedCommands、实体列表 failureSummary、
-// scopeSummaryData 两级计票、experimentComparisonData 分区、pairsByFlag、
+// scopeSummaryData 两级计票、experimentListData/scopeSummaryData 的 selectedEvalIds 投影、pairsByFlag、
 // MetricLine 点身份、空数组反馈、metricTableData sort。
 
 import { describe, expect, it } from "vitest";
 
-import type { AssertionResult, AttemptError, EvalResult, O11ySummary, Verdict } from "../types.ts";
-import type { AttemptHandle, Scope, ScopeWarning, Snapshot } from "../results/index.ts";
-import { makeScope, selectCurrentResults } from "../results/select.ts";
-import type { Results } from "../results/types.ts";
+import type { AssertionResult, AttemptError, EvalResult, O11ySummary, Verdict } from "../../types.ts";
+import type { AttemptHandle, Scope, ScopeWarning, Snapshot } from "../../results/index.ts";
+import { makeScope, selectCurrentResults } from "../../results/select.ts";
+import type { Results } from "../../results/types.ts";
 import {
   assistantTurns,
   costUSD,
@@ -23,23 +23,33 @@ import {
   executionReliability,
   repeatedFailedCommands,
   taskPassRate,
-} from "./metrics.ts";
-import { flag, numericFlag } from "./flag.ts";
+} from "../model/metrics.ts";
+import { flag, label, numericFlag, numericLabel } from "../model/flag.ts";
+import { scatterText } from "./metric-views/faces.ts";
+import { createTextContext } from "../definition/tree.ts";
+import { colorIndexForKey, colorIndicesForKeys } from "../assets/colors.ts";
+import { attemptListData, evalListData, experimentListData } from "./entity-lists/compute.ts";
+import { validateAttemptListData, validateEvalListData, validateExperimentListData } from "./entity-lists/index.tsx";
 import {
-  attemptListData,
   deltaTableData,
-  evalListData,
-  experimentComparisonData,
-  experimentListData,
   metricLineData,
   metricMatrixData,
   metricScatterData,
   metricTableData,
   pairsByFlag,
-  scopeSummaryData,
   scoreboardData,
-} from "./compute.ts";
-import { evalGroupOf } from "./aggregate.ts";
+} from "./metric-views/compute.ts";
+import {
+  validateDeltaData,
+  validateLineData,
+  validateMatrixData,
+  validateScatterData,
+  validateScoreboardData,
+  validateTableData,
+} from "./metric-views/index.tsx";
+import { scopeSummaryData } from "./summaries/compute.ts";
+import { validateScopeSummaryData } from "./summaries/index.tsx";
+import { evalGroupOf } from "../model/aggregate.ts";
 
 // ───────────────────────── fake 数据(按 results 读取契约造)─────────────────────────
 
@@ -183,7 +193,7 @@ describe("两级聚合口径", () => {
     expect(cells[executionReliability.name]!.value).toBeCloseTo(2 / 3);
   });
 
-  it("2 passed + 5 errored 的默认成功率是 2/7,不是 100%", async () => {
+  it("2 passed + 5 errored 的默认通过率是 2/7,不是 100%", async () => {
     const s = snap({
       experimentId: "exp/err",
       results: [
@@ -595,7 +605,7 @@ describe("实体列表 data", () => {
     expect(byEval.get("list/errored")!.costUSD).toBeNull();
   });
 
-  it("experimentListData:evalVerdicts / endToEndPassRate / costUSD / durationMs / tokens 齐全,默认按端到端成功率降序", async () => {
+  it("experimentListData:evalVerdicts / endToEndPassRate / costUSD / durationMs / tokens 齐全,默认按端到端通过率降序", async () => {
     const winner = snap({ experimentId: "exp/win", results: [res("a", "passed"), res("b", "passed")] });
     const loser = snap({ experimentId: "exp/lose", results: [res("a", "failed"), res("b", "passed")] });
     const items = await experimentListData([loser, winner]);
@@ -667,32 +677,59 @@ describe("scopeSummaryData", () => {
   });
 });
 
-// ───────────────────────── experimentComparisonData ─────────────────────────
+// ───────────────────────── experimentListData / scopeSummaryData 的 selectedEvalIds 投影 ─────────────────────────
+// ExperimentComparison 已收为普通组合组件(把同一个 input 原样透传给 ScopeSummary /
+// MetricScatter / ExperimentList,不再有自己的 data 形态);经它展开后与直接调用这三个
+// 函数深等的验证挪到 dual-render.test.tsx(需要 resolve 管线)。这里只测三个函数自己的
+// selectedEvalIds 投影契约。
 
-describe("experimentComparisonData", () => {
-  it("计算前按完整父路径分区,根目录 experiment 单例组;每组与独立调用三个计算函数深等,refs 不跨组", async () => {
+describe("experimentListData / scopeSummaryData 的 selectedEvalIds 投影", () => {
+  it("不同深度目录的 experiments 一律进同一份 data,不按父路径分组比较", 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", "errored", { error: erroredWith("x") })] });
+    const items = await experimentListData([g1a, g1b, g2, solo]);
+    expect(items.map((e) => e.experimentId).sort()).toEqual([
+      "bench/long/x",
+      "compare/a",
+      "compare/b",
+      "standalone",
+    ]);
+  });
+
+  it("每个 experiment 只保留自己选择的 eval:A 声明 selectedEvalIds:[q1] 但夹带 q2 attempt,B 只选 q2;q2 不污染 A", async () => {
+    const a = snap({
+      experimentId: "exp/a",
+      results: [res("q1", "passed"), res("q2", "failed")],
+      experiment: { runs: 1, earlyExit: false, selectedEvalIds: ["q1"] },
+    });
+    const b = snap({
+      experimentId: "exp/b",
+      results: [res("q2", "passed")],
+      experiment: { runs: 1, earlyExit: false, selectedEvalIds: ["q2"] },
+    });
 
-    const data = await experimentComparisonData([g1a, g1b, g2, solo]);
-    expect(data.groups.map((g) => g.key)).toEqual(["bench/long", "compare", "standalone"]);
+    const items = await experimentListData([a, b]);
+    const rowA = items.find((e) => e.experimentId === "exp/a")!;
+    const rowB = items.find((e) => e.experimentId === "exp/b")!;
+    expect(rowA.evals).toBe(1); // 只统计 q1,夹带的 q2 attempt 不计入
+    expect(rowA.evalRows.map((r) => r.evalId)).toEqual(["q1"]);
+    expect(rowB.evals).toBe(1);
+    expect(rowB.evalRows.map((r) => r.evalId)).toEqual(["q2"]);
+
+    // 汇总口径同样不被污染:全 Scope 只有 2 个 eval(exp/a·q1、exp/b·q2),不是 3 个。
+    const summary = await scopeSummaryData([a, b]);
+    expect(summary.evals).toBe(2);
+  });
 
-    const compare = data.groups.find((g) => g.key === "compare")!;
-    const [summary, scatter, experiments] = await Promise.all([
-      scopeSummaryData([g1a, g1b]),
-      metricScatterData([g1a, g1b], { points: "experiment", series: "agent", x: costUSD, y: endToEndPassRate }),
-      experimentListData([g1a, g1b]),
-    ]);
-    expect(compare.summary).toEqual(summary);
-    expect(compare.scatter).toEqual(scatter);
-    expect(compare.experiments).toEqual(experiments);
+  it("第三方快照缺 experiment 信息时仍可见,按其实际 evals 参与(selectedEvalIdsOf 退化)", async () => {
+    const thirdParty = snap({ experimentId: "third-party/exp", results: [res("q", "passed")] });
+    expect(thirdParty.experiment).toBeUndefined();
 
-    // 组外 attempt 不污染:compare 组的 refs 不含 bench/standalone 的 locator
-    const soloRefs = data.groups.find((g) => g.key === "standalone")!.summary.endToEndPassRate.refs;
-    const compareRefs = compare.summary.endToEndPassRate.refs;
-    expect(compareRefs.some((ref) => soloRefs.includes(ref))).toBe(false);
+    const items = await experimentListData([thirdParty]);
+    expect(items.map((e) => e.experimentId)).toEqual(["third-party/exp"]);
+    expect(items[0]!.evals).toBe(1);
   });
 });
 
@@ -918,22 +955,79 @@ describe("deltaTableData", () => {
       ];
     };
 
-    it("同可比组 + 删除该 flag 后配置深相等才配对;a 取 baseline(缺省=未声明),label 自动生成,按 (a 末段, 显示键) 字典序", async () => {
+    it("input Scope 内删除该 flag 后配置深相等才配对;a 取 baseline(缺省=未声明),label 用完整 a experiment id,按 (a 末段, 显示键) 字典序", async () => {
       const data = await deltaTableData(matrixSnaps(), {
         by: "experiment",
         pairs: pairsByFlag("memory"),
         metrics: [endToEndPassRate],
       });
       expect(data.rows.map((r) => r.label)).toEqual([
-        "bub · memory=agents-md",
-        "codex · memory=agents-md",
-        "codex · memory=mempal",
-        "gemini · memory=agents-md",
-        "gemini · memory=mempal",
+        "mem/bub · memory=agents-md",
+        "mem/codex · memory=agents-md",
+        "mem/codex · memory=mempal",
+        "mem/gemini · memory=agents-md",
+        "mem/gemini · memory=mempal",
       ]);
       expect(data.experiments).toBe(8);
     });
 
+    it("配对边界只是 input Scope,不额外按 experiment id 的目录前缀分组:不同前缀但可比性配置相同就配对", async () => {
+      const mk = (id: string, memory?: string) =>
+        snap({
+          experimentId: id,
+          agent: "bub",
+          results: [res("q", "passed")],
+          experiment: {
+            runs: 1,
+            earlyExit: false,
+            selectedEvalIds: [],
+            ...(memory !== undefined ? { flags: { memory } } : {}),
+          },
+        });
+      const data = await deltaTableData([mk("compare/codex"), mk("bench/codex", "agents-md")], {
+        by: "experiment",
+        pairs: pairsByFlag("memory"),
+        metrics: [endToEndPassRate],
+      });
+      expect(data.rows.map((r) => r.label)).toEqual(["compare/codex · memory=agents-md"]);
+      expect(data.rows[0]!.a.key).toBe("compare/codex");
+      expect(data.rows[0]!.b.key).toBe("bench/codex");
+    });
+
+    it("排序只看 a 末段与 flag 显示键,不看完整 label 字符串:a 末段相同、完整 id 不同的两个 bucket 不因目录前缀打乱顺序", async () => {
+      const mk = (id: string, model: string, memory?: string) =>
+        snap({
+          experimentId: id,
+          model,
+          agent: "bub",
+          results: [res("q", "passed")],
+          experiment: {
+            runs: 1,
+            earlyExit: false,
+            selectedEvalIds: [],
+            ...(memory !== undefined ? { flags: { memory } } : {}),
+          },
+        });
+      // 两个 bucket 因 model 不同而彼此不可比(不会互相配对),但都各自派生一对;
+      // 两对的 a 末段都是 "codex",flagKey 分别是 "z-value" 与 "a-value"。
+      const data = await deltaTableData(
+        [
+          mk("alpha/codex", "m1"), // bucket 1 baseline
+          mk("alpha/codex-variant", "m1", "z-value"), // bucket 1 b 侧
+          mk("zeta/codex", "m2"), // bucket 2 baseline
+          mk("zeta/codex-variant", "m2", "a-value"), // bucket 2 b 侧
+        ],
+        { by: "experiment", pairs: pairsByFlag("memory"), metrics: [endToEndPassRate] },
+      );
+      // 只看 a 末段("codex",两对相同)与 flag 显示键("a-value" < "z-value")排序:
+      // zeta 那对(flagKey "a-value")排在 alpha 那对(flagKey "z-value")之前——若误按完整
+      // label 字符串排序,"alpha/codex..." 会先于 "zeta/codex...",顺序会相反。
+      expect(data.rows.map((r) => r.label)).toEqual([
+        "zeta/codex · memory=a-value",
+        "alpha/codex · memory=z-value",
+      ]);
+    });
+
     it("可比性配置不同(model 不同)的两实验不配对", async () => {
       const base = snap({
         experimentId: "mm/a",
@@ -977,13 +1071,13 @@ describe("deltaTableData", () => {
         pairs: pairsByFlag("memory", { baseline: "agents-md" }),
         metrics: [endToEndPassRate],
       });
-      // a = *--agents-md;b = 未声明(显示键 (missing))与 mempal
+      // a = *--agents-md;b = 未声明(显示键 (missing))与 mempal;label 用完整 a experiment id。
       expect(data.rows.map((r) => r.label)).toEqual([
-        "bub--agents-md · memory=(missing)",
-        "codex--agents-md · memory=(missing)",
-        "codex--agents-md · memory=mempal",
-        "gemini--agents-md · memory=(missing)",
-        "gemini--agents-md · memory=mempal",
+        "mem/bub--agents-md · memory=(missing)",
+        "mem/codex--agents-md · memory=(missing)",
+        "mem/codex--agents-md · memory=mempal",
+        "mem/gemini--agents-md · memory=(missing)",
+        "mem/gemini--agents-md · memory=mempal",
       ]);
     });
   });
@@ -1009,3 +1103,179 @@ describe("examScore", () => {
     expect(cellOf("crashed").samples).toBe(1); // 0 分是测得的事实,不是缺数据
   });
 });
+
+// ───────────────────────── labels 维度、series 归类与 connect ─────────────────────────
+
+describe("labels 维度、series 归类与 connect", () => {
+  const labeled = (
+    experimentId: string,
+    labels: Record<string, string | number> | undefined,
+    verdicts: Verdict[],
+    agent = "agent-x",
+  ) =>
+    snap({
+      experimentId,
+      agent,
+      results: verdicts.map((v, i) => res(`q${i}`, v, { agent })),
+      experiment: {
+        runs: 1,
+        earlyExit: false,
+        selectedEvalIds: verdicts.map((_, i) => `q${i}`),
+        ...(labels ? { labels } : {}),
+      },
+    });
+
+  it("label() 按声明值分组、未声明归 (missing);numericLabel 对字符串值返回 null 不猜序", async () => {
+    const table = await metricTableData(
+      [labeled("m/one", { memory: "mempal" }, ["passed"]), labeled("m/two", undefined, ["failed"])],
+      { rows: label("memory"), columns: [endToEndPassRate] },
+    );
+    expect(table.rows.map((r) => r.key).sort()).toEqual(["(missing)", "mempal"]);
+
+    const line = await metricLineData(
+      [labeled("m/num", { contextK: 32 }, ["passed"]), labeled("m/str", { contextK: "big" }, ["passed"])],
+      { x: numericLabel("contextK"), y: endToEndPassRate },
+    );
+    expect(line.rows.filter((r) => r.x === null)).toHaveLength(1);
+    expect(line.rows.some((r) => r.x === 32)).toBe(true);
+    expect(line.rows.some((r) => r.x === 0)).toBe(false);
+  });
+
+  it("series 数组解析为复合维度:name 以 × 连接、值以 · 连接,缺失成员沿用 (missing)", async () => {
+    const a = labeled("c/one", { memory: "mempal" }, ["passed"], "codex");
+    const b = labeled("c/two", undefined, ["failed"], "codex");
+    const data = await metricScatterData([a, b], {
+      points: "experiment",
+      series: ["agent", label("memory")],
+      x: costUSD,
+      y: endToEndPassRate,
+    });
+    expect(data.seriesDimension).toBe("agent × memory");
+    const byKey = new Map(data.rows.map((r) => [r.key, r.series]));
+    expect(byKey.get("c/one")).toBe("codex · mempal");
+    expect(byKey.get("c/two")).toBe("codex · (missing)");
+    // 单成员数组等价于单维度
+    const single = await metricScatterData([a], { points: "experiment", series: ["agent"], x: costUSD, y: endToEndPassRate });
+    expect(single.seriesDimension).toBe("agent");
+    expect(single.rows[0]!.series).toBe("codex");
+  });
+
+  const cell = (value: number, display: string): import("../model/types.ts").MetricCell => ({
+    value,
+    display,
+    samples: 1,
+    total: 1,
+    refs: [],
+  });
+  const lineScatter = (): import("../model/types.ts").ScatterData => ({
+    pointDimension: "experiment",
+    seriesDimension: "line",
+    x: { key: "costUSD", label: "Cost", unit: "$", better: "lower" },
+    y: { key: "endToEndPassRate", label: "Pass rate", unit: "%", better: "higher" },
+    rows: [
+      { key: "mem/claude-mempal", series: "claude", x: cell(0.55, "$0.55"), y: cell(0.75, "75%") },
+      { key: "mem/claude-baseline", series: "claude", x: cell(0.35, "$0.35"), y: cell(0.5, "50%") },
+      { key: "mem/bub", series: "bub", x: cell(0.09, "$0.09"), y: cell(0.875, "87.5%") },
+    ],
+  });
+
+  it("scatterText:标记按图例顺序分配(series 字典序、series 内 x 升序),标题标注归类维度;默认无箭头", () => {
+    const text = scatterText(lineScatter(), createTextContext({ width: 80 }));
+    expect(text).toContain("grouped by line");
+    // bub < claude:A 给 bub;claude 内按成本升序 baseline(B) → mempal(C)
+    expect(text).toContain("bub     A mem/bub");
+    expect(text).toContain("B mem/claude-baseline");
+    expect(text).toContain("C mem/claude-mempal");
+    expect(text).not.toContain("→ C mem/claude-mempal");
+    expect(text).not.toContain("└ Pass rate");
+  });
+
+  it("scatterText connect:图例按 x 升序 → 串联并给逐段位移摘要;单点 series 无箭头无摘要;坐标图内不画折线", () => {
+    const text = scatterText(lineScatter(), createTextContext({ width: 80 }), { connect: true });
+    expect(text).toContain("B mem/claude-baseline → C mem/claude-mempal");
+    expect(text).toContain("└ Pass rate +25pt · Cost +$0.20");
+    expect(text).toContain("A mem/bub");
+    expect(text).not.toContain("A mem/bub →");
+    // 坐标图折线用 · 描画;connect 的 text 投影是图例的位移摘要,网格行(│ 开头)不出现折线点
+    const plotRows = text.split("\n").filter((l) => l.includes("│"));
+    expect(plotRows.length).toBeGreaterThan(0);
+    expect(plotRows.every((l) => !l.includes("·"))).toBe(true);
+  });
+
+  it("同图撞色按图例顺序线性探测空格;无冲突键仍取散列格;超过色板才复用", () => {
+    // 真实回归现场:bub / claude-code / codex 在同一张图里必须三色互异
+    const real = colorIndicesForKeys(["bub", "claude-code", "codex"]);
+    expect(new Set(real.values()).size).toBe(3);
+    // 构造性冲突:找两个散列同格的键,后到者让位,先到者保持散列格(跨图稳定)
+    const pool = Array.from({ length: 40 }, (_, i) => `k${i}`);
+    const byIdx = new Map<number, string[]>();
+    for (const k of pool) {
+      const idx = colorIndexForKey(k);
+      byIdx.set(idx, [...(byIdx.get(idx) ?? []), k]);
+    }
+    const [first, second] = [...byIdx.values()].find((keys) => keys.length >= 2)!;
+    const resolved = colorIndicesForKeys([first, second]);
+    expect(resolved.get(first)).toBe(colorIndexForKey(first));
+    expect(resolved.get(second)).not.toBe(resolved.get(first));
+    // 前 6 个键占满 6 色;第 7 个开始只能复用
+    const seven = colorIndicesForKeys(["s0", "s1", "s2", "s3", "s4", "s5", "s6"]);
+    expect(new Set([...seven.values()].slice(0, 6)).size).toBe(6);
+  });
+});
+
+describe("validate*Data 接受真实计算产物(不是只接受手写 literal)", () => {
+  // 手写 literal 通过校验只证明 validator 认得自己设想的形状;真正的把关是喂真实计算产物——
+  // 尤其是省略可选字段(如自定义指标不声明 label)的真实路径,不是校验作者假想的边界。
+  const a = snap({ experimentId: "compare/a", results: [res("q1", "passed"), res("q2", "failed")] });
+  const b = snap({ experimentId: "compare/b", results: [res("q1", "failed"), res("q2", "passed")] });
+  const scope = scopeOf([a, b]);
+  const noLabelMetric = defineMetric({ name: "custom-no-label", value: (attempt) => (attempt.result.verdict === "passed" ? 1 : 0) });
+
+  it("metricTableData:含未声明 label 的自定义指标", async () => {
+    const table = await metricTableData(scope, { rows: "agent", columns: [costUSD, noLabelMetric] });
+    expect(validateTableData(table)).toBeNull();
+  });
+
+  it("metricMatrixData", async () => {
+    const matrix = await metricMatrixData(scope, { rows: "experiment", columns: "eval", cell: endToEndPassRate });
+    expect(validateMatrixData(matrix)).toBeNull();
+  });
+
+  it("metricScatterData:含缺 y 的点(null MetricCell.value)", async () => {
+    const scatter = await metricScatterData(scope, { points: "experiment", x: costUSD, y: noLabelMetric });
+    expect(validateScatterData(scatter)).toBeNull();
+  });
+
+  it("metricLineData", async () => {
+    const line = await metricLineData(scope, { x: numericFlag("budget"), y: endToEndPassRate });
+    expect(validateLineData(line)).toBeNull();
+  });
+
+  it("scoreboardData", async () => {
+    const board = await scoreboardData(scope, { rows: "agent", questions: ["q1", "q2"] });
+    expect(validateScoreboardData(board)).toBeNull();
+  });
+
+  it("deltaTableData(含 pairsByFlag 派生 pair)", async () => {
+    const withFlag = snap({
+      experimentId: "compare/withflag",
+      results: [res("q1", "passed")],
+      experiment: { runs: 1, earlyExit: false, selectedEvalIds: [], flags: { memory: "on" } },
+    });
+    const withoutFlag = snap({ experimentId: "compare/noflag", results: [res("q1", "failed")] });
+    const deltaScope = scopeOf([withFlag, withoutFlag]);
+    const delta = await deltaTableData(deltaScope, { by: "experiment", pairs: pairsByFlag("memory"), metrics: [costUSD] });
+    expect(validateDeltaData(delta)).toBeNull();
+  });
+
+  it("scopeSummaryData", async () => {
+    const summary = await scopeSummaryData(scope);
+    expect(validateScopeSummaryData(summary)).toBeNull();
+  });
+
+  it("experimentListData / evalListData / attemptListData(同一 Scope 三种粒度)", async () => {
+    expect(validateExperimentListData(await experimentListData(scope))).toBeNull();
+    expect(validateEvalListData(await evalListData(scope))).toBeNull();
+    expect(validateAttemptListData(await attemptListData(scope))).toBeNull();
+  });
+});

package/src/report/{react → components/entity-lists}/AttemptList.tsx

@@ -6,30 +6,38 @@
 // 也是它们展开区里"逐条 attempt"那一层的唯一实现(通过 AttemptRow 导出复用,不重写一遍)。
 
 import type { ReactElement } from "react";
-import type { AttemptListItem } from "../types.ts";
-import type { AttemptLocator } from "../../results/locator.ts";
-import { DEFAULT_REPORT_LOCALE, countText, localeText, type ReportLocale } from "../locale.ts";
-import { colorClassForKey } from "./colors.ts";
-import { cx, formatDurationMs, formatUSD, verdictMark } from "./format.ts";
+import type { AttemptListItem } from "../../model/types.ts";
+import type { AttemptLocator } from "../../../results/locator.ts";
+import { DEFAULT_REPORT_LOCALE, countText, localeText, type ReportLocale } from "../../model/locale.ts";
+import { colorClassForKey } from "../../assets/colors.ts";
+import { formatDurationMs, formatUSD, verdictMark } from "../../model/format.ts";
+import { cx } from "../shared.ts";
 
-const DEFAULT_ATTEMPT_HREF = (locator: AttemptLocator): string => `#/attempt/${locator}`;
-
-/** locator + 判定符的普通 <a>,AttemptList/EvalList/ExperimentList 共用。 */
+/**
+ * locator + 判定符,AttemptList/EvalList/ExperimentList 共用。没有 target(当前报告没有
+ * declare attempt-input page,也没有显式 attemptHref)时是纯文本,不生成空 href 或假链接
+ * (docs/feature/reports/architecture.md「Attempt 详情是一张参数化 page」)。
+ */
 export function AttemptLocatorBadge({
   item,
-  attemptHref = DEFAULT_ATTEMPT_HREF,
+  attemptHref,
 }: {
   item: Pick<AttemptListItem, "locator" | "verdict">;
   attemptHref?: (locator: AttemptLocator) => string;
 }): ReactElement {
-  return (
-    <a
-      className={cx("nre-locator", `nre-verdict-${item.verdict}`)}
-      href={attemptHref(item.locator)}
-    >
+  const className = cx("nre-locator", `nre-verdict-${item.verdict}`);
+  const content = (
+    <>
       {item.locator}
       <span className="nre-locator-mark">{verdictMark(item.verdict)}</span>
+    </>
+  );
+  return attemptHref ? (
+    <a className={className} href={attemptHref(item.locator)}>
+      {content}
     </a>
+  ) : (
+    <span className={className}>{content}</span>
   );
 }
 
@@ -44,7 +52,7 @@ export function failureSummaryText(item: Pick<AttemptListItem, "failureSummary"
 /** 一条 Attempt 的比较卡片;完整 assertions 通过 locator 下钻,不在列表内展开。 */
 export function AttemptRow({
   item,
-  attemptHref = DEFAULT_ATTEMPT_HREF,
+  attemptHref,
   locale = DEFAULT_REPORT_LOCALE,
 }: {
   item: AttemptListItem;
@@ -74,7 +82,7 @@ export function AttemptList({
   data,
   total,
   filter = false,
-  attemptHref = DEFAULT_ATTEMPT_HREF,
+  attemptHref,
   className,
   locale = DEFAULT_REPORT_LOCALE,
 }: {