niceeval 0.6.1 → 0.7.0

package/src/show/show.test.ts

@@ -1,11 +1,12 @@
-// niceeval show 终端宿主的测试(行为规范:docs-site/zh/guides/viewing-results.mdx;
+// cases: docs/engineering/unit-tests/reports/cases.md
+// niceeval show 终端宿主的测试(行为规范:docs-site/zh/how-to/viewing-results.mdx;
 // 组合语义:docs/feature/reports/architecture.md「Selection 是计算入口」)。覆盖:
 // - 榜单合成口径:每 experiment × eval 取最新判定,局部重跑从更早快照补齐,头部标注合成自几个快照;
 // - 前缀过滤收窄 Selection,覆盖警告分母 = 已知并集 ∩ 范围;
 // - --history 时间轴只列真实执行,resume 携带的复印件不占行;
 // - --report 装载(合法 / 非法默认导出 / 文件缺失)、位置前缀收窄注入 Selection、attemptCommand 下钻;
 // - 互斥:--history 与 --report;
-// - 单 eval 详情、`@<locator>` 精确定位与 --eval / --execution / --diff 证据切面的输出形态。
+// - 单 eval 详情、`@<locator>` 精确定位与 --source / --execution / --diff 证据切面的输出形态。
 //
 // fixture 直接写新布局(<expDir>/<snapDir>/snapshot.json + <evalId>/a<n>/result.json),
 // 依据是 docs/feature/results/architecture.md 的稳定磁盘契约,不经 writer 运行时 API(避免与并行重写的
@@ -17,9 +18,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createHash } from "node:crypto";
 import { openResults } from "../results/index.ts";
-import { RESULTS_FORMAT, RESULTS_SCHEMA_VERSION, type EvalResult, type Verdict } from "../types.ts";
+import { RESULTS_FORMAT, RESULTS_SCHEMA_VERSION, type EvalResult, type TimingNode, type TraceSpan, type Verdict } from "../types.ts";
 import { selectCurrentResults } from "../results/select.ts";
-import { evalHistory } from "./compose.ts";
+import { attemptHistory } from "./compose.ts";
 import { runShow, type ShowFlags } from "./index.ts";
 import { stringWidth } from "../report/text/layout.ts";
 
@@ -52,7 +53,7 @@ type AttemptFixture = Pick<EvalResult, "id" | "verdict"> &
   Partial<
     Pick<
       EvalResult,
-      "attempt" | "durationMs" | "assertions" | "estimatedCostUSD" | "usage" | "error" | "startedAt" | "artifactBase" | "hasEvents" | "hasTrace"
+      "attempt" | "durationMs" | "assertions" | "estimatedCostUSD" | "usage" | "error" | "diagnostics" | "startedAt" | "artifactBase" | "hasEvents" | "hasTrace" | "phases"
     >
   >;
 
@@ -112,7 +113,7 @@ interface Captured {
 async function show(root: string, patterns: string[], flags: ShowFlags = {}, width = 100): Promise<Captured> {
   let out = "";
   let err = "";
-  const code = await runShow(root, patterns, { run: root, ...flags }, {
+  const code = await runShow(root, patterns, { results: root, ...flags }, {
     out: (s) => (out += s),
     err: (s) => (err += s),
     width,
@@ -135,7 +136,7 @@ async function seedComposedRoot(): Promise<string> {
           name: 'fileChanged("src/components/Button.tsx")',
           severity: "gate",
           score: 0,
-          passed: false,
+          outcome: "failed" as const,
           detail: "file was not modified",
         },
       ],
@@ -151,12 +152,12 @@ describe("默认报告:跨快照合成的现刻水位(ExperimentComparison text
     const root = await seedComposedRoot();
     const { out, code } = await show(root, []);
     expect(code).toBe(0);
-    expect(out).toContain("No data to plot Cost × Pass rate");
+    expect(out).toContain("No data to plot Cost × End-to-end pass rate");
     expect(out).toContain("1 point missing data");
     expect(out).not.toContain("needed to compare");
     expect(out).not.toContain("COMPARISON");
-    expect(out).toMatch(/compare\/bub\s+default\s+bub\s+1s\s+50%/);
-    expect(out).toContain("1 passed / 1 failed");
+    expect(out).toMatch(/\bbub\s+default\s+bub\s+1s\s+50%/);
+    expect(out).toMatch(/1 passed[\s\S]*?\/ 1\s+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⏱,]+\]/);
@@ -168,9 +169,9 @@ describe("默认报告:跨快照合成的现刻水位(ExperimentComparison text
     try {
       const { out, code } = await show(root, []);
       expect(code).toBe(0);
-      expect(out).toContain("预估成本 × 成功率 没有可绘制的数据");
+      expect(out).toContain("成本 × 端到端成功率 没有可绘制的数据");
       expect(out).toContain("1 通过 / 1 失败");
-      expect(out).toContain("compare/bub");
+      expect(out).toMatch(/\bbub\s+默认\s+bub\s+1s\s+50%/);
     } finally {
       process.env.NICEEVAL_LANG = "en";
     }
@@ -198,10 +199,11 @@ describe("默认报告:跨快照合成的现刻水位(ExperimentComparison text
     ]);
     const { out, code } = await show(root, []);
     expect(code).toBe(0);
+    // 成本轴(better: lower)反向,「更好」恒指向右上;两轴都声明 better → 提示在场
     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(/\bb\s+large\s+claude\s+1s\s+100%/);
+    expect(out).toMatch(/\ba\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");
@@ -280,15 +282,15 @@ describe("单 eval 详情", () => {
               name: 'calledTool("get_weather")',
               severity: "gate",
               score: 0,
-              passed: false,
+              outcome: "failed" as const,
               detail: "tool was never called",
             },
-            { name: "succeeded()", severity: "gate", score: 1, passed: true },
+            { name: "succeeded()", severity: "gate", score: 1, outcome: "passed" as const },
             {
               name: 'judge("回答基于实时数据")',
               severity: "soft",
               score: 0.2,
-              passed: false,
+              outcome: "failed" as const,
               detail: "reply invents a temperature without any tool call",
             },
           ],
@@ -311,7 +313,7 @@ describe("单 eval 详情", () => {
     // 每 experiment 一行都带紧凑索引(locator + 失败原因),详情块再补一条精确的 attempt locator
     expect(out).toMatch(/✗ failed\s+2 attempts.*@1[0-9a-z]{7}.*gate calledTool/);
     expect(out).toMatch(/attempt locator: @1[0-9a-z]{7}/);
-    expect(out).toMatch(/next: niceeval show @1[0-9a-z]{7} \[--eval\|--execution\|--diff\]/);
+    expect(out).toMatch(/next: niceeval show @1[0-9a-z]{7} \[--source\|--execution\|--diff\]/);
   });
 });
 
@@ -341,68 +343,94 @@ describe("--history 时间轴", () => {
         res("weather/brooklyn", "failed", {
           attempt: 1,
           estimatedCostUSD: 0.04,
-          assertions: [{ name: 'calledTool("get_weather")', severity: "gate", score: 0, passed: false }],
+          assertions: [{ name: 'calledTool("get_weather")', severity: "gate", score: 0, outcome: "failed" as const }],
         }),
       ],
     );
     return root;
   }
 
-  it("时间轴只列真实执行:复印件不占行,新失败带断言", async () => {
+  it("逐 attempt 分节:复印件按身份键去重不占行,startedAt 升序,行带摘要 / 成本 / locator", async () => {
     const root = await seedHistoryRoot();
     const results = await openResults(root);
     const exp = results.experiments.find((e) => e.id === "compare/bub")!;
-    const rows = evalHistory(exp, "weather/brooklyn");
-    // 快照2 里复印件被识别,真实执行只有:快照1 的 passed + 快照2 的 failed(新 attempt)
+    const rows = attemptHistory(exp, "weather/brooklyn");
+    // 快照2 里复印件被识别(与快照1 的真实执行同身份键),历次 attempt = 快照1 的 passed +
+    // 快照2 的 failed(新 attempt);startedAt 升序,旧的在前。
     expect(rows).toHaveLength(2);
-    expect(rows[0]).toMatchObject({ verdict: "failed", attempts: 1, costUSD: 0.04 });
-    expect(rows[0].failedAssertion).toBe('gate calledTool("get_weather")');
-    expect(rows[1]).toMatchObject({ verdict: "passed", attempts: 1, costUSD: 0.03 });
+    expect(rows[0]).toMatchObject({ verdict: "passed", costUSD: 0.03 });
+    expect(rows[0].summary).toBeUndefined();
+    expect(rows[1]).toMatchObject({ verdict: "failed", costUSD: 0.04 });
+    expect(rows[1].summary).toContain('calledTool("get_weather")');
+    expect(rows[1].locator).toMatch(/^@/);
 
     const { out, code } = await show(root, ["weather/brooklyn"], { history: true });
     expect(code).toBe(0);
-    expect(out).toContain("compare/bub · 2 runs · passed 1/2");
-    expect(out).toContain("2026-07-09T10-00");
-    expect(out).toContain("2026-07-07T09-00");
-    // 复印件那份 passed 判定只出现一行(快照1),不在快照2 再占一行
+    // 分节头:experimentId + evalId 一起出现,计数按 attempt。
+    expect(out).toContain("weather/brooklyn · compare/bub · 2 attempts · passed 1/2");
+    // 复印件那份 passed 判定只出现一行,不在快照2 再占一行;升序:passed 行在 failed 行之前。
     expect(out.match(/✓ passed/g)).toHaveLength(1);
+    expect(out.indexOf("✓ passed")).toBeLessThan(out.indexOf("✗ failed"));
+    // 每行携带可复制的 locator。
+    expect(out).toMatch(/@\w+/);
   });
 
-  it("裸 --history:每个 experiment 的 per-run 通过率序列", async () => {
+  it("裸 --history:对 Scope 中每个 experimentId + evalId 分节,不再输出快照级序列", async () => {
     const root = await seedHistoryRoot();
     const { out, code } = await show(root, [], { history: true });
     expect(code).toBe(0);
-    expect(out).toContain("compare/bub · 2 runs");
-    // 每个快照一行(快照2 折叠含携带的 passed 复印件,任一轮通过 → passed)
-    expect(out.match(/1\/1 passed/g)).toHaveLength(2);
+    expect(out).toContain("weather/brooklyn · compare/bub · 2 attempts · passed 1/2");
+    // 不是「每个快照一行」的通过率序列。
+    expect(out).not.toContain("1/1 passed");
+  });
+
+  it("--history 与 --page 组合是用法矛盾:直说", async () => {
+    const root = await seedHistoryRoot();
+    const { err, code } = await show(root, [], { history: true, page: "report" });
+    expect(code).toBe(1);
+    expect(err).toContain("--page");
   });
 });
 
 // ───────────────────────── --report 装载与组合语义 ─────────────────────────
 
 describe("--report 装载", () => {
-  /** 不经 niceeval 包也能造出合法报告:判别与双面组件都锚在 Symbol.for 上。 */
+  /**
+   * 不经 niceeval 包也能造出合法报告:判别、组合组件与双面组件都锚在 Symbol.for 上
+   * (docs/feature/reports/library/shell.md「defineReport 产物」、layout.md「自定义组件」)。
+   * Custom 是双面组件,读 props 直接渲染;Wrapper 是组合组件,用 ComposeContext 的 scope
+   * 算出 evals / locator 再装配进 Custom —— 对应 defineReport(<Wrapper />) 的展开形态。
+   */
   async function writeReportFile(dir: string): Promise<string> {
     const path = join(dir, "report.mjs");
     await writeFile(
       path,
       [
         'const FACES = Symbol.for("niceeval.report.faces");',
+        'const COMPOSE = Symbol.for("niceeval.report.compose");',
+        'const DEFINITION = Symbol.for("niceeval.report.definition");',
         "const Custom = () => null;",
         "Custom[FACES] = {",
         "  web: () => null,",
         "  text: (props, ctx) => `CUSTOM ${props.evals} · drill ${ctx.attemptCommand(props.locator)}`,",
         "};",
-        "export default {",
-        '  [Symbol.for("niceeval.report.definition")]: true,',
-        "  build: (ctx) => ({",
-        "    type: Custom,",
-        "    props: {",
-        "      evals: ctx.selection.snapshots.flatMap((s) => s.evals.map((e) => e.id)).sort().join(\",\"),",
-        "      locator: ctx.selection.snapshots[0].evals[0].attempts[0].locator,",
-        "    },",
-        "  }),",
+        "const Wrapper = () => null;",
+        "Wrapper[COMPOSE] = (props, ctx) => ({",
+        "  type: Custom,",
+        "  props: {",
+        "    evals: ctx.scope.snapshots.flatMap((s) => s.evals.map((e) => e.id)).sort().join(\",\"),",
+        "    locator: ctx.scope.snapshots[0].evals[0].attempts[0].locator,",
+        "  },",
+        "});",
+        "const definition = {",
+        '  kind: "report",',
+        "  links: [],",
+        "  scripts: [],",
+        "  styles: [],",
+        '  pages: [{ id: "report", title: "Report", content: { type: Wrapper, props: {} } }],',
         "};",
+        "Object.defineProperty(definition, DEFINITION, { value: true });",
+        "export default definition;",
         "",
       ].join("\n"),
       "utf-8",
@@ -472,6 +500,29 @@ describe("--report 装载", () => {
     expect(out).not.toContain("CUSTOM");
     expect(out).toContain("no diff recorded"); // fixture 没有 diff artifact:如实说缺
   });
+
+  it("--page 命中单页定义的唯一页 id `report`:与直接渲染等价", async () => {
+    const root = await seedComposedRoot();
+    const report = await writeReportFile(root);
+    const bare = await show(root, [], { report });
+    const paged = await show(root, [], { report, page: "report" });
+    expect(paged.code).toBe(0);
+    expect(paged.out).toBe(bare.out);
+  });
+
+  it("--page 未命中:按用法错误非零退出并列出可用页 id(内建报告同样成立)", async () => {
+    const root = await seedComposedRoot();
+    const report = await writeReportFile(root);
+    const miss = await show(root, [], { report, page: "typo" });
+    expect(miss.code).toBe(1);
+    expect(miss.err).toContain(`page "typo" not found in ${report}`);
+    expect(miss.err).toContain("Available pages: report");
+
+    const builtin = await show(root, [], { page: "typo" });
+    expect(builtin.code).toBe(1);
+    expect(builtin.err).toContain('page "typo" not found in the built-in report');
+    expect(builtin.err).toContain("Available pages: report");
+  });
 });
 
 // ───────────────────────── 证据切面:--execution ─────────────────────────
@@ -540,18 +591,18 @@ describe("--execution", () => {
   });
 });
 
-// ───────────────────────── 证据切面:--eval ─────────────────────────
+// ───────────────────────── 证据切面:--source ─────────────────────────
 
-describe("--eval", () => {
+describe("--source", () => {
   it("evalSource === null 时如实说源码未捕获", async () => {
     const root = await makeRoot();
     await writeSnapshot(
       root,
       "2026-07-08T10-00-00-000Z",
       { experimentId: "compare/bub", startedAt: "2026-07-08T10:00:00.000Z" },
-      [res("weather/brooklyn", "failed", { assertions: [{ name: "succeeded()", severity: "gate", score: 0, passed: false }] })],
+      [res("weather/brooklyn", "failed", { assertions: [{ name: "succeeded()", severity: "gate", score: 0, outcome: "failed" as const }] })],
     );
-    const { out, code } = await show(root, ["weather/brooklyn"], { eval: true });
+    const { out, code } = await show(root, ["weather/brooklyn"], { source: true });
     expect(code).toBe(0);
     expect(out).toContain("eval source unavailable for this attempt");
   });
@@ -569,11 +620,11 @@ describe("--eval", () => {
               name: 'calledTool("get_weather")',
               severity: "gate",
               score: 0,
-              passed: false,
+              outcome: "failed" as const,
               detail: "tool was never called",
               loc: { file: "evals/weather/brooklyn.eval.ts", line: 2 },
             },
-            { name: "unlocated()", severity: "soft", score: 0.5, passed: false, detail: "no loc on this one" },
+            { name: "unlocated()", severity: "soft", score: 0.5, outcome: "failed" as const, detail: "no loc on this one" },
           ],
         }),
       ],
@@ -585,7 +636,7 @@ describe("--eval", () => {
     await mkdir(join(dir, "sources"), { recursive: true });
     await writeFile(join(dir, "sources", `${sha}.json`), JSON.stringify({ content }), "utf-8");
 
-    const { out, code } = await show(root, ["weather/brooklyn"], { eval: true });
+    const { out, code } = await show(root, ["weather/brooklyn"], { source: true });
     expect(code).toBe(0);
     expect(out).toContain(`eval source: evals/weather/brooklyn.eval.ts · sha256:${sha.slice(0, 8)}`);
     // 源码行的缩进是语义的一部分,渲染必须原样保留(不按词重排折叠掉这两个空格)。
@@ -599,7 +650,7 @@ describe("--eval", () => {
   it("源码行标注保留 group 与值断言的 expected/received", async () => {
     const root = await makeRoot();
     const dir = await writeSnapshot(root, "2026-07-08T10-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-08T10:00:00.000Z" }, [
-      res("manager", "failed", { assertions: [{ name: "equals(4)", severity: "gate", score: 0, passed: false, evidence: "1", group: "Issue 15193", loc: { file: "evals/manager.eval.ts", line: 1 } }] }),
+      res("manager", "failed", { assertions: [{ name: "equals(4)", severity: "gate", score: 0, outcome: "failed" as const, expected: "4", received: "1", groupPath: ["Issue 15193"], loc: { file: "evals/manager.eval.ts", line: 1 } }] }),
     ]);
     const attemptDir = join(dir, "manager/a0");
     const content = "t.check(actual, equals(expected));\n";
@@ -607,7 +658,7 @@ describe("--eval", () => {
     await writeFile(join(attemptDir, "sources.json"), JSON.stringify([{ path: "evals/manager.eval.ts", sha256: sha }]), "utf-8");
     await mkdir(join(dir, "sources"), { recursive: true });
     await writeFile(join(dir, "sources", `${sha}.json`), JSON.stringify({ content }), "utf-8");
-    const { out } = await show(root, ["manager"], { eval: true });
+    const { out } = await show(root, ["manager"], { source: true });
     expect(out).toContain("gate · Issue 15193 · equals(4) · expected 4 · received 1");
   });
 });
@@ -618,7 +669,7 @@ describe("show @<locator>", () => {
   it("默认页直接解释失败断言的 group、期望值、实际值和源码位置", async () => {
     const root = await makeRoot();
     await writeSnapshot(root, "2026-07-08T10-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-08T10:00:00.000Z" }, [
-      res("manager", "failed", { assertions: [{ name: "equals(4)", severity: "gate", score: 0, passed: false, evidence: "1", group: "Issue 15193", loc: { file: "evals/manager.eval.ts", line: 40, column: 11 } }] }),
+      res("manager", "failed", { assertions: [{ name: "equals(4)", severity: "gate", score: 0, outcome: "failed" as const, expected: "4", received: "1", groupPath: ["Issue 15193"], loc: { file: "evals/manager.eval.ts", line: 40, column: 11 } }] }),
     ]);
     const results = await openResults(root);
     const locator = results.experiments[0]!.latest.evals[0]!.attempts[0]!.locator!;
@@ -649,6 +700,41 @@ describe("show @<locator>", () => {
     expect(out).not.toContain("available:");
   });
 
+  it("errored attempt 首页展开结构化 error(phase/code/message/cause)与 diagnostics", async () => {
+    const root = await makeRoot();
+    await writeSnapshot(root, "2026-07-08T10-00-00-000Z", { experimentId: "compare/claude-e2b", startedAt: "2026-07-08T10:00:00.000Z" }, [
+      res("agent-029", "errored", {
+        error: {
+          code: "sandbox-rate-limit",
+          message: "E2B sandbox allocation failed after 5 attempts",
+          phase: "sandbox.create",
+          cause: { name: "RateLimitError", message: "too many concurrent sandboxes" },
+        },
+        diagnostics: [
+          { code: "teardown-failed", level: "warning", message: "container stop timed out", phase: "sandbox.teardown" },
+        ],
+      }),
+    ]);
+    const results = await openResults(root);
+    const locator = results.experiments[0]!.latest.evals[0]!.attempts[0]!.locator!;
+
+    const { out, code } = await show(root, [locator]);
+    expect(code).toBe(0);
+    expect(out).toContain(`${locator} · agent-029 · compare/claude-e2b · errored`);
+    // 结构化 error 块:phase 直接展示闭集点分名,code/message/cause 各一行(见 docs/feature/reports/show.md)
+    expect(out).toContain("error:");
+    expect(out).toContain("phase: sandbox.create");
+    expect(out).toContain("code: sandbox-rate-limit");
+    expect(out).toContain("message: E2B sandbox allocation failed after 5 attempts");
+    expect(out).toContain("cause: RateLimitError · too many concurrent sandboxes");
+    // attempt 级 diagnostics 块(与 verdict 独立)
+    expect(out).toContain("diagnostics:");
+    expect(out).toContain("warning · sandbox.teardown · teardown-failed");
+    expect(out).toContain("container stop timed out");
+    // errored 且无断言:不打印空的 assertions 汇总行
+    expect(out).not.toContain("assertions:");
+  });
+
   it("available 只逐行列出实际存在的证据命令,不打印能力字母或合并式 next", async () => {
     const root = await makeRoot();
     const dir = await writeSnapshot(root, "2026-07-08T10-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-08T10:00:00.000Z" }, [
@@ -666,7 +752,7 @@ describe("show @<locator>", () => {
 
     const { out, code } = await show(root, [locator]);
     expect(code).toBe(0);
-    expect(out).toContain(`available:\n  niceeval show ${locator} --eval\n  niceeval show ${locator} --execution`);
+    expect(out).toContain(`available:\n  niceeval show ${locator} --source\n  niceeval show ${locator} --execution`);
     expect(out).not.toContain(`niceeval show ${locator} --diff`);
     expect(out).not.toContain("evidence:");
     expect(out).not.toContain("next:");
@@ -688,6 +774,186 @@ describe("show @<locator>", () => {
     expect(out).not.toContain("available:");
   });
 
+  it("单独 --timing 进入完整时间树,不回落到 attempt 首页", async () => {
+    const root = await makeRoot();
+    await writeSnapshot(root, "2026-07-08T10-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-08T10:00:00.000Z" }, [
+      res("weather/brooklyn", "passed", {
+        durationMs: 50_000,
+        phases: [
+          { name: "eval.run", durationMs: 42_000 },
+          { name: "sandbox.stop", durationMs: 800 },
+        ],
+      }),
+    ]);
+    const results = await openResults(root);
+    const locator = results.experiments[0]!.latest.evals[0]!.attempts[0]!.locator!;
+
+    const { out, code } = await show(root, [locator], { timing: true });
+    expect(code).toBe(0);
+    expect(out).toContain("total 50.0s");
+    expect(out).toContain("eval.run              42.0s");
+    expect(out).toContain("teardown (not counted in total):");
+    expect(out).toContain("sandbox.stop          800ms");
+    expect(out).not.toContain("assertions:");
+    expect(out).not.toContain("available:");
+  });
+
+  it("--timing 在 80 个 detail node 内与 full 等价，81 个开始原位省略", async () => {
+    const root = await makeRoot();
+    const children: TimingNode[] = Array.from({ length: 81 }, (_, index) => ({
+      id: `command-${String(index).padStart(3, "0")}`,
+      kind: "command",
+      label: "tool",
+      startOffsetMs: index * 10,
+      durationMs: 81 - index,
+      command: { display: `tool --item=${index}` },
+    }));
+    await writeSnapshot(root, "2026-07-08T10-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-08T10:00:00.000Z" }, [
+      res("weather/brooklyn", "passed", {
+        durationMs: 50_000,
+        phases: [
+          { name: "sandbox.create", durationMs: 1_000 },
+          { name: "eval.run", durationMs: 42_000, children },
+          { name: "sandbox.stop", durationMs: 800 },
+        ],
+      }),
+    ]);
+    const results = await openResults(root);
+    const locator = results.experiments[0]!.latest.evals[0]!.attempts[0]!.locator!;
+
+    const bounded = await show(root, [locator], { timing: "summary" });
+    const full = await show(root, [locator], { timing: "full" });
+    expect(bounded.out).toContain("sandbox.create");
+    expect(bounded.out).toContain("eval.run");
+    expect(bounded.out).toContain("sandbox.stop");
+    expect(bounded.out).toMatch(/… 1 nodes omitted/);
+    expect(bounded.out).toContain(`niceeval show ${locator} --timing=full`);
+    expect(full.out).not.toContain("nodes omitted");
+    expect(full.out).toContain("tool --item=0");
+    expect(full.out).toContain("tool --item=80");
+
+    // 去掉第 81 个后，默认投影不再省略，detail 行与 full 完全一致。
+    children.pop();
+    const root80 = await makeRoot();
+    await writeSnapshot(root80, "2026-07-08T10-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-08T10:00:00.000Z" }, [
+      res("weather/brooklyn", "passed", {
+        durationMs: 50_000,
+        phases: [{ name: "eval.run", durationMs: 42_000, children }],
+      }),
+    ]);
+    const results80 = await openResults(root80);
+    const locator80 = results80.experiments[0]!.latest.evals[0]!.attempts[0]!.locator!;
+    const bounded80 = await show(root80, [locator80], { timing: "summary" });
+    const full80 = await show(root80, [locator80], { timing: "full" });
+    expect(bounded80.out).toBe(full80.out);
+  });
+
+  it("默认投影保留失败路径/慢点/首尾，omission 报失败数且不虚构 children 合计", async () => {
+    const root = await makeRoot();
+    const children: TimingNode[] = Array.from({ length: 120 }, (_, index) => ({
+      id: `node-${String(index).padStart(3, "0")}`,
+      kind: "provider",
+      label: `provider-step-${index}`,
+      startOffsetMs: index * 100,
+      durationMs: index === 60 ? 99_000 : index + 1,
+      ...(index === 55 ? { failed: true as const } : {}),
+    }));
+    await writeSnapshot(root, "2026-07-08T10-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-08T10:00:00.000Z" }, [
+      res("weather/brooklyn", "errored", {
+        durationMs: 120_000,
+        error: { code: "provider-failed", message: "boom", phase: "sandbox.create" },
+        phases: [{ name: "sandbox.create", durationMs: 120_000, failed: true, children }],
+      }),
+    ]);
+    const results = await openResults(root);
+    const locator = results.experiments[0]!.latest.evals[0]!.attempts[0]!.locator!;
+    const { out } = await show(root, [locator], { timing: "summary" });
+
+    expect(out).toContain("provider-step-0");
+    expect(out).toContain("provider-step-55");
+    expect(out).toContain("provider-step-60");
+    expect(out).toContain("provider-step-119");
+    expect(out).not.toContain("combined");
+  });
+
+  it("operation 使用 producer label；full 按 parentSpanId 展开唯一关联 OTel 树", async () => {
+    const root = await makeRoot();
+    const dir = await writeSnapshot(root, "2026-07-08T10-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-08T10:00:00.000Z" }, [
+      res("weather/brooklyn", "passed", {
+        durationMs: 50_000,
+        hasTrace: true,
+        phases: [{
+          name: "workspace.diff",
+          durationMs: 5_000,
+          children: [{
+            id: "operation-1",
+            kind: "operation",
+            label: "export workspace diff · 1 window · 3,302 files",
+            startOffsetMs: 100,
+            durationMs: 4_000,
+            children: [{
+              id: "turn-1",
+              kind: "turn",
+              label: "s1/t1",
+              startOffsetMs: 200,
+              durationMs: 3_000,
+              traceId: "trace-1",
+            }],
+          }],
+        }],
+      }),
+    ]);
+    const trace: TraceSpan[] = [
+      { traceId: "trace-1", spanId: "child", parentSpanId: "root", name: "chat", kind: "model", startMs: 1_100, endMs: 2_000 },
+      { traceId: "trace-1", spanId: "root", name: "codex.exec", kind: "agent", startMs: 1_000, endMs: 3_000 },
+    ];
+    await writeFile(join(dir, "weather/brooklyn/a0/trace.json"), JSON.stringify(trace), "utf-8");
+    const results = await openResults(root);
+    const locator = results.experiments[0]!.latest.evals[0]!.attempts[0]!.locator!;
+    const { out } = await show(root, [locator], { timing: "full" });
+
+    expect(out).toContain("operation · export workspace diff · 1 window · 3,302 files");
+    expect(out).toMatch(/agent · codex\.exec[\s\S]*model · chat/);
+    expect(out).not.toContain("git show ×");
+  });
+
+  it("attempt 首页 timing 只列大头,但保留变慢的 telemetry 阶段", async () => {
+    const root = await makeRoot();
+    const dir = await writeSnapshot(root, "2026-07-08T10-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-08T10:00:00.000Z" }, [
+      res("weather/brooklyn", "passed", {
+        durationMs: 100_000,
+        hasEvents: true,
+        phases: [
+          { name: "sandbox.queue", durationMs: 0 },
+          { name: "sandbox.create", durationMs: 3_000 },
+          { name: "workspace.baseline", durationMs: 310 },
+          { name: "telemetry.configure", durationMs: 358 },
+          { name: "eval.run", durationMs: 45_000 },
+          { name: "telemetry.collect", durationMs: 35_300 },
+          { name: "sandbox.stop", durationMs: 8_500 },
+        ],
+      }),
+    ]);
+    await writeFile(
+      join(dir, "weather/brooklyn/a0/events.json"),
+      JSON.stringify([{ type: "message", role: "assistant", text: "done" }]),
+      "utf-8",
+    );
+    const results = await openResults(root);
+    const locator = results.experiments[0]!.latest.evals[0]!.attempts[0]!.locator!;
+
+    const { out } = await show(root, [locator]);
+    const timingLine = out.split("\n").find((line) => line.startsWith("timing:"));
+    expect(out).toContain("1 AI message");
+    expect(timingLine).toContain("sandbox.queue 0ms");
+    expect(timingLine).toContain("sandbox.create 3.0s");
+    expect(timingLine).toContain("eval.run 45.0s");
+    expect(timingLine).toContain("telemetry.collect 35.3s");
+    expect(timingLine).toContain("teardown +8.5s");
+    expect(timingLine).not.toContain("workspace.baseline");
+    expect(timingLine).not.toContain("telemetry.configure");
+  });
+
   it("语法不对的 locator 报「not a valid attempt locator」,退出码 1,不崩", async () => {
     const root = await makeRoot();
     await writeSnapshot(root, "2026-07-08T10-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-08T10:00:00.000Z" }, [

package/src/tty-line.ts

@@ -1,32 +1,14 @@
-// 独立诊断行的统一终端出口。
+// 独立诊断行的 bootstrap 终端出口:只服务 run 启动前的 argv/config 错误,以及崩溃兜底/
+// 尚无活跃 coordinator 时的兜底(见 src/runner/feedback/sink.ts 的 no-active-coordinator 分支)。
 //
-// live 表格(src/runner/reporters/live.ts)重画靠 \x1B[{drawnLines}A 回跳到上一帧起点,
-// 这个回跳量的前提是"stderr/stdout 这块屏幕在两帧之间只有它自己在写"。sandbox teardown
-// 失败、budget 不可执行、reporter 抛错这类跟 attempt 进度无关的独立诊断行,如果在 live
-// 表格激活期间直接 process.stderr.write / console.log,就会插进两次 draw() 之间——下一帧
-// 按旧的 drawnLines 回跳,已经够不到表格真正的起点,清行重画变成往下多写一份,且这个偏移
-// 被记进新的 drawnLines,此后每帧都在错位的基础上继续错位,越滚越多(见
-// memory/live-raw-stderr-write-desyncs-redraw.md)。
-//
-// 所以任何不经过 Reporter.progress() / onEvalComplete() 的独立诊断行,写之前都要先广播
-// beforeExternalTerminalWrite(),live.ts 借此机会把已画内容清掉、drawnLines 归零,下一次
-// draw() 就会把这行诊断消息之下当成全新起点重画,不会累积。
-
-const listeners = new Set<() => void>();
-
-/** live.ts 用来订阅"即将有一行独立诊断消息落地"。返回取消订阅函数。 */
-export function onBeforeExternalTerminalWrite(fn: () => void): () => void {
-  listeners.add(fn);
-  return () => listeners.delete(fn);
-}
-
-/** 任何要绕开 Reporter 直接往终端打一行独立诊断消息的地方,写之前都先调用这个。 */
-export function beforeExternalTerminalWrite(): void {
-  for (const fn of listeners) fn();
-}
+// run 激活之后的全部反馈(dashboard、durable event、heartbeat)由
+// src/runner/feedback/coordinator.ts 统一排序;它通过 sink.ts 的模块级 coordinator 栈直接接管
+// reportXxx() 调用的目的地(显式路由,不是广播-订阅),所以这里不再需要"写之前先广播、订阅方
+// 自己清屏"的机制——那套机制是为已删除的 live.ts 的 ANSI 回跳重画设计的(见
+// memory/live-raw-stderr-write-desyncs-redraw.md),新 coordinator 的 clear → append → redraw
+// 顺序由 sink.ts 的显式路由保证,不依赖本文件。
 
 /** process.stderr.write 的替代:文本需自带换行(沿用现有 i18n 字符串的约定)。 */
 export function writeStderrLine(text: string): void {
-  beforeExternalTerminalWrite();
   process.stderr.write(text);
 }

package/src/util.test.ts

@@ -1,3 +1,4 @@
+// cases: docs/engineering/unit-tests/scoring/cases.md
 import { describe, expect, it } from "vitest";
 import { brief, formatThrown, upsertManagedBlock } from "./util.ts";