niceeval 0.6.0 → 0.6.1

package/src/show/render.ts

@@ -5,7 +5,7 @@
 
 import { join, relative } from "node:path";
 import type { AssertionResult, DiffData, EvalResult, Verdict } from "../types.ts";
-import type { AttemptEvidence, AttemptEvidenceCapabilities, AttemptHandle, Selection, Snapshot } from "../results/index.ts";
+import type { AttemptEvidence, AttemptHandle, Snapshot } from "../results/index.ts";
 import type { AnnotatedSourceLine } from "../results/index.ts";
 import { groupIncompatibleVersionSkips } from "../results/index.ts";
 import type { SkippedDir } from "../results/index.ts";
@@ -13,7 +13,7 @@ import type { ExecutionNode } from "../o11y/execution-tree.ts";
 import { foldEvalVerdict } from "../shared/verdict.ts";
 import { attemptCostUSD } from "../report/metrics.ts";
 import { formatDurationMs, formatMetricValue, formatPlainNumber, formatUSD } from "../report/format.ts";
-import { indentBlock, padDisplay, renderAlignedRows, stringWidth, wrapDisplay } from "../report/text/layout.ts";
+import { indentBlock, padDisplay, renderAlignedRows, wrapDisplay } from "../report/text/layout.ts";
 import type { EvalHistoryRow, ExperimentHistoryRow } from "./compose.ts";
 
 const MISSING = "—";
@@ -45,172 +45,6 @@ function verdictMark(verdict: Verdict): string {
   return "✗";
 }
 
-function showVerdictLabel(verdict: Verdict): string {
-  switch (verdict) {
-    case "passed":
-      return "✓ passed";
-    case "failed":
-      return "✗ failed";
-    case "errored":
-      return "! errored";
-    case "skipped":
-      return "○ skipped";
-  }
-}
-
-/** 按终端显示宽度截断，末尾保留一个省略号；不从 CJK 字符中间切开。 */
-function clipDisplay(text: string, width: number): string {
-  if (stringWidth(text) <= width) return text;
-  if (width <= 1) return "…";
-  let out = "";
-  let used = 0;
-  for (const ch of text) {
-    const next = stringWidth(ch);
-    if (used + next > width - 1) break;
-    out += ch;
-    used += next;
-  }
-  return out + "…";
-}
-
-function commandExitCode(evidence: string | undefined): string | undefined {
-  if (!evidence) return undefined;
-  try {
-    const parsed: unknown = JSON.parse(evidence);
-    if (typeof parsed === "object" && parsed !== null && "exitCode" in parsed) {
-      const exitCode = parsed.exitCode;
-      if (typeof exitCode === "number") return String(exitCode);
-    }
-  } catch {
-    // Assertion evidence is allowed to be arbitrary text; fall through to textual hints.
-  }
-  return /(?:returncode|retcode|exit(?:ed| code)?)\D{0,8}(-?\d+)/i.exec(evidence)?.[1];
-}
-
-/** 默认索引 RESULT 列：只给能决定下一步的短原因，完整 evidence 留在 attempt 首页。 */
-export function showResultReason(result: EvalResult): string {
-  if (result.verdict === "passed") return MISSING;
-  if (result.error !== undefined) return result.error;
-  if (result.skipReason !== undefined) return result.skipReason;
-  const gate = result.assertions.find((assertion) => !assertion.passed && assertion.severity === "gate");
-  if (!gate) return MISSING;
-  const expected = equalsExpected(gate.name);
-  if (expected !== undefined && gate.evidence !== undefined) {
-    return `expected ${expected}, received ${gate.evidence} · ${gate.name}`;
-  }
-  if (gate.name === "commandSucceeded()") {
-    const exitCode = commandExitCode(gate.evidence);
-    return `${exitCode === undefined ? "command failed" : `command exited ${exitCode}`} · ${gate.name}`;
-  }
-  return gate.detail ? `${gate.detail} · ${gate.name}` : gate.name;
-}
-
-function average(values: number[]): number {
-  return values.length === 0 ? 0 : values.reduce((sum, value) => sum + value, 0) / values.length;
-}
-
-function snapshotSummary(snapshot: Snapshot): string {
-  const counts: Record<Verdict, number> = { passed: 0, failed: 0, errored: 0, skipped: 0 };
-  for (const attempt of snapshot.attempts) counts[attempt.result.verdict] += 1;
-  const costs = snapshot.attempts.map((attempt) => attemptCostUSD(attempt.result)).filter((cost): cost is number => cost !== null);
-  const duration = average(snapshot.attempts.map((attempt) => attempt.result.durationMs));
-  return [
-    `${counts.passed} passed`,
-    `${counts.failed} failed`,
-    `${counts.errored} errored`,
-    `${counts.skipped} skipped`,
-    attemptsLabel(snapshot.attempts.length),
-    formatDurationMs(duration),
-    costs.length === 0 ? MISSING : formatUSD(average(costs)),
-  ].join(" · ");
-}
-
-function warningText(selection: Selection, width: number): string {
-  return selection.warnings
-    .flatMap((warning) => {
-      const lines = wrapDisplay(warning.message, Math.max(20, width - 9));
-      return lines.map((line, index) => `${index === 0 ? "WARNING  " : "         "}${line}`);
-    })
-    .join("\n");
-}
-
-function labeledBlock(label: string, value: string, width: number): string {
-  const prefix = padDisplay(label, 12);
-  return wrapDisplay(value, Math.max(8, width - stringWidth(prefix)))
-    .map((line, index) => `${index === 0 ? prefix : " ".repeat(stringWidth(prefix))}${line}`)
-    .join("\n");
-}
-
-function experimentAttemptTable(snapshot: Snapshot, width: number): string {
-  const separator = width >= 100 ? "   " : width >= 70 ? "  " : " ";
-  const fixedWidth = 9 + 9 + 8 + 5 + stringWidth(separator) * 5;
-  const flexible = Math.max(10, width - fixedWidth);
-  const naturalEval = Math.max(4, ...snapshot.attempts.map((attempt) => stringWidth(attempt.evalId)));
-  const evalWidth = Math.min(naturalEval, Math.max(4, Math.floor(flexible * 0.52)));
-  const resultWidth = Math.max(6, flexible - evalWidth);
-  const rows: string[][] = [["STATUS", "EVAL", "ATTEMPT", "RESULT", "DURATION", "COST"]];
-  for (const ev of snapshot.evals) {
-    for (const attempt of ev.attempts) {
-      const result = attempt.result;
-      const cost = attemptCostUSD(result);
-      rows.push([
-        showVerdictLabel(result.verdict),
-        clipDisplay(ev.id, evalWidth),
-        attempt.locator ?? MISSING,
-        clipDisplay(showResultReason(result), resultWidth),
-        result.verdict === "skipped" && result.durationMs === 0 ? MISSING : formatDurationMs(result.durationMs),
-        cost === null ? MISSING : formatUSD(cost),
-      ]);
-    }
-  }
-  return renderAlignedRows(rows, ["left", "left", "left", "left", "right", "right"], separator);
-}
-
-function comparisonTable(snapshots: Snapshot[], width: number): string {
-  const rows: string[][] = [["EXPERIMENT", "AGENT", "MODEL", "PASS", "FAILED", "ERROR", "SKIP", "DURATION", "COST"]];
-  for (const snapshot of snapshots) {
-    const verdicts = snapshot.evals.map((ev) => foldEvalVerdict(ev.attempts.map((attempt) => attempt.result)));
-    const passed = verdicts.filter((verdict) => verdict === "passed").length;
-    const failed = verdicts.filter((verdict) => verdict === "failed").length;
-    const errored = verdicts.filter((verdict) => verdict === "errored").length;
-    const skipped = verdicts.filter((verdict) => verdict === "skipped").length;
-    const ran = verdicts.length - skipped;
-    const costs = snapshot.attempts.map((attempt) => attemptCostUSD(attempt.result)).filter((cost): cost is number => cost !== null);
-    rows.push([
-      clipDisplay(snapshot.experimentId, Math.max(12, Math.floor(width * 0.24))),
-      snapshot.agent,
-      snapshot.model ?? MISSING,
-      ran === 0 ? MISSING : `${Math.round((passed / ran) * 1000) / 10}% ${passed}/${ran}`,
-      String(failed),
-      String(errored),
-      String(skipped),
-      formatDurationMs(average(snapshot.attempts.map((attempt) => attempt.result.durationMs))),
-      costs.length === 0 ? MISSING : formatUSD(average(costs)),
-    ]);
-  }
-  return renderAlignedRows(rows, ["left", "left", "left", "right", "right", "right", "right", "right", "right"]);
-}
-
-/** docs/feature/reports/show.md 的默认结果索引；只服务裸 show，不是可替换报告组件。 */
-export function showIndexText(selection: Selection, width: number): string {
-  const blocks: string[] = [];
-  const warnings = warningText(selection, width);
-  if (warnings) blocks.push(warnings);
-  if (selection.snapshots.length >= 2) blocks.push(`COMPARISON\n${comparisonTable(selection.snapshots, width)}`);
-  for (const snapshot of selection.snapshots) {
-    blocks.push(
-      [
-        labeledBlock("EXPERIMENT", `${snapshot.experimentId} · ${snapshot.agent}${snapshot.model ? ` · ${snapshot.model}` : ""}`, width),
-        labeledBlock("SUMMARY", snapshotSummary(snapshot), width),
-        "",
-        experimentAttemptTable(snapshot, width),
-      ].join("\n"),
-    );
-  }
-  blocks.push(labeledBlock("DRILL DOWN", "niceeval show @<attempt> [--eval | --execution | --diff]", width));
-  return blocks.join("\n\n");
-}
-
 function attemptsLabel(n: number): string {
   return `${n} ${n === 1 ? "attempt" : "attempts"}`;
 }
@@ -353,7 +187,7 @@ export function attemptHeader(attempt: AttemptHandle): string {
 
 // ───────────────────────── AttemptEvidence 共用 ─────────────────────────
 // evalSourceText / executionText / attemptOverviewText(--eval / --execution / 默认全景)
-// 与 evalDetailText 的紧凑索引列共用的小件:locator 头、capability 字母、失败原因、
+// 与 evalDetailText 的紧凑索引列共用的小件:locator 头、失败原因、
 // 断言计票摘要。三个证据 renderer 与全景面都只消费同一份 AttemptEvidence,不各自读
 // artifact 或重新判定 capability(loadAttemptEvidence 已经算好)。
 
@@ -362,36 +196,6 @@ export function attemptEvidenceHeader(evidence: AttemptEvidence): string {
   return [evidence.locator, evidence.identity.evalId, evidence.identity.experimentId, evidence.result.verdict].join(" · ");
 }
 
-/** capability 位 → 展示字母,只列为 true 的位;全部为 false 时返回空串(不打空 `[]`)。 */
-export function capabilityLetters(capabilities: AttemptEvidenceCapabilities): string {
-  const letters: string[] = [];
-  if (capabilities.eval) letters.push("E");
-  if (capabilities.execution) letters.push("X");
-  if (capabilities.timing) letters.push("⏱");
-  if (capabilities.diff) letters.push("D");
-  return letters.length > 0 ? `[${letters.join(",")}]` : "";
-}
-
-/**
- * 紧凑多 attempt 索引(裸 `niceeval show`、单 eval 多 experiment 行、evidence flag 撞多个
- * eval 时的消歧提示)用的廉价 capability 估算:只读瘦身 `EvalResult` 字段(`hasSources` /
- * `hasEvents` / `hasTrace`),不为了点亮一个字母去读 artifact —— 与
- * `report/compute.ts::attemptRow` 的 `hasEvidence` 同一个「只认瘦身字段」的口径(它同样只用
- * `hasEvents` / `hasTrace`,同样不读 diff.json)。`diff` 位没有对应的瘦身字段(不像
- * events/trace/sources,写入面从不给 diff 算一个 has* 布尔),而 diff.json 可达上百 MB,
- * 不该为了这一个字母在渲染路径上打开它(见 docs/feature/reports/architecture.md「计算与
- * 渲染分离」)——因此这里恒报 `false`;只有 `loadAttemptEvidence()` real 出的
- * capabilities(单 attempt 路径,如 `@<locator>` 全景)才知道真实答案。
- */
-export function cheapCapabilities(result: EvalResult): AttemptEvidenceCapabilities {
-  return {
-    eval: result.hasSources === true,
-    execution: result.hasEvents === true,
-    timing: result.hasEvents === true && result.hasTrace === true,
-    diff: false,
-  };
-}
-
 /**
  * 一次 attempt 未通过的判定原因,单行、不含 detail——供紧凑索引行使用。precedence 与
  * `report/compute.ts::reasonFor` 同一条规则(error → skipReason → 未通过的 gate 断言,
@@ -408,15 +212,14 @@ export function verdictReasonLine(result: EvalResult): string | undefined {
   return gates.map((a) => `gate ${a.name}`).join(", ");
 }
 
-/** 紧凑多 attempt 索引的一行:`✗ weather/brooklyn  @7K2M9Q[E,X,⏱]  gate calledTool(...)`。 */
+/** 紧凑多 attempt 索引的一行:`✗ weather/brooklyn  @7K2M9Q  gate calledTool(...)`。 */
 export function attemptIndexLine(opts: {
   evalId: string;
   verdict: Verdict;
   locator: string | undefined;
-  capabilities: AttemptEvidenceCapabilities;
   reason?: string;
 }): string {
-  const loc = opts.locator ? `${opts.locator}${capabilityLetters(opts.capabilities)}` : MISSING;
+  const loc = opts.locator ?? MISSING;
   const parts = [`${verdictMark(opts.verdict)} ${opts.evalId}`, loc];
   if (opts.reason) parts.push(opts.reason);
   return parts.join("  ");
@@ -463,7 +266,7 @@ export function evalDetailText(opts: EvalDetailOptions): string {
   blocks.push(description ? `${evalId} — ${description}` : evalId);
 
   // 每 experiment 一行:折叠判定、attempt 数、最新 attempt 的耗时、总成本、判定时间、
-  // 代表 attempt 的紧凑索引(locator + capability 字母 + 失败原因)——agent 从这张榜单
+  // 代表 attempt 的紧凑索引(locator + 失败原因)——agent 从这张榜单
   // 就能直接摘到一个 `@<locator>` 下钻,不必先跑一遍 `--eval`/`--execution` 才知道选谁。
   const rows: string[][] = [];
   for (const snapshot of snapshots) {
@@ -477,7 +280,7 @@ export function evalDetailText(opts: EvalDetailOptions): string {
       if (c !== null) cost = (cost ?? 0) + c;
     }
     const rep = pickDetailAttempt(ev.attempts);
-    const locatorCell = rep?.locator ? `${rep.locator}${capabilityLetters(cheapCapabilities(rep.result))}` : MISSING;
+    const locatorCell = rep?.locator ?? MISSING;
     const reasonCell = rep ? (verdictReasonLine(rep.result) ?? "") : "";
     rows.push([
       snapshot.experimentId,

package/src/show/show.test.ts

@@ -146,33 +146,30 @@ async function seedComposedRoot(): Promise<string> {
 
 // ───────────────────────── 榜单合成口径 ─────────────────────────
 
-describe("榜单:跨快照合成的现刻水位(show 专用 attempt 表)", () => {
-  it("局部重跑不撕榜单:另一题从更早快照补齐,单实验不出现比较空态", async () => {
+describe("默认报告:跨快照合成的现刻水位(ExperimentComparison text 面)", () => {
+  it("局部重跑不撕报告:另一题从更早快照补齐,缺成本时散点明确空态", async () => {
     const root = await seedComposedRoot();
     const { out, code } = await show(root, []);
     expect(code).toBe(0);
-    expect(out).not.toContain("No data to plot");
-    expect(out).not.toContain("At least 2 experiments");
+    expect(out).toContain("No data to plot Cost × Pass rate");
+    expect(out).toContain("1 point missing data");
+    expect(out).not.toContain("needed to compare");
     expect(out).not.toContain("COMPARISON");
-    expect(out).toContain("EXPERIMENT  compare/bub · bub");
-    expect(out).toContain("SUMMARY     1 passed · 1 failed · 0 errored · 0 skipped · 2 attempts");
-    expect(out).toMatch(/STATUS\s+EVAL\s+ATTEMPT\s+RESULT\s+DURATION\s+COST/);
-    expect(out).toMatch(/✗ failed\s+fixtures\/button\s+@1[0-9a-z]{7}\s+file was not modified/);
-    expect(out).toMatch(/✓ passed\s+weather\/brooklyn\s+@1[0-9a-z]{7}\s+—/);
-    expect(out).not.toMatch(/@1[0-9a-z]{7}[✓✗]/);
-    expect(out).not.toContain("[E,X,");
-    expect(out).toContain("DRILL DOWN  niceeval show @<attempt>");
+    expect(out).toMatch(/compare\/bub\s+default\s+bub\s+1s\s+50%/);
+    expect(out).toContain("1 passed / 1 failed");
+    expect(out).toMatch(/✗ failed\s+fixtures\/button[\s\S]*└─ @1[0-9a-z]{7}[\s\S]*fileChanged/);
+    expect(out).toMatch(/✓ passed\s+weather\/brooklyn[\s\S]*└─ @1[0-9a-z]{7}/);
+    expect(out).not.toMatch(/\[[EXD⏱,]+\]/);
   });
 
-  it("裸 show 使用稳定表头,不受自定义报告 locale chrome 影响", async () => {
+  it("裸 show 的默认报告 chrome 跟随 locale", async () => {
     const root = await seedComposedRoot();
     process.env.NICEEVAL_LANG = "zh-CN";
     try {
       const { out, code } = await show(root, []);
       expect(code).toBe(0);
-      expect(out).toMatch(/STATUS\s+EVAL\s+ATTEMPT\s+RESULT\s+DURATION\s+COST/);
-      expect(out).toContain("1 passed · 1 failed");
-      expect(out).not.toContain("没有可绘制的数据");
+      expect(out).toContain("预估成本 × 成功率 没有可绘制的数据");
+      expect(out).toContain("1 通过 / 1 失败");
       expect(out).toContain("compare/bub");
     } finally {
       process.env.NICEEVAL_LANG = "en";
@@ -183,13 +180,13 @@ describe("榜单:跨快照合成的现刻水位(show 专用 attempt 表)", () =>
     const root = await seedComposedRoot();
     const { out, code } = await show(root, [], {}, 60);
     expect(code).toBe(0);
-    expect(out).toContain("…");
+    expect(out).toContain("fixtures/button");
     for (const line of out.trimEnd().split("\n")) {
       expect(stringWidth(line), line).toBeLessThanOrEqual(60);
     }
   });
 
-  it("多个 experiment 先显示紧凑比较表,再逐 experiment 显示 attempt 表", async () => {
+  it("多个 experiment 显示散点图,再逐 experiment → Eval → Attempt", async () => {
     const root = await makeRoot();
     await writeSnapshot(root, "2026-07-08T10-00-00-000Z", { experimentId: "compare/a", agent: "codex", model: "mini", startedAt: "2026-07-08T10:00:00.000Z" }, [
       res("q1", "passed", { estimatedCostUSD: 0.1 }),
@@ -201,11 +198,13 @@ describe("榜单:跨快照合成的现刻水位(show 专用 attempt 表)", () =>
     ]);
     const { out, code } = await show(root, []);
     expect(code).toBe(0);
-    expect(out).toMatch(/COMPARISON\nEXPERIMENT\s+AGENT\s+MODEL\s+PASS\s+FAILED\s+ERROR\s+SKIP\s+DURATION\s+COST/);
-    expect(out).toContain("50% 1/2");
-    expect(out).toContain("100% 2/2");
-    expect(out.match(/^EXPERIMENT  compare\//gm)).toHaveLength(2);
-    expect(out).not.toContain("At least 2 experiments");
+    expect(out).toContain("better → upper right");
+    expect(out).toContain("A compare/a   B compare/b");
+    expect(out).toMatch(/compare\/b\s+large\s+claude\s+1s\s+100%/);
+    expect(out).toMatch(/compare\/a\s+mini\s+codex\s+1s\s+50%/);
+    expect(out).toMatch(/✓ passed\s+q1[\s\S]*└─ @1[0-9a-z]{7}/);
+    expect(out).toMatch(/✗ failed\s+q2[\s\S]*└─ @1[0-9a-z]{7}/);
+    expect(out).not.toContain("needed to compare");
   });
 
   it("合成 Selection:每 experiment × eval 取最新判定;compose 不产生残缺警告", async () => {

package/src/view/data.test.ts

@@ -251,7 +251,7 @@ describe("loadViewScan · 新布局落盘直接可读(写入面 / 读取面同
     );
 
     const { viewData, reportHtml } = await loadViewScan(root);
-    // 报告槽(CostPassRateComparison 的 web 面):Experiment 工作台行 + 官方通过率格子(1 过 1 败 = 50%)。
+    // 报告槽(ExperimentComparison 的 web 面):Experiment 工作台行 + 官方通过率格子(1 过 1 败 = 50%)。
     expect(reportHtml.en).toContain("compare/bub");
     expect(reportHtml.en).toContain("50%");
     const snapshot = viewData.snapshots[0]!;

package/src/view/data.ts

@@ -1,7 +1,7 @@
 // view 的数据层:读取经 niceeval/results 的 openResults(布局/版本知识只住在那)。
 // 这里只做编排:报告槽 Selection 恒经 selectCurrentResults(现刻水位;与 show 调同一个函数,
 // 两扇门判定不分叉)、快照明细注入(locator / artifactBase)、skipped 透传、报告槽渲染
-// (renderReportSlot:裸跑填充 CostPassRateComparison,--report 整槽替换,en / zh-CN 双语各渲染一遍)。
+// (renderReportSlot:裸跑填充 ExperimentComparison,--report 整槽替换,en / zh-CN 双语各渲染一遍)。
 // --report 只换报告定义,注入的 Selection 与裸跑同一份。统计口径整体住在报告槽里
 // (报告组件的官方计算函数),viewData 不再携带 overview / 榜单这类统计产物,
 // 见 docs/feature/reports/view.md「打开与收窄」。
@@ -37,7 +37,7 @@ export interface ViewScan {
   attemptsByBase: Map<string, AttemptHandle>;
   /**
    * 报告槽:报告树经 renderReportToStaticHtml 渲染出的静态 HTML(en / zh-CN 各一份),
-   * 裸跑填充内置默认报告 CostPassRateComparison,--report 整槽替换。作为两个 <template> 静态块
+   * 裸跑填充内置默认报告 ExperimentComparison,--report 整槽替换。作为两个 <template> 静态块
    * 烘进页面(与 __NICEEVAL_VIEW_DATA__ 相邻),不进 viewData —— 前端只负责把当前
    * 界面语言对应的那块 HTML 摆进报告槽位置,不解析。
    */
@@ -154,7 +154,7 @@ export async function loadLatestResultsPerEval(root = ".niceeval"): Promise<Eval
  * 报告槽 Selection 恒经 selectCurrentResults 合成(现刻水位;与 `niceeval show` 调同一个
  * 函数,裸跑与局部收窄不分叉),位置前缀 / --experiment 只作为 scope 传入,不切换选择口径。
  * --report 本身不改挑选——它只换报告槽的填充,注入的 Selection 与裸跑同一份,
- * 「裸跑 ≡ --report <CostPassRateComparison>」靠这条成立(docs/feature/reports/architecture.md「Selection 是计算入口」)。
+ * 「裸跑 ≡ --report <ExperimentComparison>」靠这条成立(docs/feature/reports/architecture.md「Selection 是计算入口」)。
  * 证据室数据(快照明细 / skipped)恒为全量,深链在任何收窄下都可达。
  * 零可读结果一律抛 ViewInputError,不渲染/导出空页面(server 起不来,--out 非零退出)。
  */
@@ -200,7 +200,7 @@ export async function loadViewScan(input?: string, opts: ViewScanOptions = {}):
     );
   }
 
-  // 报告槽:裸跑填充 CostPassRateComparison,--report 整槽替换。报告吃同一份注入 Selection,
+  // 报告槽:裸跑填充 ExperimentComparison,--report 整槽替换。报告吃同一份注入 Selection,
   // web 面在计算侧静态渲染成 HTML(en / zh-CN 各一遍,切界面语言不重算数据)。
   const reportHtml = await renderReportSlot(opts.report, results, selection);
 
@@ -288,7 +288,7 @@ export async function loadAttemptIndex(input?: string): Promise<Map<string, Atte
 
 /**
  * 报告槽渲染:装载报告文件(--report;dev server 语义 —— 文件变更下次请求整页重算,
- * 经 mtime cache-busting),缺省用内置默认报告 CostPassRateComparison → 注入 Selection →
+ * 经 mtime cache-busting),缺省用内置默认报告 ExperimentComparison → 注入 Selection →
  * web 面 renderToStaticMarkup 成静态 HTML,en / zh-CN 各渲染一遍(chrome 文案按 locale)。
  * react / react-dom 动态加载:data.ts 还被 runner 的续跑携带(loadLatestResultsPerEval)
  * 消费,渲染依赖不进那条路径。attemptHref 缺省即 `#/attempt/@<locator>` 深链路由(web.ts 的默认值),
@@ -307,7 +307,7 @@ async function renderReportSlot(
   // 一个走 src。
   const definition = report
     ? await loadReportFile(report.cwd, report.path, { freshImport: true })
-    : (await import("../../dist/report/built-ins/index.js")).CostPassRateComparison;
+    : (await import("../../dist/report/built-ins/index.js")).ExperimentComparison;
   const { renderReportToStaticHtml } = await import("../../dist/report/web.js");
   const ctx = { selection, results };
   return {

package/src/view/index.ts

@@ -77,7 +77,7 @@ export function resolveViewInput(
  * 导出静态报告(--out):只有目录式一种形态。写 <dir>/index.html,并把前端会 fetch 的 artifact
  * (sources.json / events.json / trace.json)复制到 <dir>/artifact/<base>/——与本地
  * server 的 /artifact/<rel> 路由同一布局,整个目录扔给任何静态托管即是完整体验。
- * 首页即报告槽(裸跑填充 CostPassRateComparison,--report 整槽替换),证据室同站。
+ * 首页即报告槽(裸跑填充 ExperimentComparison,--report 整槽替换),证据室同站。
  * 单文件(*.html)导出已移除:代码/transcript/trace 视图依赖 artifact 文件,单文件注定残缺,
  * 存在本身就在诱导用户导出一份看不了证据的报告(docs/feature/reports/view.md「静态导出」)。
  */

package/src/view/shared/types.ts

@@ -3,7 +3,7 @@
 //
 // viewData 只携带证据室与壳需要的东西:快照明细(locator / artifactBase 已注入)、
 // skipped、项目名与 run 元信息。统计口径(KPI / 榜单 / 挑选警告)整体住在报告槽的
-// 静态 HTML 里(CostPassRateComparison 或 --report 的报告自己算),壳与报告之间没有第二条数据通道。
+// 静态 HTML 里(ExperimentComparison 或 --report 的报告自己算),壳与报告之间没有第二条数据通道。
 
 import type { EvalResult, LocalizedText } from "../../types.ts";
 import type { ReportLocale } from "../../report/locale.ts";

package/src/view/view-report.test.ts

@@ -3,8 +3,8 @@
 // 覆盖:
 // - 组合语义与 show 对齐:位置前缀收窄报告槽 Selection、--experiment 过滤、匹配不到直说;
 // - 单文件模式共存:存在的文件路径 → 单文件模式,目录报错直说走 --run,其余按 eval 前缀;
-// - 报告槽恒在:裸跑填充 CostPassRateComparison,--report 整槽替换;en / zh-CN 双语各渲染一遍;
-//   裸跑 ≡ --report <re-export CostPassRateComparison 的文件>(等价性);
+// - 报告槽恒在:裸跑填充 ExperimentComparison,--report 整槽替换;en / zh-CN 双语各渲染一遍;
+//   裸跑 ≡ --report <re-export ExperimentComparison 的文件>(等价性);
 // - --out 静态导出:index.html 含两个语言的报告块、官方样式与增强 runtime,报告块零 <script>;
 // - dev server 装载语义:报告文件变更 → 下次装载整页重算(mtime cache-busting)。
 //
@@ -169,10 +169,10 @@ describe("loadViewScan · 组合语义", () => {
   });
 });
 
-// ─────────────────── 报告槽恒在:裸跑 ≡ --report <CostPassRateComparison> ───────────────────
+// ─────────────────── 报告槽恒在:裸跑 ≡ --report <ExperimentComparison> ───────────────────
 
 describe("loadViewScan · 默认报告槽(裸跑)", () => {
-  it("裸跑产出的报告槽 HTML 与 --report <re-export CostPassRateComparison 的文件> 完全一致(双语)", async () => {
+  it("裸跑产出的报告槽 HTML 与 --report <re-export ExperimentComparison 的文件> 完全一致(双语)", async () => {
     const root = await seedRoot();
     const bare = await loadViewScan(root);
     const viaReport = await loadViewScan(root, {
@@ -340,7 +340,7 @@ describe("buildView · --out 与 --report", () => {
     ).toBe(true);
   });
 
-  it("默认导出(无 --report):报告槽填充 CostPassRateComparison,双语块与增强 runtime 恒内联", async () => {
+  it("默认导出(无 --report):报告槽填充 ExperimentComparison,双语块与增强 runtime 恒内联", async () => {
     const root = await seedRoot();
     const out = join(root, "site");
     await buildView({ input: root, out });

package/dist/o11y/execution-tree.d.ts

@@ -1,103 +0,0 @@
-import type { InputRequest, JsonValue, StreamEvent, ToolName, TraceSpan } from "../types.ts";
-interface ExecutionNodeBase {
-    /** 本函数内确定性生成,同一份 (events, spans) 输入永远产出同一批 id(不是全局稳定 id,
-     * 不跨调用持久化——目前没有下游需要跨次运行比对同一个节点)。 */
-    id: string;
-    /** 唯一关联上的 OTel span(供下钻;渲染层用 endMs - startMs 算耗时)。action 节点的
-     * span.attributes 额外补了 io.tool/io.input/io.output/io.status(见 withIoAttributes);
-     * 其余节点原样保留。缺失 = timing unavailable——要么这次运行没有 OTel 接入,要么有 span
-     * 但没能唯一关联到这个节点上;两种情况都不是「假装有耗时」,统一表现为字段不存在。 */
-    span?: TraceSpan;
-}
-export interface ExecutionMessageNode extends ExecutionNodeBase {
-    kind: "message";
-    role: "assistant" | "user";
-    text: string;
-}
-export interface ExecutionThinkingNode extends ExecutionNodeBase {
-    kind: "thinking";
-    text: string;
-}
-/** Skill 加载节点——一等,直接来自 StreamEvent 的 "skill.loaded",不靠工具名/文本猜。 */
-export interface ExecutionSkillNode extends ExecutionNodeBase {
-    kind: "skill.loaded";
-    skill: string;
-    /**
-     * 仅当原生协议把 Skill 加载表达成可关联的工具调用时才有,和 StreamEvent 同名字段同一含义。
-     * 存在时参与和 action/subagent 节点同一套 callId 关联(见主函数 nodeByCallId):Claude Code
-     * 的 Skill 调用本身就是一次 tool_use,OTel mapper 同样会把它的 tool_use_id 复制成
-     * span.attributes.call_id,唯一命中时这个节点也应该拿到 timing,不因为节点 kind 是
-     * skill.loaded 就被排除在 enrichment 之外。
-     */
-    callId?: string;
-}
-/**
- * action.called + action.result 按 callId 合并成一个节点。`status` 多了 "pending"
- * (StreamEvent 的 action.result.status 没有这一档)——这是 ExecutionTree 独有的中间态,
- * 表示这次运行结束时结果始终没有回来(如超时截断的 transcript),诚实地区分「还没完成」
- * 和「跑完但失败/被拒绝」。
- */
-export interface ExecutionActionNode extends ExecutionNodeBase {
-    kind: "action";
-    callId: string;
-    /** 原始工具名(未归一化),对齐 StreamEvent.action.called.name。 */
-    name: string;
-    /** 归一化后的规范工具名,省略表示 adapter 没能归一(等同 ToolCall.name 缺省为 "unknown")。 */
-    tool?: ToolName;
-    input: JsonValue;
-    output?: JsonValue;
-    status: "pending" | "completed" | "failed" | "rejected";
-}
-/** subagent.called + subagent.completed 按 callId 合并;pending 语义同 ExecutionActionNode。 */
-export interface ExecutionSubagentNode extends ExecutionNodeBase {
-    kind: "subagent";
-    callId: string;
-    name: string;
-    remoteUrl?: string;
-    output?: JsonValue;
-    status: "pending" | "completed" | "failed";
-}
-export interface ExecutionInputRequestedNode extends ExecutionNodeBase {
-    kind: "input.requested";
-    request: InputRequest;
-}
-export interface ExecutionCompactionNode extends ExecutionNodeBase {
-    kind: "compaction";
-    reason?: string;
-}
-export interface ExecutionErrorNode extends ExecutionNodeBase {
-    kind: "error";
-    message: string;
-}
-/**
- * span 存在、有意义,但唯一关联不到任何骨架节点——原样保留成独立节点,清楚标注「只有遥测、
- * 没有对应事件」,不悄悄猜着并进某个骨架节点。`span` 是必填字段:这类节点的全部内容就是
- * 这一条 span 本身,没有骨架事件可以叠加。
- */
-export interface ExecutionTelemetryNode {
-    kind: "telemetry";
-    id: string;
-    span: TraceSpan;
-}
-export type ExecutionNode = ExecutionMessageNode | ExecutionThinkingNode | ExecutionSkillNode | ExecutionActionNode | ExecutionSubagentNode | ExecutionInputRequestedNode | ExecutionCompactionNode | ExecutionErrorNode | ExecutionTelemetryNode;
-export interface ExecutionTree {
-    /**
-     * 骨架节点在前,顺序 = 事件出现顺序;telemetry-only 节点(未能唯一关联的 span)
-     * 按 span.startMs 追加在骨架之后——它们不属于骨架,不改变骨架的节点/顺序/内容,
-     * 只是叠加在末尾的额外证据。
-     */
-    nodes: ExecutionNode[];
-    /**
-     * 这次运行是否提供过任何 span——不代表关联成功,只代表「OTel 接入过」。供渲染层区分
-     * 两种不同的诚实提示:整体没有 OTel 接入(该字段为 false,所有节点自然都没有 span),
-     * 和 OTel 接入了但这一个节点恰好关联不上(该字段为 true,该节点的 span 仍缺失)。
-     */
-    timingAvailable: boolean;
-}
-/**
- * 纯函数:把标准事件流(骨架)与一批已挑选好的 OTel span(可选 enrichment)合成一棵
- * ExecutionTree。events 决定节点的存在、顺序与内容;spans 只能给已存在的节点补时间,
- * 从不新增、删除或重排骨架节点。
- */
-export declare function buildExecutionTree(events: readonly StreamEvent[], spans: readonly TraceSpan[]): ExecutionTree;
-export {};

package/dist/o11y/otlp/select.d.ts

@@ -1,22 +0,0 @@
-import type { ToolCall, TraceSpan } from "../../types.ts";
-/**
- * 选出要保留并落盘的 span。
- * 小 trace 原样返回;大 trace 按 canonical kind 过滤(kind ≠ "other" 留);
- * 没 mapper(kind 全 "other")则回落到 firehose 频率过滤;仍过多再按耗时硬截断。
- * 最后一律按起点排序,view 直接当瀑布图渲染。
- */
-export declare function selectTraceSpans(spans: TraceSpan[]): TraceSpan[];
-/**
- * I/O 文本上限:文件内容/命令输出可能很大,截一下别把 trace 撑爆。导出给
- * `execution-tree.ts` 复用——ExecutionTree 的 action 节点给合并上去的 span 补同一份
- * io.* attributes,必须和这里同一个截断预算,不能另立一个数字。
- */
-export declare const IO_MAX = 4000;
-export declare function ioText(v: unknown): string;
-/**
- * 给工具执行 span 补上真实「入参/出参」:codex 等的 OTLP span 只带 tool_name/call_id,
- * 命令文本与输出在 stdout transcript(events)里 —— 按 call_id 把 deriveRunFacts 的
- * ToolCall.input/output join 到对应 span 的 attributes(io.input / io.output / io.tool)。
- * 没匹配上的 span 原样返回。
- */
-export declare function enrichTraceWithIO(spans: TraceSpan[], toolCalls: readonly ToolCall[]): TraceSpan[];

package/dist/report/built-ins/cost-pass-rate-comparison.d.ts

@@ -1 +0,0 @@
-export declare const CostPassRateComparison: import("../report.ts").ReportDefinition;

package/dist/report/built-ins/cost-pass-rate-comparison.js

@@ -1,17 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// CostPassRateComparison:show / view 裸跑时的出厂报告槽。
-//
-// 它是一份普通 ReportDefinition,零特权:只声明「摆什么」——成本 × 通过率的散点(比较
-// experiments)和实验列表。散点走 selection-form(`MetricScatter` 声明了 `resolve`,宿主
-// 渲染前的 resolveReportTree 会替它调 `.data`);`ExperimentList` 没有 selection-form,
-// 报告函数体里直接 `await ExperimentList.data(selection)` 拿到普通数组再传 `items`——
-// 这正是三个实体列表统一的用法,内置默认报告不搞一套特权写法。包外用户复制这段 TSX
-// (只改 import 路径与 export 形式)会走完全相同的解析与渲染管线。
-import { Col } from "../primitives.js";
-import { ExperimentList, MetricScatter } from "../components.js";
-import { costUSD, passRate } from "../metrics.js";
-import { defineReport } from "../report.js";
-export const CostPassRateComparison = defineReport(async ({ selection }) => {
-    const experiments = await ExperimentList.data(selection);
-    return (_jsxs(Col, { children: [_jsx(MetricScatter, { selection: selection, points: "experiment", series: "agent", x: costUSD, y: passRate }), _jsx(ExperimentList, { items: experiments })] }));
-});