niceeval 0.6.0 → 0.6.2

package/src/report/report.ts

@@ -44,10 +44,14 @@ export function defineReport(
   return { build, [REPORT_DEFINITION]: true };
 }
 
-/** 宿主装载报告文件时用:默认导出是不是 defineReport 的产物。 */
+/**
+ * 宿主装载报告文件时用:默认导出是不是 ReportDefinition。defineReport 的产物是普通对象;
+ * 「组件兼报告」(把 defineReport 产物 Object.assign 到双面组件上)是挂了 build 面的
+ * 可调用函数,同样算数——判据只看 build 面与标记,不看宿主形态。
+ */
 export function isReportDefinition(value: unknown): value is ReportDefinition {
   return (
-    typeof value === "object" &&
+    (typeof value === "object" || typeof value === "function") &&
     value !== null &&
     (value as Partial<ReportDefinition>)[REPORT_DEFINITION] === true &&
     typeof (value as Partial<ReportDefinition>).build === "function"

package/src/report/text/faces.ts

@@ -9,7 +9,6 @@ import type {
   AttemptListItem,
   DeltaData,
   EvalListItem,
-  ExperimentListEvalRow,
   ExperimentListItem,
   GroupSummaryData,
   LineData,
@@ -24,7 +23,7 @@ import type { TextContext } from "../tree.ts";
 import type { TableColumn, TableRow } from "../primitives.tsx";
 import {
   attemptItemReason,
-  capabilityBadge,
+  experimentDisplayName,
   formatDurationMs,
   formatMetricValue,
   formatPlainNumber,
@@ -32,7 +31,7 @@ import {
   verdictMark,
 } from "../format.ts";
 import { countText, localeText, resolveMetricLabel, type ReportLocale } from "../locale.ts";
-import { indentBlock, padDisplay, textBar, wrapDisplay } from "./layout.ts";
+import { indentBlock, padDisplay, stringWidth, textBar, wrapDisplay } from "./layout.ts";
 import { renderTableText } from "./table.ts";
 import { renderCharPlot, renderCoordinateTable, type PlotPoint } from "./plot.ts";
 
@@ -325,11 +324,6 @@ export function scatterText(data: ScatterData, ctx: TextContext): string {
   if (drawable.length === 0) {
     return [localeText(locale, "scatter.noData", axes), ...footnotes].join("\n");
   }
-  // 恰好 1 个可画点:成本 × 通过率的比较至少要两个实验,单点不成图。
-  if (drawable.length === 1) {
-    return [localeText(locale, "scatter.needTwo", axes), ...footnotes].join("\n");
-  }
-
   // 点太密排不下时降级为坐标表,不硬挤
   if (drawable.length > POINT_MARKS.length || ctx.width < 44) {
     const table = renderCoordinateTable(
@@ -451,51 +445,118 @@ export function deltaText(data: DeltaData, ctx: TextContext): string {
 
 // ───────────────────────── 实体列表(ExperimentList / EvalList / AttemptList)─────────────────────────
 //
-// 三面共用的紧凑标记:`locator✓[E,X,⏱]`(判定符紧跟 locator,证据能力方括号紧跟判定符,
-// 中间不留空格)——docs-site/zh/guides/report-components.mdx「终端输出形成反馈闭环」定的形态。
+// 三面共用的紧凑标记:`locator✓`(判定符紧跟 locator,中间不留空格)。
 // ExperimentList / EvalList 逐 attempt 只列这一个标记 + 各自的原因/耗时摘要,不重复整段
 // niceeval show 命令;要看某个 attempt 的完整证据,agent 自己拼 `niceeval show <locator>`——
-// 命令模板只在 AttemptList(叶子层)展示完整断言明细时才值得,不在中间层重复。
+// 比较列表都不内联完整断言或命令模板。
 
-function locatorBadge(item: { locator: string; verdict: AttemptListItem["verdict"]; capabilities: AttemptListItem["capabilities"] }): string {
-  return `${item.locator}${verdictMark(item.verdict)}${capabilityBadge(item.capabilities)}`;
+function locatorBadge(item: { locator: string; verdict: AttemptListItem["verdict"] }): string {
+  return `${item.locator}${verdictMark(item.verdict)}`;
 }
 
 // ── ExperimentList ──
 
-function experimentListEvalLine(row: ExperimentListEvalRow): string {
-  const badges = row.attempts.map(locatorBadge).join(" ");
-  const trailer =
-    row.verdict === "passed"
-      ? [formatDurationMs(row.duration.value ?? 0), row.cost.value === null ? undefined : formatUSD(row.cost.value)]
-          .filter((s): s is string => s !== undefined)
-          .join(" · ")
-      : (row.reason ?? "");
-  return `  ${verdictMark(row.verdict)} ${row.evalId}   ${badges}   ${trailer}`;
+function experimentSummaryTable(items: ExperimentListItem[], ctx: TextContext, relativeTo?: string): string {
+  const locale = ctx.locale;
+  const compact = ctx.width < 100;
+  const columns: TableColumn[] = [
+    { key: "experiment", header: compact && locale === "en" ? "Exp." : localeText(locale, "experimentList.experiment") },
+    { key: "model", header: localeText(locale, "table.model") },
+    { key: "agent", header: localeText(locale, "table.agent") },
+    { key: "duration", header: compact && locale === "en" ? "Avg" : localeText(locale, "experimentList.avgDuration"), align: "right" },
+    { key: "passRate", header: compact && locale === "en" ? "Pass" : localeText(locale, "experimentList.passRate"), align: "right" },
+    { key: "result", header: localeText(locale, "experimentList.result") },
+    { key: "tokens", header: localeText(locale, "experimentList.tokens"), align: "right" },
+    { key: "cost", header: compact && locale === "en" ? "Cost" : localeText(locale, "experimentList.estimatedCost"), align: "right" },
+  ];
+  const rows: TableRow[] = items.map((item) => ({
+    key: item.experimentId,
+    cells: {
+      experiment: experimentDisplayName(item.experimentId, relativeTo),
+      model: item.model ?? localeText(locale, "experimentList.defaultModel"),
+      agent: item.agent,
+      duration: cellText(item.duration),
+      passRate: cellText(item.passRate),
+      result: verdictTallyText(item.verdicts, locale),
+      tokens: cellText(item.tokens),
+      cost: cellText(item.cost),
+    },
+  }));
+  const metadata = items.flatMap((item) =>
+    wrapDisplay(
+      `${experimentDisplayName(item.experimentId, relativeTo)}: ${localeText(locale, "overview.evalsCount", { n: item.evals })} · ${localeText(locale, "overview.attemptsCount", { n: item.attempts })} · ${item.lastRunAt}`,
+      Math.max(8, ctx.width - 2),
+    ).map((line) => `  ${line}`),
+  );
+  return [renderTableText({ columns, rows, locale }, ctx), metadata.join("\n")].join("\n");
 }
 
-export function experimentListText(items: ExperimentListItem[], ctx: TextContext): string {
+function experimentDetailTable(item: ExperimentListItem, ctx: TextContext, relativeTo?: string): string {
   const locale = ctx.locale;
-  if (items.length === 0) return localeText(locale, "attemptList.empty");
-  const blocks = items.map((item) => {
-    const identity = item.model ? `${item.experimentId} · ${item.agent} · ${item.model}` : `${item.experimentId} · ${item.agent}`;
-    const summary = [
-      `${localeText(locale, "overview.passRate")} ${cellText(item.passRate)}`,
-      verdictTallyText(item.verdicts, locale),
-      localeText(locale, "overview.attemptsCount", { n: item.attempts }),
-      formatDurationMs(item.duration.value ?? 0),
-      item.cost.value === null ? missingText(locale) : formatUSD(item.cost.value),
-    ].join(" · ");
-    const evalLines = item.evalRows.map(experimentListEvalLine);
-    return [identity, `  ${summary}`, ...evalLines].join("\n");
+  const columns: TableColumn[] = [
+    { key: "status", header: localeText(locale, "experimentList.status") },
+    { key: "entity", header: localeText(locale, "experimentList.evalAttempt") },
+    // Result 是可扫读的失败预览,不是证据面:两行放不下的以 … 收口,完整值走 locator 下钻。
+    { key: "result", header: localeText(locale, "experimentList.result"), maxLines: 2 },
+    { key: "duration", header: localeText(locale, "experimentList.duration"), align: "right" },
+    { key: "cost", header: localeText(locale, "experimentList.cost"), align: "right" },
+  ];
+  // Result 的字符预算 ≈ 两行 × 它能分到的列宽(总宽减其它列的自然宽与列距)。这里只做
+  // 优先级让位(标题先截、received 最后截)的粗预算;精确的按宽度收口由列的 maxLines 兜底。
+  const statusWidth = Math.max(
+    stringWidth(localeText(locale, "experimentList.status")),
+    ...item.evalRows.map((row) => stringWidth(`${verdictMark(row.verdict)} ${localeText(locale, `verdict.${row.verdict}`)}`)),
+  );
+  const entityWidth = Math.max(
+    stringWidth(localeText(locale, "experimentList.evalAttempt")),
+    ...item.evalRows.flatMap((row) => [stringWidth(row.evalId), ...row.attempts.map((a) => stringWidth(a.locator) + 3)]),
+  );
+  const fixedWidth = statusWidth + entityWidth + 8 /* duration */ + 6 /* cost */ + 3 * 4; /* 4 段列距 */
+  const resultBudget = Math.max(24, (ctx.width - fixedWidth) * 2);
+  const rows: TableRow[] = item.evalRows.flatMap((row) => {
+    const parent: TableRow = {
+      key: row.evalId,
+      cells: {
+        status: `${verdictMark(row.verdict)} ${localeText(locale, `verdict.${row.verdict}`)}`,
+        entity: row.evalId,
+        result: "",
+        duration: localeText(locale, "entityList.average", { value: cellText(row.duration) }),
+        cost: localeText(locale, "entityList.average", { value: cellText(row.cost) }),
+      },
+    };
+    const attempts: TableRow[] = row.attempts.map((attempt, index) => ({
+      key: attempt.locator,
+      cells: {
+        status: `  ${verdictMark(attempt.verdict)}`,
+        entity: `${index === row.attempts.length - 1 ? "└─" : "├─"} ${attempt.locator}`,
+        result: attemptItemReason(attempt, resultBudget) ?? MISSING_MARK,
+        duration: attempt.verdict === "skipped" && attempt.durationMs === 0 ? null : formatDurationMs(attempt.durationMs),
+        cost: attempt.costUSD === undefined ? null : formatUSD(attempt.costUSD),
+      },
+    }));
+    return [parent, ...attempts];
   });
-  return blocks.join("\n\n");
+  const flags = item.flags && Object.keys(item.flags).length > 0
+    ? `${localeText(locale, "experimentList.flags")} ${Object.entries(item.flags).map(([key, value]) => `${key}=${String(value)}`).join(" · ")}`
+    : undefined;
+  return [experimentDisplayName(item.experimentId, relativeTo), flags, renderTableText({ columns, rows, locale }, ctx)]
+    .filter(Boolean)
+    .join("\n");
+}
+
+export function experimentListText(items: ExperimentListItem[], ctx: TextContext, relativeTo?: string): string {
+  if (items.length === 0) return localeText(ctx.locale, "attemptList.empty");
+  return [
+    experimentSummaryTable(items, ctx, relativeTo),
+    ...items.map((item) => experimentDetailTable(item, ctx, relativeTo)),
+  ].join("\n\n");
 }
 
 // ── EvalList ──
 
-function evalListAttemptLine(item: AttemptListItem): string {
-  const reason = attemptItemReason(item);
+function evalListAttemptLine(item: AttemptListItem, ctx: TextContext): string {
+  // 行式列表同守「Result 最多两行」:预算 = 两行终端宽,超出由 fit 投影按优先级让位。
+  const reason = attemptItemReason(item, Math.max(24, ctx.width * 2 - stringWidth(locatorBadge(item)) - 6));
   return `  ${locatorBadge(item)}${reason ? ` · ${reason}` : ""}`;
 }
 
@@ -507,10 +568,14 @@ export function evalListText(items: EvalListItem[], ctx: TextContext): string {
     const summary = [
       localeText(locale, "attemptList.score", { score: cellText(item.score) }),
       localeText(locale, "overview.attemptsCount", { n: item.attempts.length }),
-      `${formatDurationMs(item.duration.value ?? 0)} avg`,
-      item.cost.value === null ? `${missingText(locale)} avg` : `${formatUSD(item.cost.value)} avg`,
+      localeText(locale, "entityList.average", {
+        value: item.duration.value === null ? missingText(locale) : formatDurationMs(item.duration.value),
+      }),
+      localeText(locale, "entityList.average", {
+        value: item.cost.value === null ? missingText(locale) : formatUSD(item.cost.value),
+      }),
     ].join(" · ");
-    const attemptLines = item.attempts.map(evalListAttemptLine);
+    const attemptLines = item.attempts.map((attempt) => evalListAttemptLine(attempt, ctx));
     return [identity, `  ${summary}`, ...attemptLines].join("\n");
   });
   return blocks.join("\n\n");
@@ -518,46 +583,25 @@ export function evalListText(items: EvalListItem[], ctx: TextContext): string {
 
 // ── AttemptList ──
 
-/** 一个 AttemptListItem 的完整 text 卡片:判定符 + locator + 身份 + 耗时/成本 + 证据能力,
- * 然后逐条断言(gate 与 soft 都列,与 web 面的 AttemptRow 同一份材料)。 */
-function attemptListItemText(item: AttemptListItem, ctx: TextContext, locale: ReportLocale): string {
+/** Attempt 比较卡片：只显示一条主失败摘要（至多两行终端宽）；完整 assertions 走 locator 下钻。 */
+function attemptListItemText(item: AttemptListItem, ctx: TextContext): string {
   const head = [
     `${verdictMark(item.verdict)} ${item.locator}`,
     item.evalId,
     item.experimentId,
     formatDurationMs(item.durationMs),
     ...(item.costUSD !== undefined ? [formatUSD(item.costUSD)] : []),
-    ...(capabilityBadge(item.capabilities) ? [capabilityBadge(item.capabilities)] : []),
   ].join(" · ");
   const lines = [head];
-  if (item.error) {
-    lines.push(indentBlock(wrapDisplay(item.error, ctx.width - 4).join("\n"), "    "));
-  }
-  for (const assertion of item.assertions) {
-    const scoreText =
-      assertion.threshold !== undefined
-        ? `${formatPlainNumber(assertion.score)}/${formatPlainNumber(assertion.threshold)}`
-        : formatPlainNumber(assertion.score);
-    lines.push(
-      `  ${assertion.severity} ${assertion.name} · ${localeText(locale, `verdict.${assertion.passed ? "passed" : "failed"}`)}${assertion.severity === "soft" ? ` ${scoreText}` : ""}`,
-    );
-    if (assertion.detail) lines.push(indentBlock(wrapDisplay(assertion.detail, ctx.width - 4).join("\n"), "    "));
-    if (assertion.evidence) {
-      const limit = Math.max(240, ctx.width * 5);
-      const evidence =
-        assertion.evidence.length <= limit
-          ? assertion.evidence
-          : `${assertion.evidence.slice(0, limit)}… (${assertion.evidence.length - limit} more chars; open ${item.locator} for full evidence)`;
-      lines.push(indentBlock(wrapDisplay(evidence, ctx.width - 6).join("\n"), "      "));
-    }
-  }
+  const reason = attemptItemReason(item, Math.max(24, ctx.width * 2 - 4));
+  if (reason) lines.push(`  ${reason}`);
   return lines.join("\n");
 }
 
 export function attemptListText(items: AttemptListItem[], total: number | undefined, ctx: TextContext): string {
   const locale = ctx.locale;
   if (items.length === 0) return localeText(locale, "attemptList.empty");
-  const blocks = items.map((item) => attemptListItemText(item, ctx, locale));
+  const blocks = items.map((item) => attemptListItemText(item, ctx));
   const remaining = (total ?? items.length) - items.length;
   if (remaining > 0) blocks.push(localeText(locale, "attemptList.truncatedText", { n: remaining }));
   return blocks.join("\n\n");

package/src/report/text/table.ts

@@ -9,7 +9,7 @@
 import type { TableProps, TableRow } from "../primitives.tsx";
 import type { TextContext } from "../tree.ts";
 import { countText, localeText } from "../locale.ts";
-import { renderAlignedRows, stringWidth, wrapDisplay, type ColumnAlign } from "./layout.ts";
+import { charDisplayWidth, renderAlignedRows, stringWidth, wrapDisplay, type ColumnAlign } from "./layout.ts";
 
 const MISSING_MARK = "—";
 /** 列间距,与 renderAlignedRows 的 join("   ") 一致。 */
@@ -56,12 +56,43 @@ function fitWidths(
   return { widths, hidden };
 }
 
-/** 逻辑行 → 物理行:每格折到自己的列宽,行高取最高的那格,矮格补空串。 */
-function toPhysicalRows(cells: readonly string[], widths: readonly number[]): string[][] {
+/** 按显示宽度截到 width(不够放 `…` 时原样返回)。 */
+function truncateDisplay(text: string, width: number): string {
+  if (stringWidth(text) <= width) return text;
+  let out = "";
+  let used = 0;
+  for (const ch of text) {
+    const w = charDisplayWidth(ch.codePointAt(0)!);
+    if (used + w > width) break;
+    out += ch;
+    used += w;
+  }
+  return out;
+}
+
+/** 列的 maxLines 收口:超出的行丢弃,最后一行以 `…` 如实标注被收口。 */
+function clampCellLines(lines: string[], maxLines: number | undefined, width: number): string[] {
+  if (maxLines === undefined || lines.length <= maxLines) return lines;
+  const kept = lines.slice(0, Math.max(1, maxLines));
+  const last = kept[kept.length - 1]!;
+  kept[kept.length - 1] = `${truncateDisplay(last, Math.max(1, width - 1))}…`;
+  return kept;
+}
+
+/** 逻辑行 → 物理行:每格折到自己的列宽,列带 maxLines 就收口,行高取最高的那格,矮格补空串。 */
+function toPhysicalRows(
+  cells: readonly string[],
+  widths: readonly number[],
+  maxLines: readonly (number | undefined)[],
+): string[][] {
   const wrapped = cells.map((cell, c) =>
     // 放得下就原样保留:wrapDisplay 会把连续空格折成一个,而 DeltaTable 的
     // "50% → 62%   +12pp" 这类格子内含固定间距 —— 不折行时一个字节都不能动。
-    !cell.includes("\n") && stringWidth(cell) <= widths[c] ? [cell] : wrapDisplay(cell, widths[c]),
+    clampCellLines(
+      !cell.includes("\n") && stringWidth(cell) <= widths[c] ? [cell] : wrapDisplay(cell, widths[c]),
+      maxLines[c],
+      widths[c]!,
+    ),
   );
   const height = Math.max(...wrapped.map((lines) => lines.length), 1);
   const out: string[][] = [];
@@ -92,7 +123,13 @@ export function renderTableText(props: TableProps, ctx: TextContext): string {
   const natural = header.map((_, c) => Math.max(...matrix.map((row) => stringWidth(row[c] ?? ""))));
   const { widths, hidden } = fitWidths(natural, align, ctx.width);
 
-  const physical = matrix.flatMap((row) => toPhysicalRows(row.slice(0, widths.length), widths));
+  const maxLines: (number | undefined)[] = props.columns.map((column) => column.maxLines);
+  if (hasLocator) maxLines.push(undefined);
+  // 表头不参与 maxLines 收口:表头是自己写的短词,收口只服务数据格。
+  const physical = [
+    ...toPhysicalRows(header.slice(0, widths.length), widths, widths.map(() => undefined)),
+    ...body.flatMap((row) => toPhysicalRows(row.slice(0, widths.length), widths, maxLines)),
+  ];
   const table = renderAlignedRows(physical, align);
   return hidden > 0 ? `${table}\n${countText(locale, "table.columnsHidden", hidden)}` : table;
 }

package/src/report/types.ts

@@ -4,12 +4,11 @@
 
 import type { AttemptHandle, SelectionWarning } from "../results/types.ts";
 import type { AttemptLocator } from "../results/locator.ts";
-import type { AttemptEvidenceCapabilities } from "../results/attempt-evidence.ts";
-import type { AssertionResult, Verdict } from "../types.ts";
+import type { AssertionResult, AttemptError, DiagnosticRecord, Verdict } from "../types.ts";
 import type { LocalizedLabel, ReportLocale } from "./locale.ts";
 
 export type { SelectionWarning };
-export type { AttemptLocator, AttemptEvidenceCapabilities };
+export type { AttemptLocator };
 export type { LocalizedLabel, ReportLocale };
 
 // ───────────────────────── 指标与聚合 ─────────────────────────
@@ -32,7 +31,7 @@ export interface MetricAggregate {
  * 指标:纯函数,吃一个 AttemptHandle 吐一个值(null = 此 attempt 测不了这个指标,
  * 不进聚合;0 = 测了结果是零,照常进),外加名字、两级聚合方式和渲染提示。
  * 内置指标与自定义指标是同一个类型,没有特权。name 走字面量泛型:列键锚在指标
- * 对象上(`row.cells[passRate.name]`),拼错列名编译不过。
+ * 对象上(`row.cells[taskPassRate.name]`),拼错列名编译不过。
  */
 export interface Metric<Name extends string = string> {
   /** MetricColumn.key 与列头的来源;同一次计算里重名是错误。 */
@@ -87,8 +86,24 @@ export interface FlagRef {
   readonly unit?: string;
 }
 
-/** 维度槽的输入:内置/自定义维度,或 experiment 声明的 flag。 */
-export type DimensionInput = Dimension | FlagRef;
+/**
+ * config() 的产物:把顶层运行配置(快照 `ExperimentRunInfo` 投影的字段全集,外加桥接到
+ * 快照顶层权威字段的 `model` / `agent` 两个键)当维度或轴,槽位用法与 {@link FlagRef} 一致。
+ * 未投影的值不猜:分组如实归「(unset)」,作轴不画点、注脚报数。
+ */
+export interface ConfigRef {
+  readonly kind: "config";
+  readonly name: string;
+  /** 组标签 / 轴标签;函数形态把投影值折成组名。 */
+  readonly label?: string | ((value: string | number | boolean) => string);
+  readonly unit?: string;
+}
+
+/** MetricLine 的 x 轴输入:experiment 声明的 flag,或顶层运行配置(config())。 */
+export type AxisInput = FlagRef | ConfigRef;
+
+/** 维度槽的输入:内置/自定义维度、experiment 声明的 flag,或顶层运行配置(config())。 */
+export type DimensionInput = Dimension | FlagRef | ConfigRef;
 
 // ───────────────────────── 计算产物(组件 data props)─────────────────────────
 
@@ -266,7 +281,7 @@ export interface GroupSummaryData {
   /**
    * 组的通过率:eval 级折叠计票的 `passed / (passed + failed + errored)`(`skipped` 不进
    * 分母)——这是旧 `GroupSelector` 卡片的口径,不是 `OverviewData.totals.passRate` 那种
-   * `computeCell` 两级聚合(两者服务不同问题:「这组题多少算过」vs「整体质量几分」)。
+   * `computeCell` 两级聚合(两者服务不同问题:「这组题多少算过」vs「每次运行成功多少」)。
    * 分母为 0(组内没有任何已跑的 eval)时 `value` 为 `null`,不编 0%。
    */
   passRate: MetricCell;
@@ -290,10 +305,11 @@ export interface OverviewData {
     errored: number;
     skipped: number;
     /**
-     * 通过率的唯一官方口径:`computeCell(passRate, items)`,与 `MetricTable.data(...,
-     * columns: [passRate])` 同一台两级聚合引擎(题内折叠 perEval、跨题折叠 across,默认都是
+     * 默认成功率的唯一官方口径:`computeCell(endToEndPassRate, items)`,与 `MetricTable.data(...,
+     * columns: [endToEndPassRate])` 同一台两级聚合引擎(题内折叠 perEval、跨题折叠 across,默认都是
      * mean)——一道题内多个 attempt 部分通过,贡献的是小数份额而不是二元票。`samples`/`total`
-     * 是两级聚合口径下的 attempt 计数(`total` 含 skipped,`samples` 不含),不等于上面四个
+     * 是两级聚合口径下的 attempt 计数(`total` 含 skipped 与 errored——endToEndPassRate 对
+     * errored 记 0、只对 skipped 记 null,`samples` 因此只不含 skipped),不等于上面四个
      * verdict 计票的任何一个之和。
      */
     passRate: MetricCell;
@@ -336,10 +352,11 @@ export interface DeltaData<K extends string = string> {
 // `EvalListItem.attempts` 的元素,报告作者可以直接把这些嵌套数组喂给 `<AttemptList items={...} />`。
 
 /**
- * `AttemptList` 一项 = 一个 Attempt:身份、判定、断言、error、耗时、成本、locator,外加
- * 证据能力标记(有没有保存的 Eval 源码 / 执行事件 / OTel 计时 / diff——与 `AttemptEvidence.capabilities`
- * 同一个类型,不重新发明四个布尔位的含义)。`ExperimentList` / `EvalList` 的下钻数组复用同一个
- * 类型,不是各自的精简版。
+ * `AttemptList` 一项 = 一个 Attempt:身份、判定、断言、结构化 error、diagnostics、耗时、
+ * 成本和 locator。`ExperimentList` / `EvalList` 的下钻数组复用同一个类型,不是各自的精简版。
+ * 渲染面只显示一条主失败断言摘要或 error 的一层摘要；完整 assertions、cause / stack 与
+ * diagnostics 属于 locator 下钻详情,不塞进比较列表,但随数据携带 —— `AttemptList.data` 的 `redact`
+ * 钩子覆盖它们的自由文本(见 docs/feature/reports/library.md「AttemptList」)。
  */
 export interface AttemptListItem {
   evalId: string;
@@ -347,33 +364,25 @@ export interface AttemptListItem {
   attempt: number;
   agent: string;
   verdict: Verdict;
-  error?: string;
+  /** 结构化执行错误(与 `EvalResult.error` 同构):列表只显示 `message` 一层摘要。 */
+  error?: AttemptError;
+  /** 本 attempt 的有界诊断(teardown / cleanup 失败等,与 verdict 独立);属于下钻详情。 */
+  diagnostics?: DiagnosticRecord[];
   assertions: AssertionResult[];
   durationMs: number;
   costUSD?: number;
   locator: AttemptLocator;
-  /**
-   * 证据能力标记:`eval`(运行时 Eval 源码已保存)、`execution`(执行事件非空)、
-   * `timing`(执行事件 + 这次运行接入过 OTel)、`diff`(工作区有文件改动)。逐位定义与
-   * `AttemptEvidence.capabilities` 完全一致——这里复用同一个类型,不重复声明四个布尔位的门槛。
-   * 计算函数从 `EvalResult` 上已有的 `hasEvents` / `hasSources` / `hasTrace` 摘要位与一次
-   * `attempt.diff()` 懒加载算出,不对每个 item 调用完整的 `loadAttemptEvidence`
-   * (那还会额外装配 Eval 源码标注与 ExecutionTree,这里只要四个布尔位)。
-   */
-  capabilities: AttemptEvidenceCapabilities;
 }
 
 /**
- * `ExperimentList` 一项里,一个 Eval 的展开行:折叠判定(`foldEvalVerdict`)、失败原因摘要
- * (`error` → `skipReason` → 未通过的 gate 断言,`reasonFor` 的口径,soft 断言永不进入)、
- * 该 Eval 内 attempt 的平均耗时/成本(两级聚合引擎在单一 eval 上退化成组内均值),以及这道题
- * 的全部 Attempt(升序,供进一步展开到 `AttemptList`)。
+ * `ExperimentList` 一项里,一个 Eval 的展开行:折叠判定(`foldEvalVerdict`)、该 Eval 内
+ * attempt 的平均耗时/成本(两级聚合引擎在单一 eval 上退化成组内均值),以及这道题的全部
+ * Attempt(升序,供进一步展开到 `AttemptList`)。失败原因属于各 Attempt,不在父行挑一轮重复。
  */
 export interface ExperimentListEvalRow {
   evalId: string;
   /** 折叠判定(任一 attempt 通过则通过,否则取最严重的)。 */
   verdict: Verdict;
-  reason?: string;
   /** 这道题内 attempt 的平均耗时(`computeCell(durationMs, …)`,单一 eval 分组下即均值)。 */
   duration: MetricCell;
   /** 这道题内 attempt 的平均成本。 */
@@ -385,7 +394,7 @@ export interface ExperimentListEvalRow {
 /**
  * `ExperimentList.data(selection)` 的一项 = 一个 experiment:身份(experimentId/agent/model)、
  * 声明的 flags、Eval 判定构成(`foldEvalVerdict` 计票,与 view 榜单同一口径)、官方两级聚合
- * 汇总指标(passRate/cost/duration/tokens,直接来自 `computeCell`,不现场重算),以及展开到
+ * 汇总指标(endToEndPassRate/cost/duration/tokens,直接来自 `computeCell`,不现场重算),以及展开到
  * 这个 experiment 每道 Eval 的 `evalRows`(按 eval id 升序)。
  */
 export interface ExperimentListItem {
@@ -395,7 +404,7 @@ export interface ExperimentListItem {
   flags?: Record<string, unknown>;
   /** eval 级折叠计票(foldEvalVerdict 口径,与 `TableRowMeta.verdicts`、view 榜单同一套)。 */
   verdicts: { passed: number; failed: number; errored: number; skipped: number };
-  /** 官方两级聚合口径,与 `MetricTable.data(..., columns: [passRate])` 同一台引擎。 */
+  /** 官方两级聚合口径(endToEndPassRate),与 `MetricTable.data(..., columns: [endToEndPassRate])` 同一台引擎。 */
   passRate: MetricCell;
   cost: MetricCell;
   duration: MetricCell;
@@ -413,14 +422,13 @@ export interface ExperimentListItem {
 /**
  * `EvalList.data(selection)` 的一项 = 一个 `experimentId + evalId`(同一个 Eval 跑在两个
  * experiment 上是两条不同结果,不合并)。判定、分数(examScore 的两级聚合)、这道题内 attempt
- * 的平均耗时/成本,失败原因摘要(与 `ExperimentListEvalRow.reason` 同一口径),外加展开到这道题
- * 全部 Attempt 的 `attempts`(按 attempt 序号升序)。
+ * 的平均耗时/成本,外加展开到这道题全部 Attempt 的 `attempts`(按 attempt 序号升序)。失败
+ * 原因只存在于各 `AttemptListItem` 的 error / assertions,不会在 Eval 父项重复一份。
  */
 export interface EvalListItem {
   evalId: string;
   experimentId: string;
   verdict: Verdict;
-  reason?: string;
   /** examScore 的两级聚合;单一 eval 分组下即这道题的题级分数。 */
   score: MetricCell;
   duration: MetricCell;

package/src/results/annotated-source.test.ts

@@ -1,10 +1,11 @@
+// cases: docs/engineering/unit-tests/results/cases.md
 // buildAnnotatedEvalSource 的单测(定稿见 docs/concepts.md「标注 Eval 源码」)。
 // 覆盖:同一行多条断言、无 loc 断言进 unmapped、loc 指向别的文件/越界行也进 unmapped
 // (never silently dropped 的边界情况)、空断言数组、summary 计数、哈希与归一化行为。
 
 import { describe, expect, it } from "vitest";
-import type { AssertionResult } from "../types.ts";
-import { buildAnnotatedEvalSource } from "./annotated-source.ts";
+import type { AssertionResult, PhaseTiming, StreamEvent } from "../types.ts";
+import { buildAnnotatedEvalSource, deriveSendAnnotations, type SendAnnotation } from "./annotated-source.ts";
 import { hashEvalSource, normalizeEvalSource } from "./source-hash.ts";
 
 const SOURCE_PATH = "evals/weather.eval.ts";
@@ -13,9 +14,9 @@ function assertion(over: Partial<AssertionResult> & Pick<AssertionResult, "name"
   return {
     severity: "soft",
     score: 1,
-    passed: true,
+    outcome: "passed" as const,
     ...over,
-  };
+  } as AssertionResult;
 }
 
 describe("buildAnnotatedEvalSource", () => {
@@ -94,10 +95,10 @@ describe("buildAnnotatedEvalSource", () => {
   it("computes summary counts across passed/failed and gate/soft, mapped and unmapped alike", () => {
     const content = "line 1\nline 2\n";
     const assertions = [
-      assertion({ name: "a", severity: "gate", passed: true, loc: { file: SOURCE_PATH, line: 1 } }),
-      assertion({ name: "b", severity: "gate", passed: false, loc: { file: SOURCE_PATH, line: 1 } }),
-      assertion({ name: "c", severity: "soft", passed: true, loc: { file: SOURCE_PATH, line: 2 } }),
-      assertion({ name: "d", severity: "soft", passed: false }), // unmapped
+      assertion({ name: "a", severity: "gate", outcome: "passed" as const, loc: { file: SOURCE_PATH, line: 1 } }),
+      assertion({ name: "b", severity: "gate", outcome: "failed" as const, loc: { file: SOURCE_PATH, line: 1 } }),
+      assertion({ name: "c", severity: "soft", outcome: "passed" as const, loc: { file: SOURCE_PATH, line: 2 } }),
+      assertion({ name: "d", severity: "soft", outcome: "failed" as const }), // unmapped
     ];
 
     const model = buildAnnotatedEvalSource({ path: SOURCE_PATH, content }, assertions);
@@ -129,7 +130,7 @@ describe("buildAnnotatedEvalSource", () => {
 
   it("treats an empty source file as a single empty line", () => {
     const model = buildAnnotatedEvalSource({ path: SOURCE_PATH, content: "" }, []);
-    expect(model.lines).toEqual([{ line: 1, text: "", assertions: [] }]);
+    expect(model.lines).toEqual([{ line: 1, text: "", assertions: [], sends: [] }]);
   });
 
   it("sourceSha256 matches hashEvalSource(normalizeEvalSource(content)) and is stable across CRLF/LF", () => {
@@ -143,4 +144,56 @@ describe("buildAnnotatedEvalSource", () => {
     expect(modelLf.sourceSha256).toBe(modelCrlf.sourceSha256);
     expect(modelLf.lines.map((l) => l.text)).toEqual(modelCrlf.lines.map((l) => l.text));
   });
+
+  it("send 标注按 loc 落到对应行,一行多轮逐轮保留;别的文件或越界行直接丢(全量面在 --execution)", () => {
+    const content = "await t.send('a');\nawait t.send('b');\n";
+    const sends: SendAnnotation[] = [
+      { label: "s1/t1", status: "completed", durationMs: 1200, loc: { file: SOURCE_PATH, line: 1, column: 9 } },
+      { label: "s1/t2", status: "failed", durationMs: 800, loc: { file: SOURCE_PATH, line: 1, column: 9 } },
+      { label: "s1/t3", status: "completed", loc: { file: "evals/other.eval.ts", line: 1 } },
+      { label: "s1/t4", status: "completed", loc: { file: SOURCE_PATH, line: 99 } },
+    ];
+    const model = buildAnnotatedEvalSource({ path: SOURCE_PATH, content }, [], sends);
+    expect(model.lines[0]!.sends.map((s) => s.label)).toEqual(["s1/t1", "s1/t2"]);
+    expect(model.lines[1]!.sends).toEqual([]);
+  });
+});
+
+describe("deriveSendAnnotations", () => {
+  it("第 i 条用户消息配第 i 个 turn 节点(与 --execution 分轮同一规则);无 loc 的轮不产出", () => {
+    const events: StreamEvent[] = [
+      { type: "message", role: "user", text: "first", loc: { file: SOURCE_PATH, line: 3, column: 5 } },
+      { type: "message", role: "assistant", text: "reply" },
+      { type: "message", role: "user", text: "second (no loc)" },
+      { type: "message", role: "user", text: "third", loc: { file: SOURCE_PATH, line: 9, column: 5 } },
+    ];
+    const phases: PhaseTiming[] = [{
+      name: "eval.run" as PhaseTiming["name"],
+      durationMs: 5000,
+      children: [
+        { id: "n1", kind: "command", label: "git", startOffsetMs: 0, durationMs: 10 },
+        { id: "n2", kind: "turn", label: "s1/t1", startOffsetMs: 10, durationMs: 1500 },
+        { id: "n3", kind: "turn", label: "s1/t2", startOffsetMs: 1510, durationMs: 900, failed: true },
+        { id: "n4", kind: "turn", label: "s1/t3", startOffsetMs: 2410, durationMs: 300 },
+      ],
+    }];
+
+    const sends = deriveSendAnnotations(events, phases);
+    expect(sends).toEqual([
+      { label: "s1/t1", status: "completed", durationMs: 1500, loc: { file: SOURCE_PATH, line: 3, column: 5 } },
+      // 第二条用户消息没有 loc → 不产出;第三条配第 3 个 turn 节点,不因跳过而错位
+      { label: "s1/t3", status: "completed", durationMs: 300, loc: { file: SOURCE_PATH, line: 9, column: 5 } },
+    ]);
+  });
+
+  it("时间树缺 turn 节点时回退 t<i> 标签、无墙钟;没有事件时为空", () => {
+    const events: StreamEvent[] = [
+      { type: "message", role: "user", text: "only", loc: { file: SOURCE_PATH, line: 1 } },
+    ];
+    expect(deriveSendAnnotations(events, undefined)).toEqual([
+      { label: "t1", status: "completed", loc: { file: SOURCE_PATH, line: 1 } },
+    ]);
+    expect(deriveSendAnnotations(null, undefined)).toEqual([]);
+    expect(deriveSendAnnotations([], undefined)).toEqual([]);
+  });
 });