niceeval 0.6.0 → 0.6.2

package/src/show/render.ts

@@ -4,16 +4,17 @@
 // 全部纯函数(时间经 now 显式传入),证据数据由调用方 await 好了递进来。
 
 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 { AnnotatedSourceLine } from "../results/index.ts";
+import type { AssertionResult, DiffData, EvalResult, TimingNode, TraceSpan, Verdict } from "../types.ts";
+import type { AttemptEvidence, AttemptHandle, Snapshot } from "../results/index.ts";
+import type { AnnotatedSourceLine, SendAnnotation } from "../results/index.ts";
 import { groupIncompatibleVersionSkips } from "../results/index.ts";
 import type { SkippedDir } from "../results/index.ts";
 import type { ExecutionNode } from "../o11y/execution-tree.ts";
 import { foldEvalVerdict } from "../shared/verdict.ts";
+import { summaryText } from "../scoring/display.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 +46,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"}`;
 }
@@ -294,43 +129,97 @@ function scoreText(score: number): string {
   return formatPlainNumber(Math.round(score * 100) / 100);
 }
 
-/** 断言行:✓/✗ + severity + name;gate 失败带 detail,soft 恒带 score/1(失败再补 detail)。 */
+/** 分组路径标题(嵌套用 " > " 拼接);无分组返回 undefined。 */
+function groupTitle(a: AssertionResult): string | undefined {
+  return a.groupPath && a.groupPath.length > 0 ? a.groupPath.join(" > ") : undefined;
+}
+
+/** 断言行:✓/✗/◌ + severity + 标题;unavailable 带 reason,soft 恒带 score/1(失败再补 detail)。 */
 export function assertionLine(a: AssertionResult): string {
-  const scope = a.group ? `${a.group} · ` : "";
-  const head = `${a.passed ? "✓" : "✗"} ${a.severity} ${scope}${a.name}`;
+  const group = groupTitle(a);
+  const scope = group ? `${group} · ` : "";
+  const optional = a.optional ? "optional · " : "";
+  if (a.outcome === "unavailable") {
+    return `◌ ${a.severity} · ${optional}${scope}${a.name} — unavailable: ${a.reason}`;
+  }
+  const head = `${a.outcome === "passed" ? "✓" : "✗"} ${a.severity} ${optional}${scope}${a.name}`;
   if (a.severity === "soft") {
-    const detail = !a.passed && a.detail ? `: ${a.detail}` : "";
-    return `${head} — ${scoreText(a.score)}/1${detail}`;
+    const detail = a.outcome === "failed" && a.detail ? `: ${a.detail}` : "";
+    const threshold = a.threshold !== undefined ? ` / ${scoreText(a.threshold)}` : "/1";
+    return `${head} — ${scoreText(a.score)}${threshold}${detail}`;
   }
-  if (!a.passed) {
+  if (a.outcome === "failed") {
     const reason = a.detail ?? `score ${scoreText(a.score)}`;
-    return a.evidence !== undefined ? `${head} — ${reason} · actual: ${a.evidence}` : `${head} — ${reason}`;
+    const received = a.received ?? a.evidence;
+    // 单行面只放摘要收口后的预览;多行值(如 output tail)的完整版在 attempt 首页展开。
+    return received !== undefined ? `${head} — ${reason} · received: ${summaryText(received)}` : `${head} — ${reason}`;
   }
   return head;
 }
 
-function equalsExpected(name: string): string | undefined {
-  const match = /^equals\((.*)\)$/.exec(name);
-  return match?.[1];
+/** 字段行:首行 `<label>: <值首行>`,值的其余行(如 CommandResult 的 output tail)缩进原样展开。 */
+function fieldLines(label: string, value: string): string[] {
+  const [first, ...rest] = value.split("\n");
+  return [`    ${label}: ${first ?? ""}`, ...rest.map((line) => `      ${line}`)];
 }
 
-/** 默认 Attempt 页的首要诊断：不要求用户再猜一次 evidence flag 才知道为何失败。 */
-export function failureDiagnostics(assertions: AssertionResult[], width: number): string | undefined {
-  const failed = assertions.filter((a) => !a.passed);
-  if (failed.length === 0) return undefined;
-  const lines = ["failures:"];
-  for (const a of failed) {
-    const label = a.group ?? a.name;
-    lines.push(`  ${a.severity} · ${label}`);
-    if (a.group) lines.push(`    assertion: ${a.name}`);
-    const expected = equalsExpected(a.name);
-    if (expected !== undefined) lines.push(`    expected: ${expected}`);
-    if (a.evidence !== undefined) lines.push(`    received: ${a.evidence}`);
-    if (a.detail) lines.push(`    reason: ${a.detail}`);
-    if (a.loc) lines.push(`    source: ${a.loc.file}:${a.loc.line}${a.loc.column ? `:${a.loc.column}` : ""}`);
-    if (a.severity === "soft") lines.push(`    score: ${scoreText(a.score)}/1`);
+/** 每条的通用行组(见 docs/feature/scoring/library/display.md「通用渲染规则」):
+ *  首行 `severity · <标题>`(有分组时标题是分组路径,随后 assertion: 行给检查方式),
+ *  之后按有则显示的顺序列 expected / received / score / reason / source。 */
+function assertionRecordLines(a: AssertionResult): string[] {
+  const group = groupTitle(a);
+  const optional = a.optional ? "optional · " : "";
+  const title = group ?? a.name;
+  const lines: string[] = [];
+  const scoreSuffix =
+    a.outcome !== "unavailable" && (a.severity === "soft" || a.threshold !== undefined)
+      ? `   ${scoreText(a.score)}${a.threshold !== undefined ? ` / ${scoreText(a.threshold)}` : ""}`
+      : "";
+  lines.push(`  ${a.severity} · ${optional}${title}${scoreSuffix}`);
+  const detailLine = a.detail ?? (group ? a.name : undefined);
+  if (detailLine !== undefined && detailLine !== title) lines.push(`    assertion: ${detailLine}`);
+  if (a.outcome === "unavailable") {
+    lines.push(`    reason: ${a.reason}`);
+  } else {
+    if (a.expected !== undefined) lines.push(...fieldLines("expected", a.expected));
+    if (a.received !== undefined) lines.push(...fieldLines("received", a.received));
+    if (a.evidence !== undefined && a.evidence !== a.received) lines.push(...fieldLines("evidence", a.evidence));
   }
+  if (a.loc) lines.push(`    source: ${a.loc.file}:${a.loc.line}${a.loc.column ? `:${a.loc.column}` : ""}`);
+  return lines;
+}
+
+/**
+ * 默认 Attempt 页的首要诊断:按结果分节,只逐条列出需要看的(见 display.md)——
+ * `failures:`(gate 失败,含 --strict 下改判的 soft)、`soft below threshold:`、
+ * `scores:`(无阈值 judge 的纯打分)、`unavailable:`(证据评不了的,带 reason)。
+ * 全部通过时这些节整体省略(返回 undefined),只留计数行。
+ */
+export function failureDiagnostics(assertions: AssertionResult[], width: number, strict?: boolean): string | undefined {
+  const failures = assertions.filter(
+    (a) => a.outcome === "failed" && (a.severity === "gate" || strict),
+  );
+  const softBelow = assertions.filter(
+    (a) => a.outcome === "failed" && a.severity === "soft" && !strict,
+  );
+  const scores = assertions.filter(
+    (a) => a.outcome === "passed" && a.severity === "soft" && a.threshold === undefined && a.score < 1,
+  );
+  const unavailableOnes = assertions.filter((a) => a.outcome === "unavailable");
+  const lines: string[] = [];
+  const section = (title: string, items: AssertionResult[]) => {
+    if (items.length === 0) return;
+    if (lines.length > 0) lines.push("");
+    lines.push(title);
+    for (const a of items) lines.push(...assertionRecordLines(a));
+  };
+  section("failures:", failures);
+  section("soft below threshold:", softBelow);
+  section("scores:", scores);
+  section("unavailable:", unavailableOnes);
+  if (lines.length === 0) return undefined;
   return lines.flatMap((line) => {
+    if (line === "") return [line];
     const indent = line.length - line.trimStart().length;
     return wrapDisplay(line.trimStart(), Math.max(20, width - indent)).map((part) => `${" ".repeat(indent)}${part}`);
   }).join("\n");
@@ -353,7 +242,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 +251,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 断言,
@@ -401,22 +260,24 @@ export function cheapCapabilities(result: EvalResult): AttemptEvidenceCapabiliti
  * 依赖它的内部实现细节。
  */
 export function verdictReasonLine(result: EvalResult): string | undefined {
-  if (result.error !== undefined) return result.error;
+  if (result.error !== undefined) return result.error.message;
   if (result.skipReason !== undefined) return result.skipReason;
-  const gates = result.assertions.filter((a) => !a.passed && a.severity === "gate");
-  if (gates.length === 0) return undefined;
+  const gates = result.assertions.filter((a) => a.outcome === "failed" && a.severity === "gate");
+  if (gates.length === 0) {
+    const gap = result.assertions.find((a) => a.outcome === "unavailable" && !a.optional);
+    return gap && gap.outcome === "unavailable" ? `unavailable ${gap.name} (${gap.reason})` : 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("  ");
@@ -430,13 +291,15 @@ export function attemptIndexLine(opts: {
  * (未捕获源码),读 `result.assertions` 让这条摘要不因缺源码而跟着消失。
  */
 export function assertionSummaryLine(assertions: AssertionResult[]): string {
-  const passed = assertions.filter((a) => a.passed).length;
-  const gateFailed = assertions.filter((a) => !a.passed && a.severity === "gate").length;
-  const softBelow = assertions.filter((a) => !a.passed && a.severity === "soft").length;
+  const passed = assertions.filter((a) => a.outcome === "passed").length;
+  const gateFailed = assertions.filter((a) => a.outcome === "failed" && a.severity === "gate").length;
+  const softBelow = assertions.filter((a) => a.outcome === "failed" && a.severity === "soft").length;
+  const unavailableCount = assertions.filter((a) => a.outcome === "unavailable").length;
   const parts: string[] = [];
   if (passed > 0) parts.push(`${passed} passed`);
   if (gateFailed > 0) parts.push(`${gateFailed} gate failed`);
   if (softBelow > 0) parts.push(`${softBelow} soft below target`);
+  if (unavailableCount > 0) parts.push(`${unavailableCount} unavailable`);
   return `assertions: ${parts.length > 0 ? parts.join(" · ") : "(none)"}`;
 }
 
@@ -463,7 +326,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 +340,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,
@@ -498,7 +361,7 @@ export function evalDetailText(opts: EvalDetailOptions): string {
       lines.push(indentBlock(wrapDisplay(assertionLine(a), width - 2).join("\n"), "  "));
     }
     if (detail.result.error !== undefined) {
-      lines.push(indentBlock(wrapDisplay(`error: ${detail.result.error}`, width - 2).join("\n"), "  "));
+      lines.push(indentBlock(wrapDisplay(`error: ${detail.result.error.message}`, width - 2).join("\n"), "  "));
     }
     if (detail.result.skipReason !== undefined) {
       lines.push(indentBlock(wrapDisplay(`skipped: ${detail.result.skipReason}`, width - 2).join("\n"), "  "));
@@ -600,28 +463,51 @@ function indentedText(text: string, width: number, indent = 4, maxLines = 18): s
 
 const MAX_SOURCE_LINES = 400;
 
-/** gate 失败 / soft 恒带分——与 assertionLine 的严重度口径一致,但不带断言 name(源码行本身就是名字)。 */
+/** gate 失败 / soft 恒带分 / unavailable 带 reason——与 assertionLine 的口径一致,但不带断言
+ *  name(源码行本身就是名字)。 */
 function evalAssertionDetailLine(a: AssertionResult): string | undefined {
+  if (a.outcome === "unavailable") {
+    return `${a.severity} · unavailable · ${a.reason}`;
+  }
   if (a.severity === "soft") {
-    const detail = !a.passed && a.detail ? ` · ${a.detail}` : "";
-    return `soft · ${scoreText(a.score)}/1${detail}`;
+    const detail = a.outcome === "failed" && a.detail ? ` · ${a.detail}` : "";
+    const threshold = a.threshold !== undefined ? ` / ${scoreText(a.threshold)}` : "/1";
+    return `soft · ${scoreText(a.score)}${threshold}${detail}`;
   }
-  if (!a.passed) {
+  if (a.outcome === "failed") {
+    // 标注行是源码页里的一行事实,不是证据面:expected / received 过摘要收口
+    // (折单行 + 上限),完整值在 attempt 首页与 events.json / diff.json。
     const parts = ["gate"];
-    if (a.group) parts.push(a.group);
+    const group = groupTitle(a);
+    if (group) parts.push(group);
     parts.push(a.name);
-    const expected = equalsExpected(a.name);
-    if (expected !== undefined) parts.push(`expected ${expected}`);
-    if (a.evidence !== undefined) parts.push(`received ${a.evidence}`);
-    if (a.detail) parts.push(a.detail);
+    if (a.expected !== undefined) parts.push(`expected ${summaryText(a.expected)}`);
+    const received = a.received ?? a.evidence;
+    if (received !== undefined) parts.push(`received ${summaryText(received)}`);
+    if (a.detail) parts.push(summaryText(a.detail));
     return parts.join(" · ");
   }
   return undefined;
 }
 
+/** send 行标注:轮身份 · status · 墙钟(有记录才出现),契约见 show.md「--eval」。 */
+function sendAnnotationLine(send: SendAnnotation): string {
+  const parts = [send.label, send.status];
+  if (send.durationMs !== undefined) parts.push(formatDurationMs(send.durationMs));
+  return parts.join(" · ");
+}
+
 function evalSourceLineText(line: AnnotatedSourceLine, gutterWidth: number, width: number): string[] {
-  const anyFailed = line.assertions.some((a) => !a.passed);
-  const glyph = line.assertions.length === 0 ? " " : anyFailed ? "✗" : "✓";
+  const anyFailed = line.assertions.some((a) => a.outcome === "failed") ||
+    line.sends.some((send) => send.status === "failed");
+  const anyUnavailable = line.assertions.some((a) => a.outcome === "unavailable");
+  const glyph = line.assertions.length === 0 && line.sends.length === 0
+    ? " "
+    : anyFailed
+      ? "✗"
+      : anyUnavailable
+        ? "◌"
+        : "✓";
   const marginWidth = gutterWidth + 2; // 行号列 + glyph + 分隔空格
   const prefix = `${padDisplay(String(line.line), gutterWidth)}${glyph} `;
   // 源码行的空白(尤其是缩进)是语义的一部分:wrapDisplay 按单词重排会把连续空格
@@ -630,6 +516,11 @@ function evalSourceLineText(line: AnnotatedSourceLine, gutterWidth: number, widt
   // 折行只对续行加统一 margin,救不回已经被吃掉的原始缩进,不如老实截断。
   const out = [prefix + clip(line.text, Math.max(20, width - marginWidth))];
   const margin = " ".repeat(marginWidth);
+  for (const send of line.sends) {
+    for (const wrapped2 of wrapDisplay(sendAnnotationLine(send), Math.max(20, width - marginWidth))) {
+      out.push(margin + wrapped2);
+    }
+  }
   for (const a of line.assertions) {
     const detail = evalAssertionDetailLine(a);
     if (detail === undefined) continue;
@@ -670,8 +561,14 @@ export function evalSourceText(
     );
   }
 
-  blocks.push(assertionSummaryLine(evidence.result.assertions));
-  if (artifact) blocks.push(`full eval source: ${artifact}`);
+  const tail = [assertionSummaryLine(evidence.result.assertions)];
+  // 标注行的值是收口预览;有未通过断言时给「更进一步」——attempt 首页展开完整 expected /
+  // received(含 output tail),再往下是 result.json / events.json。
+  if (evidence.result.assertions.some((a) => a.outcome !== "passed")) {
+    tail.push(`full failure detail: niceeval show ${evidence.locator}`);
+  }
+  if (artifact) tail.push(`full eval source: ${artifact}`);
+  blocks.push(tail.join("\n"));
   return blocks.join("\n\n");
 }
 
@@ -786,10 +683,30 @@ export function executionText(
   const agentNodes = tree.nodes.filter((node) => node.kind !== "telemetry");
   const telemetryCount = tree.nodes.length - agentNodes.length;
   const shown = agentNodes.slice(0, MAX_EVENTS);
-  const lines = shown.flatMap((node, index) => [
-    ...(index === 0 ? [] : [""]),
-    ...executionNodeLines(node, originMs, timingAvailable, width),
-  ]);
+
+  // 按轮分段(见 docs/feature/reports/show.md「--execution」):每轮以 TURN 头行开始——身份
+  // s<session>/t<turn>(与 --timing 的 turn 节点、diff 的 windows 同一套标签,来自
+  // result.json.phases 的 turn 时间树)、该轮墙钟;边界按用户消息切(t.send 恒以用户消息开轮)。
+  const turnNodes = (evidence.result.phases ?? [])
+    .flatMap((p) => p.children ?? [])
+    .filter((n) => n.kind === "turn");
+  const lines: string[] = [];
+  let turnIndex = -1;
+  shown.forEach((node, index) => {
+    const isTurnStart = node.kind === "message" && node.role === "user";
+    if (isTurnStart) {
+      turnIndex += 1;
+      const turn = turnNodes[turnIndex];
+      const label = turn?.label ?? `t${turnIndex + 1}`;
+      const durationPart = turn ? ` · ${formatDurationMs(turn.durationMs)}` : "";
+      const failedPart = turn?.failed ? " · failed" : "";
+      if (index > 0) lines.push("");
+      lines.push(`TURN ${label}${failedPart || " · completed"}${durationPart}`);
+    } else if (index > 0) {
+      lines.push("");
+    }
+    lines.push(...executionNodeLines(node, originMs, timingAvailable, width).map((l) => (turnIndex >= 0 ? `  ${l}` : l)));
+  });
 
   const tail: string[] = [];
   if (timingAvailable) {
@@ -824,14 +741,38 @@ export function executionText(
 
 const MAX_OVERVIEW_DIFF_NAMES = 5;
 
+/** net 效果的单字母标记(A/M/D;none = 动过但净无变化,标 ±)。 */
+function netLetter(net: string): string {
+  switch (net) {
+    case "added":
+      return "A";
+    case "deleted":
+      return "D";
+    case "none":
+      return "±";
+    default:
+      return "M";
+  }
+}
+
 function overviewDiffLine(diff: DiffData): string {
-  const names = [
-    ...Object.keys(diff.generatedFiles).sort().map((p) => `M ${p}`),
-    ...[...diff.deletedFiles].sort().map((p) => `D ${p}`),
-  ];
+  const names = Object.entries(diff.files)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([p, f]) => `${netLetter(f.net)} ${p}`);
   const shown = names.slice(0, MAX_OVERVIEW_DIFF_NAMES);
   const more = names.length > shown.length ? ` · +${names.length - shown.length} more` : "";
-  return `changes: ${names.length} ${names.length === 1 ? "file" : "files"} changed · ${shown.join(", ")}${more}`;
+  return `changes: ${names.length} ${names.length === 1 ? "file" : "files"} changed by agent · ${shown.join(" · ")}${more}`;
+}
+
+/** 有界行 diff(公共前后缀修剪):对单区域编辑精确,复杂编辑给出上界近似。 */
+function lineDelta(before: string | undefined, after: string | undefined): { adds: number; dels: number } {
+  const a = before === undefined ? [] : before.split("\n");
+  const b = after === undefined ? [] : after.split("\n");
+  let prefix = 0;
+  while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix]) prefix++;
+  let suffix = 0;
+  while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]) suffix++;
+  return { adds: b.length - prefix - suffix, dels: a.length - prefix - suffix };
 }
 
 /**
@@ -839,6 +780,48 @@ function overviewDiffLine(diff: DiffData): string {
  * 执行事件计数、可选 OTel 时间指示、工作区 diff 摘要,不复现 `--eval` 的完整源码、
  * `--execution` 的完整事件流或 `--diff` 的完整文件列表(那些内容各自的证据 flag 才给)。
  */
+/** lifecycle operation → 首页可读标签:点换空格,与 docs/feature/reports/show.md 的
+ *  `phase: sandbox provision` 字面一致(不引入第二套本地化标签,show 首页用英文原样呈现)。 */
+function operationWords(operation: string): string {
+  return operation.replace(/\./g, " ");
+}
+
+/**
+ * errored attempt 的结构化 `error:` 块(见 docs/feature/reports/show.md「errored attempt 的首页」)。
+ * 先展开 phase(= operation 的可读形态)/ code / message / cause,stack 放在块后、保持原始换行。
+ * 字段来自结构化 `AttemptError`;非 errored(`r.error === undefined`)返回 undefined。
+ */
+function renderErrorBlock(r: EvalResult): string | undefined {
+  const err = r.error;
+  if (err === undefined) return undefined;
+  const lines = ["error:", `  phase: ${err.phase}`, `  code: ${err.code}`, `  message: ${err.message}`];
+  if (err.cause) {
+    const c = err.cause;
+    const causeText = c.name ? `${c.name} · ${c.message}` : c.message;
+    lines.push(`  cause: ${causeText}`);
+  }
+  // stack 放在 error 块之后、保持原始换行(见 docs);没有 stack(如 timeout / turn-failed)就不加空块。
+  if (err.stack && err.stack.trim() !== "") return `${lines.join("\n")}\n\n${err.stack.replace(/\n+$/, "")}`;
+  return lines.join("\n");
+}
+
+/**
+ * attempt 级诊断块(见 docs/feature/reports/show.md「diagnostics」)。每条一行标头
+ * `<level> · <operation> · <code>`,message 缩进在下一行;`count > 1` 时补 `(N occurrences)`。
+ * 诊断的 level 与 verdict 无关 —— passed / failed / errored 都可能带一条 cleanup / teardown
+ * warning。没有诊断返回 undefined。
+ */
+function renderAttemptDiagnostics(r: EvalResult): string | undefined {
+  if (!r.diagnostics || r.diagnostics.length === 0) return undefined;
+  const lines = ["diagnostics:"];
+  for (const d of r.diagnostics) {
+    lines.push(`  ${d.level} · ${d.phase} · ${d.code}`);
+    const occ = d.count && d.count > 1 ? ` (${d.count} occurrences)` : "";
+    lines.push(`    ${d.message}${occ}`);
+  }
+  return lines.join("\n");
+}
+
 export function attemptOverviewText(
   evidence: AttemptEvidence,
   opts: { header: string; artifactPath?: string; width: number },
@@ -853,27 +836,43 @@ export function attemptOverviewText(
 
   const blocks: string[] = [[header, metaParts.join(" · ")].join("\n")];
 
-  blocks.push(
-    [
-      assertionSummaryLine(r.assertions),
-      evidence.evalSource
-        ? `eval source: ${evidence.evalSource.sourcePath} · sha256:${evidence.evalSource.sourceSha256.slice(0, 8)}…`
-        : "eval source: unavailable (not captured for this attempt)",
-    ].join("\n"),
-  );
+  // errored attempt 的首页不靠 trace 就要能解释基础设施错误(见 docs/feature/reports/show.md
+  // 「errored attempt 的首页」):先展开结构化 error(phase/operation/code/message/cause + stack),
+  // 断言块对没有断言的 errored attempt 省略(它在评分之前就挂了)。
+  const errorBlock = renderErrorBlock(r);
+  if (errorBlock) blocks.push(errorBlock);
+
+  // errored 且没有任何断言时不打印空的 "assertions: 0 passed" —— 主因已经在 error 块里说清楚了。
+  if (r.assertions.length > 0 || r.error === undefined) {
+    blocks.push(
+      [
+        assertionSummaryLine(r.assertions),
+        evidence.evalSource
+          ? `eval source: ${evidence.evalSource.sourcePath} · sha256:${evidence.evalSource.sourceSha256.slice(0, 8)}…`
+          : "eval source: unavailable (not captured for this attempt)",
+      ].join("\n"),
+    );
+  }
 
   const diagnostics = failureDiagnostics(r.assertions, opts.width);
   if (diagnostics) blocks.push(diagnostics);
 
+  // attempt 级诊断(teardown/cleanup 等,与 verdict 独立;passed/failed/errored 都可能有)。
+  const attemptDiag = renderAttemptDiagnostics(r);
+  if (attemptDiag) blocks.push(attemptDiag);
+
   if (evidence.execution) {
     const nodes = evidence.execution.nodes.filter((node) => node.kind !== "telemetry");
     const skillLoads = nodes.filter((n) => n.kind === "skill.loaded").length;
     const toolCalls = nodes.filter((n) => n.kind === "action").length;
     const aiMessages = nodes.filter((n) => n.kind === "message" && n.role === "assistant").length;
-    const execLines = [`execution: ${nodes.length} events · ${skillLoads} skill loads · ${toolCalls} tool calls · ${aiMessages} AI messages`];
-    if (evidence.capabilities.timing) {
-      execLines.push("timing: OTel spans recorded for this attempt — see --execution for per-step timing.");
-    }
+    const counted = (count: number, singular: string, plural = `${singular}s`) =>
+      `${count} ${count === 1 ? singular : plural}`;
+    const execLines = [
+      `execution: ${counted(nodes.length, "event")} · ${counted(skillLoads, "skill load")} · ${counted(toolCalls, "tool call")} · ${counted(aiMessages, "AI message")}`,
+    ];
+    const timingLine = overviewTimingLine(r);
+    if (timingLine) execLines.push(timingLine);
     blocks.push(execLines.join("\n"));
   } else {
     blocks.push("execution: unavailable (no events recorded for this attempt)");
@@ -892,6 +891,7 @@ export function attemptOverviewText(
   const available = [
     evidence.capabilities.eval ? `niceeval show ${evidence.locator} --eval` : undefined,
     evidence.capabilities.execution ? `niceeval show ${evidence.locator} --execution` : undefined,
+    evidence.capabilities.timing ? `niceeval show ${evidence.locator} --timing` : undefined,
     evidence.capabilities.diff ? `niceeval show ${evidence.locator} --diff` : undefined,
   ].filter((command): command is string => command !== undefined);
   if (available.length > 0) tail.push(`available:\n${available.map((command) => `  ${command}`).join("\n")}`);
@@ -912,45 +912,363 @@ export function diffText(opts: {
   file?: string;
 }): string {
   const { header, diff, artifactPath, file } = opts;
-  const source = artifactPath ? join( artifactPath, "diff.json") : undefined;
+  const source = artifactPath ? join(artifactPath, "diff.json") : undefined;
   if (!diff) {
-    return `${header}\n\n(no diff recorded for this attempt${source ? ` · expected: ${source}` : ""})`;
+    return `${header}\n\ndiff unavailable (no diff recorded for this attempt: remote agent, or diff artifact not published${source ? `; expected: ${source}` : ""})`;
   }
 
   if (file !== undefined) {
-    const content = diff.generatedFiles[file];
-    if (content === undefined) {
-      if (diff.deletedFiles.includes(file)) return `${header}\n\nD ${file} (deleted by the agent)`;
-      const known = [...Object.keys(diff.generatedFiles), ...diff.deletedFiles];
-      return `${header}\n\nFile "${file}" is not in this attempt's diff. Files: ${known.join(", ") || "(none)"}`;
+    const summary = diff.files[file];
+    if (summary === undefined) {
+      const known = Object.keys(diff.files).sort();
+      return `${header}\n\nFile "${file}" is not in this attempt's agent diff. Files: ${known.join(", ") || "(none)"}`;
     }
-    const lines = content.split("\n");
-    const shown = lines.slice(0, MAX_DIFF_LINES);
-    const footer = [
-      `${lines.length} ${lines.length === 1 ? "line" : "lines"}`,
-      ...(lines.length > shown.length ? [`${lines.length - shown.length} more lines not shown`] : []),
-      ...(source ? [`full diff: ${source}`] : []),
-    ].join(" · ");
-    return `${header}\n\n${file}\n${shown.join("\n")}\n\n(${footer})`;
-  }
-
-  const generated = Object.entries(diff.generatedFiles).sort(([a], [b]) => a.localeCompare(b));
-  const deleted = [...diff.deletedFiles].sort();
-  if (generated.length === 0 && deleted.length === 0) {
-    return `${header}\n\n(no file changes recorded${source ? ` · full diff: ${source}` : ""})`;
-  }
-  // 落盘的 diff 只有改后全文(git name-status + readFile),没有基线:
-  // 行数是文件现大小,不硬编 +/- 增删行;A/M 无从区分,统一 M(created or modified)。
-  const rows = [
-    ...generated.map(([path, content]) => {
-      const lines = content.split("\n").length;
-      return ["M", path, `${lines} ${lines === 1 ? "line" : "lines"}`];
-    }),
-    ...deleted.map((path) => ["D", path, "(deleted)"]),
-  ];
-  const footer = [
-    `${rows.length} ${rows.length === 1 ? "file" : "files"}`,
-    ...(source ? [`full diff: ${source}`] : []),
-  ].join(" · ");
-  return `${header}\n\n${renderAlignedRows(rows)}\n\n(${footer})`;
+    // 单文件 patch 按窗口逐段渲染(diff.json 存的就是逐窗口 delta,不产出跨窗口合成 patch)。
+    const head = `${netLetter(summary.net)} ${file} · touched in ${summary.windows.join(", ")}`;
+    if (summary.binary) {
+      const sections = diff.windows
+        .filter((w) => w.changes[file] !== undefined)
+        .map((w) => {
+          const c = w.changes[file]!;
+          const b = c.binary ?? {};
+          return `── window ${w.window}\nbinary · ${b.beforeBytes ?? 0} → ${b.afterBytes ?? 0} bytes`;
+        });
+      return `${header}\n\n${head}\n\n${sections.join("\n\n")}`;
+    }
+    const sections: string[] = [];
+    for (const w of diff.windows) {
+      const c = w.changes[file];
+      if (c === undefined) continue;
+      sections.push(`── window ${w.window}\n${windowHunk(c)}`);
+    }
+    return `${header}\n\n${head}\n\n${sections.join("\n\n")}${source ? `\n\n(full diff: ${source})` : ""}`;
+  }
+
+  const entries = Object.entries(diff.files).sort(([a], [b]) => a.localeCompare(b));
+  if (entries.length === 0) {
+    return `${header}\n\n(no file changes by the agent in any send window${source ? ` · full diff: ${source}` : ""})`;
+  }
+  const rows = entries.map(([path, summary]) => {
+    if (summary.binary) {
+      return [netLetter(summary.net), path, "binary", summary.windows.join(", ")];
+    }
+    let adds = 0;
+    let dels = 0;
+    for (const w of diff.windows) {
+      const c = w.changes[path];
+      if (!c) continue;
+      const d = lineDelta(c.before, c.after);
+      adds += Math.max(0, d.adds);
+      dels += Math.max(0, d.dels);
+    }
+    const delta = [adds > 0 ? `+${adds}` : "", dels > 0 ? `-${dels}` : ""].filter(Boolean).join(" ") || "±0";
+    return [netLetter(summary.net), path, delta, summary.windows.join(", ")];
+  });
+  const headLine = `${entries.length} ${entries.length === 1 ? "file" : "files"} changed by agent`;
+  const single = entries[0] ? `\n\nsingle file: niceeval show @… --diff=${entries[0][0]}` : "";
+  return `${header}\n\n${headLine}\n${renderAlignedRows(rows).split("\n").map((l) => `  ${l}`).join("\n")}${single}`;
+}
+
+/** 一个窗口内单文件的最小 unified hunk:公共前后缀修剪出的编辑区,一段 @@ 展示。 */
+function windowHunk(c: { status: string; before?: string; after?: string }): string {
+  const a = c.before === undefined ? [] : c.before.replace(/\n$/, "").split("\n");
+  const b = c.after === undefined ? [] : c.after.replace(/\n$/, "").split("\n");
+  let prefix = 0;
+  while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix]) prefix++;
+  let suffix = 0;
+  while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]) suffix++;
+  const removed = a.slice(prefix, a.length - suffix);
+  const added = b.slice(prefix, b.length - suffix);
+  const ctxBefore = a.slice(Math.max(0, prefix - 2), prefix);
+  const lines: string[] = [];
+  lines.push(`@@ -${Math.max(1, prefix - ctxBefore.length + 1)},${removed.length + ctxBefore.length} +${Math.max(1, prefix - ctxBefore.length + 1)},${added.length + ctxBefore.length} @@`);
+  for (const l of ctxBefore) lines.push(` ${l}`);
+  const MAX_HUNK_LINES = 200;
+  const shownRemoved = removed.slice(0, MAX_HUNK_LINES);
+  const shownAdded = added.slice(0, MAX_HUNK_LINES);
+  for (const l of shownRemoved) lines.push(`-${l}`);
+  if (removed.length > shownRemoved.length) lines.push(`… (${removed.length - shownRemoved.length} more removed lines)`);
+  for (const l of shownAdded) lines.push(`+${l}`);
+  if (added.length > shownAdded.length) lines.push(`… (${added.length - shownAdded.length} more added lines)`);
+  return lines.join("\n");
+}
+
+// ───────────────────────── 证据切面:--timing(统一时间树) ─────────────────────────
+
+const CLOSING_PHASE_NAMES = new Set(["eval.teardown", "agent.teardown", "sandbox.teardown", "sandbox.suspend", "sandbox.stop"]);
+
+// 首页只保留能回答「大头在哪」的阶段。分类账锚点与 telemetry bookkeeping 在很短时
+// 留给 --timing 完整树；一旦自身变成慢点或失败，仍必须抬到首页，不能被静默藏掉。
+const OVERVIEW_DETAIL_PHASE_NAMES = new Set(["workspace.baseline", "telemetry.configure", "telemetry.collect"]);
+const OVERVIEW_DETAIL_THRESHOLD_MS = 1_000;
+
+/** phases 主链摘要行(首页 `timing:`):各主链阶段耗时点隔,收尾段合计以 `teardown +N` 单列。 */
+export function overviewTimingLine(r: EvalResult): string | undefined {
+  if (!r.phases || r.phases.length === 0) return undefined;
+  const main = r.phases.filter(
+    (p) =>
+      !CLOSING_PHASE_NAMES.has(p.name) &&
+      (p.failed === true || !OVERVIEW_DETAIL_PHASE_NAMES.has(p.name) || p.durationMs >= OVERVIEW_DETAIL_THRESHOLD_MS),
+  );
+  const closing = r.phases.filter((p) => CLOSING_PHASE_NAMES.has(p.name));
+  const parts = main.map((p) => `${p.name} ${formatDurationMs(p.durationMs)}${p.failed ? " ✗" : ""}`);
+  const closingMs = closing.reduce((sum, p) => sum + p.durationMs, 0);
+  if (closingMs > 0) parts.push(`teardown +${formatDurationMs(closingMs)}`);
+  return `timing: ${parts.join(" · ")}`;
+}
+
+const TIMING_DETAIL_NODE_BUDGET = 80;
+
+interface DiagnosticTimingNode {
+  id: string;
+  label: string;
+  startOffsetMs: number;
+  durationMs: number;
+  failed: boolean;
+  otel: boolean;
+  children: DiagnosticTimingNode[];
+}
+
+function timingNodeLabel(node: TimingNode): string {
+  if (node.kind === "command" && node.command) return `shell · ${node.command.display}`;
+  if (node.kind === "turn") return `turn ${node.label}`;
+  if (node.kind === "operation" || node.kind === "provider") return `${node.kind} · ${node.label}`;
+  return node.label;
+}
+
+function traceReferenceCounts(nodes: readonly TimingNode[], counts = new Map<string, number>()): Map<string, number> {
+  for (const node of nodes) {
+    if (node.kind === "turn" && node.traceId) counts.set(node.traceId, (counts.get(node.traceId) ?? 0) + 1);
+    traceReferenceCounts(node.children ?? [], counts);
+  }
+  return counts;
+}
+
+/** OTel 只按唯一 traceId 归属和 span parent 关系挂接；不按绝对墙钟猜跨进程顺序。 */
+function otelForest(traceId: string, spans: readonly TraceSpan[], turnStartOffsetMs: number): DiagnosticTimingNode[] {
+  const unique = new Map<string, TraceSpan>();
+  for (const span of spans) if (span.traceId === traceId && !unique.has(span.spanId)) unique.set(span.spanId, span);
+  const selected = [...unique.values()];
+  if (selected.length === 0) return [];
+  const traceOrigin = Math.min(...selected.map((span) => span.startMs));
+  const nodes = new Map<string, DiagnosticTimingNode>();
+  for (const span of selected) {
+    nodes.set(span.spanId, {
+      id: `otel:${span.traceId}:${span.spanId}`,
+      label: `${span.kind ?? "span"} · ${span.name}`,
+      startOffsetMs: turnStartOffsetMs + Math.max(0, span.startMs - traceOrigin),
+      durationMs: Math.max(0, span.endMs - span.startMs),
+      failed: span.status === "error",
+      otel: true,
+      children: [],
+    });
+  }
+  const roots: DiagnosticTimingNode[] = [];
+  for (const span of selected) {
+    const node = nodes.get(span.spanId)!;
+    const parent = span.parentSpanId && span.parentSpanId !== span.spanId ? nodes.get(span.parentSpanId) : undefined;
+    if (parent) parent.children.push(node);
+    else roots.push(node);
+  }
+  const sort = (items: DiagnosticTimingNode[]) => {
+    items.sort((a, b) => a.startOffsetMs - b.startOffsetMs || a.id.localeCompare(b.id));
+    for (const item of items) sort(item.children);
+  };
+  sort(roots);
+  return roots;
+}
+
+function diagnosticTimingNode(
+  node: TimingNode,
+  spans: readonly TraceSpan[],
+  uniqueTraceIds: ReadonlySet<string>,
+): DiagnosticTimingNode {
+  const children = (node.children ?? []).map((child) => diagnosticTimingNode(child, spans, uniqueTraceIds));
+  if (node.kind === "turn" && node.traceId && uniqueTraceIds.has(node.traceId)) {
+    children.push(...otelForest(node.traceId, spans, node.startOffsetMs));
+  }
+  return {
+    id: `runner:${node.id}`,
+    label: timingNodeLabel(node),
+    startOffsetMs: node.startOffsetMs,
+    durationMs: node.durationMs,
+    failed: node.failed === true,
+    otel: false,
+    children,
+  };
+}
+
+interface FlatTimingNode {
+  node: DiagnosticTimingNode;
+  path: readonly DiagnosticTimingNode[];
+}
+
+function flattenTimingForest(roots: readonly DiagnosticTimingNode[]): FlatTimingNode[] {
+  const flat: FlatTimingNode[] = [];
+  const visit = (node: DiagnosticTimingNode, ancestors: readonly DiagnosticTimingNode[]) => {
+    const path = [...ancestors, node];
+    flat.push({ node, path });
+    for (const child of node.children) visit(child, path);
+  };
+  for (const root of roots) visit(root, []);
+  return flat;
+}
+
+/**
+ * 默认 80-node 投影。四个稳定池先各用自己的配额，再把空余额按失败→最慢→首尾重分配。
+ * 选中深层节点必须连同祖先整条加入；四池合并后按 id 去重。
+ */
+function selectTimingNodes(roots: readonly DiagnosticTimingNode[]): ReadonlySet<string> {
+  const flat = flattenTimingForest(roots);
+  if (flat.length <= TIMING_DETAIL_NODE_BUDGET) return new Set(flat.map(({ node }) => node.id));
+
+  const selected = new Set<string>();
+  const byStart = [...flat].sort(
+    (a, b) => a.node.startOffsetMs - b.node.startOffsetMs || a.node.id.localeCompare(b.node.id),
+  );
+  const failed = byStart.filter(({ node }) => node.failed);
+  const slow = [...flat].sort(
+    (a, b) => b.node.durationMs - a.node.durationMs || a.node.startOffsetMs - b.node.startOffsetMs || a.node.id.localeCompare(b.node.id),
+  );
+  const latest = [...flat].sort(
+    (a, b) => b.node.startOffsetMs - a.node.startOffsetMs || a.node.id.localeCompare(b.node.id),
+  );
+
+  const add = (candidate: FlatTimingNode, allowance: number): number => {
+    const missing = candidate.path.filter((node) => !selected.has(node.id));
+    if (missing.length === 0 || missing.length > allowance || selected.size + missing.length > TIMING_DETAIL_NODE_BUDGET) {
+      return 0;
+    }
+    for (const node of missing) selected.add(node.id);
+    return missing.length;
+  };
+  const pool = (candidates: readonly FlatTimingNode[], cap: number) => {
+    let remaining = cap;
+    for (const candidate of candidates) {
+      if (remaining === 0) break;
+      remaining -= add(candidate, remaining);
+    }
+  };
+
+  pool(failed, 40);
+  pool(slow, 20);
+  pool(byStart, 10);
+  pool(latest, 10);
+
+  // 固定池未用满时，剩余额度按契约优先级继续分配；候选稳定、无法容纳的整条路径跳过。
+  for (const candidate of [...failed, ...slow, ...byStart, ...latest]) {
+    const remaining = TIMING_DETAIL_NODE_BUDGET - selected.size;
+    if (remaining === 0) break;
+    add(candidate, remaining);
+  }
+  return selected;
+}
+
+function subtreeStats(node: DiagnosticTimingNode): { nodes: number; failed: number } {
+  let nodes = 1;
+  let failed = node.failed ? 1 : 0;
+  for (const child of node.children) {
+    const stats = subtreeStats(child);
+    nodes += stats.nodes;
+    failed += stats.failed;
+  }
+  return { nodes, failed };
+}
+
+type VisibleTimingEntry =
+  | { kind: "node"; node: DiagnosticTimingNode }
+  | { kind: "omitted"; nodes: number; failed: number };
+
+function visibleTimingEntries(
+  nodes: readonly DiagnosticTimingNode[],
+  selected: ReadonlySet<string> | undefined,
+): VisibleTimingEntry[] {
+  if (!selected) return nodes.map((node) => ({ kind: "node", node }));
+  const entries: VisibleTimingEntry[] = [];
+  for (let i = 0; i < nodes.length;) {
+    const node = nodes[i]!;
+    if (selected.has(node.id)) {
+      entries.push({ kind: "node", node });
+      i += 1;
+      continue;
+    }
+    let omittedNodes = 0;
+    let omittedFailed = 0;
+    while (i < nodes.length && !selected.has(nodes[i]!.id)) {
+      const stats = subtreeStats(nodes[i]!);
+      omittedNodes += stats.nodes;
+      omittedFailed += stats.failed;
+      i += 1;
+    }
+    entries.push({ kind: "omitted", nodes: omittedNodes, failed: omittedFailed });
+  }
+  return entries;
+}
+
+function diagnosticTimingLines(
+  nodes: readonly DiagnosticTimingNode[],
+  prefix: string,
+  selected: ReadonlySet<string> | undefined,
+  locator: string,
+): string[] {
+  const entries = visibleTimingEntries(nodes, selected);
+  const lines: string[] = [];
+  entries.forEach((entry, index) => {
+    const last = index === entries.length - 1;
+    const branch = `${prefix}${last ? "└─ " : "├─ "}`;
+    const childPrefix = `${prefix}${last ? "   " : "│  "}`;
+    if (entry.kind === "omitted") {
+      const failed = entry.failed > 0 ? ` · ${entry.failed} failed` : "";
+      lines.push(`${branch}… ${entry.nodes} nodes omitted${failed} · full: niceeval show ${locator} --timing=full`);
+      return;
+    }
+    const node = entry.node;
+    lines.push(
+      `${branch}${node.label}   ${formatDurationMs(node.durationMs)}${node.failed ? " ✗" : ""}${node.otel ? "  OTel" : ""}`,
+    );
+    lines.push(...diagnosticTimingLines(node.children, childPrefix, selected, locator));
+  });
+  return lines;
+}
+
+/**
+ * `--timing`:整个 attempt 的统一时间树(见 docs/feature/reports/show.md)。先按
+ * `result.json.phases` 输出 runner 生命周期,再展开 hook / 命令 / turn;turn 带 traceId 时
+ * 从 trace.json 挂接 agent/model/tool spans。缩进表达包含关系,子项不能求和后与父项比较。
+ */
+export function timingText(
+  evidence: AttemptEvidence,
+  opts: { header: string; artifactPath?: string; width: number; mode?: "summary" | "full" },
+): string {
+  const r = evidence.result;
+  if (!r.phases || r.phases.length === 0) {
+    return `${opts.header}\n\nphase timing unavailable (this result was not produced by a runner with phase timing)`;
+  }
+  const spans = evidence.trace;
+  const main = r.phases.filter((p) => !CLOSING_PHASE_NAMES.has(p.name));
+  const closing = r.phases.filter((p) => CLOSING_PHASE_NAMES.has(p.name));
+  const traceCounts = new Map<string, number>();
+  for (const phase of r.phases) traceReferenceCounts(phase.children ?? [], traceCounts);
+  const uniqueTraceIds = new Set([...traceCounts].filter(([, count]) => count === 1).map(([traceId]) => traceId));
+  const phaseForests = new Map(
+    r.phases.map((phase) => [
+      phase,
+      (phase.children ?? []).map((node) => diagnosticTimingNode(node, spans ?? [], uniqueTraceIds)),
+    ]),
+  );
+  const allRoots = [...phaseForests.values()].flat();
+  const selected = opts.mode === "full" ? undefined : selectTimingNodes(allRoots);
+
+  const lines: string[] = [`total ${formatDurationMs(r.durationMs)}`, ""];
+  const renderPhase = (p: NonNullable<EvalResult["phases"]>[number]) => {
+    const failedNote = p.failed ? ` ✗ failed here${r.error ? ` (${r.error.code})` : ""}` : "";
+    lines.push(`${p.name.padEnd(22)}${formatDurationMs(p.durationMs)}${failedNote}`);
+    lines.push(...diagnosticTimingLines(phaseForests.get(p) ?? [], "  ", selected, evidence.locator));
+  };
+  for (const p of main) renderPhase(p);
+  if (closing.length > 0) {
+    lines.push("", "teardown (not counted in total):");
+    for (const p of closing) renderPhase(p);
+  }
+  return `${opts.header}\n\n${lines.join("\n")}`;
 }