niceeval 0.6.0 → 0.6.2

package/dist/report/text/faces.js

@@ -4,9 +4,9 @@
 // 零 react、零 IO、纯同步 —— 这是 text 宿主不需要 react-dom 的那一半。
 // chrome 文案(注脚、verdict 词、截断提示)经 ctx.locale 查 locale 字典,
 // 默认 en 与历史输出逐字一致;数据(display、键、warnings message)不本地化。
-import { attemptItemReason, capabilityBadge, formatDurationMs, formatMetricValue, formatPlainNumber, formatUSD, verdictMark, } from "../format.js";
+import { attemptItemReason, experimentDisplayName, formatDurationMs, formatMetricValue, formatPlainNumber, formatUSD, verdictMark, } from "../format.js";
 import { countText, localeText, resolveMetricLabel } from "../locale.js";
-import { indentBlock, padDisplay, textBar, wrapDisplay } from "./layout.js";
+import { padDisplay, stringWidth, textBar, wrapDisplay } from "./layout.js";
 import { renderTableText } from "./table.js";
 import { renderCharPlot, renderCoordinateTable } from "./plot.js";
 const MISSING_MARK = "—";
@@ -290,10 +290,6 @@ export function scatterText(data, ctx) {
     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(drawable.map((r) => ({ key: r.key, x: r.x.display, y: r.y.display })), { key: data.points, x: axisLabel(data.x, locale), y: axisLabel(data.y, locale) });
@@ -400,45 +396,101 @@ export function deltaText(data, ctx) {
 }
 // ───────────────────────── 实体列表(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) {
-    return `${item.locator}${verdictMark(item.verdict)}${capabilityBadge(item.capabilities)}`;
+    return `${item.locator}${verdictMark(item.verdict)}`;
 }
 // ── ExperimentList ──
-function experimentListEvalLine(row) {
-    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 !== undefined)
-            .join(" · ")
-        : (row.reason ?? "");
-    return `  ${verdictMark(row.verdict)} ${row.evalId}   ${badges}   ${trailer}`;
+function experimentSummaryTable(items, ctx, relativeTo) {
+    const locale = ctx.locale;
+    const compact = ctx.width < 100;
+    const columns = [
+        { 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 = 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, ctx) {
+function experimentDetailTable(item, ctx, relativeTo) {
     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 = [
+        { 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 = item.evalRows.flatMap((row) => {
+        const parent = {
+            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 = 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, ctx, relativeTo) {
+    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) {
-    const reason = attemptItemReason(item);
+function evalListAttemptLine(item, ctx) {
+    // 行式列表同守「Result 最多两行」:预算 = 两行终端宽,超出由 fit 投影按优先级让位。
+    const reason = attemptItemReason(item, Math.max(24, ctx.width * 2 - stringWidth(locatorBadge(item)) - 6));
     return `  ${locatorBadge(item)}${reason ? ` · ${reason}` : ""}`;
 }
 export function evalListText(items, ctx) {
@@ -450,52 +502,39 @@ export function evalListText(items, ctx) {
         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");
 }
 // ── AttemptList ──
-/** 一个 AttemptListItem 的完整 text 卡片:判定符 + locator + 身份 + 耗时/成本 + 证据能力,
- * 然后逐条断言(gate 与 soft 都列,与 web 面的 AttemptRow 同一份材料)。 */
-function attemptListItemText(item, ctx, locale) {
+/** Attempt 比较卡片：只显示一条主失败摘要（至多两行终端宽）；完整 assertions 走 locator 下钻。 */
+function attemptListItemText(item, ctx) {
     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, total, ctx) {
     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 }));

package/dist/report/text/table.js

@@ -6,7 +6,7 @@
 // 列宽按显示宽度算(CJK 记 2 列);null 渲染 —,不补 0;超宽先折最宽的左对齐列,
 // 压到下限仍放不下就从右侧丢列并如实报数(「截断报剩余」是既有契约,不在这里破例)。
 import { countText, localeText } from "../locale.js";
-import { renderAlignedRows, stringWidth, wrapDisplay } from "./layout.js";
+import { charDisplayWidth, renderAlignedRows, stringWidth, wrapDisplay } from "./layout.js";
 const MISSING_MARK = "—";
 /** 列间距,与 renderAlignedRows 的 join("   ") 一致。 */
 const COLUMN_GAP = 3;
@@ -47,12 +47,36 @@ function fitWidths(natural, align, available) {
     }
     return { widths, hidden };
 }
-/** 逻辑行 → 物理行:每格折到自己的列宽,行高取最高的那格,矮格补空串。 */
-function toPhysicalRows(cells, widths) {
+/** 按显示宽度截到 width(不够放 `…` 时原样返回)。 */
+function truncateDisplay(text, width) {
+    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, maxLines, width) {
+    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, widths, maxLines) {
     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 = [];
     for (let i = 0; i < height; i++)
@@ -80,7 +104,14 @@ export function renderTableText(props, ctx) {
     const matrix = [header, ...body];
     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 = 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/dist/report/types.d.ts

@@ -1,10 +1,9 @@
 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 };
 /** 两级聚合里单级的折叠方式。 */
 export type Aggregator = "mean" | "sum" | "min" | "max" | ((values: number[]) => number);
@@ -22,7 +21,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 与列头的来源;同一次计算里重名是错误。 */
@@ -68,8 +67,22 @@ export interface FlagRef {
     readonly label?: string | ((value: string | number | boolean) => string);
     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;
 export interface MetricColumn {
     /** = metric.name,与 cells 的键对应。 */
     key: string;
@@ -259,7 +272,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;
@@ -287,10 +300,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;
@@ -325,10 +339,11 @@ export interface DeltaData<K extends string = string> {
     }[];
 }
 /**
- * `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;
@@ -336,32 +351,24 @@ 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 的平均成本。 */
@@ -372,7 +379,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 {
@@ -387,7 +394,7 @@ export interface ExperimentListItem {
         errored: number;
         skipped: number;
     };
-    /** 官方两级聚合口径,与 `MetricTable.data(..., columns: [passRate])` 同一台引擎。 */
+    /** 官方两级聚合口径(endToEndPassRate),与 `MetricTable.data(..., columns: [endToEndPassRate])` 同一台引擎。 */
     passRate: MetricCell;
     cost: MetricCell;
     duration: MetricCell;
@@ -404,14 +411,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/dist/results/types.d.ts

@@ -33,6 +33,13 @@ export interface SnapshotMeta {
     completedAt?: string;
     /** 写入时刻该实验已知的 eval 并集 —— 残缺检测的分母随数据走(copySnapshots 自动补记,writer 可声明)。 */
     knownEvalIds?: string[];
+    /**
+     * 发布拷贝的自描述标记:copySnapshots 补记,消毒函数 → "applied"、redact: false → "none";
+     * 本地事实根没有此字段。只声明流程,不证明无秘密;view --out 据此分级防呆。
+     */
+    publish?: {
+        redaction: "applied" | "none";
+    };
     /** 项目名(来自 config.name),透传给 `niceeval view` 顶部 hero 显示。 */
     name?: LocalizedText;
 }
@@ -110,6 +117,10 @@ export interface Snapshot {
     dir: string;
     /** 写入时刻该实验已知的 eval 并集(可选);copySnapshots 自动补记,writer.snapshot() 也可声明。 */
     knownEvalIds?: string[];
+    /** 发布拷贝的自描述标记(见 SnapshotMeta.publish);本地事实根没有此字段。 */
+    publish?: {
+        redaction: "applied" | "none";
+    };
 }
 /** 一个实验的全部历史:同一 experiment id 的历次快照归在一起。 */
 export interface Experiment {

package/dist/runner/feedback/sink.d.ts

@@ -0,0 +1,110 @@
+import type { AttemptLifecycleEvent, AttemptRef, FailureDetail } from "../types.ts";
+import type { Verdict } from "../../scoring/types.ts";
+import type { JsonValue } from "../../shared/types.ts";
+import type { AttemptLocator } from "../../results/locator.ts";
+/** `sink.diagnostic()` 的输入 —— 与 `DurableFeedbackEvent` 的 "diagnostic" 变体字段一致,
+ *  只是省略 `type`/`at`(由 coordinator 补上)。 */
+export interface DiagnosticInput {
+    /** 稳定去重 key —— 同一种 warning/error 用同一个 key(见 cli.md「同一 dedupeKey 并发出现时
+     *  只留一条并显示次数」),不要把可变的实例细节(如具体 sandbox id)编进 key 本身,
+     *  那些细节放 `data`。 */
+    key: string;
+    severity: "warning" | "error";
+    /** 一句话人类可读摘要;renderer 的 appendDurable 直接展示,不需要再解析。 */
+    message: string;
+    identity?: AttemptRef;
+    data?: Readonly<Record<string, JsonValue>>;
+}
+/** `sink.failure()` 的输入 —— 与 `DurableFeedbackEvent` 的 "failure" 变体字段一致,只省略
+ *  `type`/`at`(由 coordinator 补上)。`locator` 只有在 attempt 挂靠 experiment 时才存在
+ *  (见 `results/locator.ts` 的 `encodeAttemptLocator`);调用方(run.ts)只在拿到 locator 之后
+ *  才应该调用这个函数——没有 locator 的裸 run 不产出这类永久失败通知。 */
+export type FailureInput = FailureDetail;
+/** `sink.budgetExhausted()` 的输入 —— 与 `DurableFeedbackEvent` 的 "budget-exhausted" 变体字段
+ *  一致,只省略 `type`/`at`。调用方(run.ts)对每一个因预算到顶而不派发的 attempt 各调一次
+ *  (与 `AttemptLifecycleEvent` 的 "attempt:early-exit" 同构);`unstarted` 是调用方自己维护的、
+ *  发出这条时的累计未派发数,不是 reducer 能推导的值(见 reducer.ts 对应事件的注释)。 */
+export interface BudgetExhaustedInput {
+    experimentId: string;
+    spent: number;
+    unstarted: number;
+}
+/** `sink.kept()` 的输入 —— 与 `DurableFeedbackEvent` 的 "kept" 变体字段一致,省略 type/at。 */
+export interface KeptInput {
+    locator: AttemptLocator;
+    identity: AttemptRef;
+    who: string;
+    verdict: Verdict;
+    provider: string;
+    sandboxId: string;
+    enter?: string;
+}
+/** `sink.ts` façade 函数实际转发到的最小接口 —— `FeedbackCoordinator`(coordinator.ts)实现它。
+ *  定义在这里(而不是从 coordinator.ts 导入)是为了让 sink.ts 不必在运行时依赖 coordinator.ts,
+ *  避免两个模块互相 import 造成的循环依赖 —— coordinator.ts 反过来 `import type` 这个接口。 */
+export interface FeedbackSink {
+    activity(text: string): void;
+    diagnostic(input: DiagnosticInput): void;
+    interrupted(): void;
+    reporterError(input: {
+        reporter: string;
+        required: boolean;
+        message: string;
+    }): void;
+    /** 一次失败/errored attempt 的永久通知(见 `FailureInput`)。 */
+    failure(input: FailureInput): void;
+    /** 一个因预算到顶而未被派发的 attempt(见 `BudgetExhaustedInput`)。 */
+    budgetExhausted(input: BudgetExhaustedInput): void;
+    /** 一次留存授予(--keep-sandbox);见 `KeptInput` 与 docs/feature/sandbox/cli.md。 */
+    kept(input: KeptInput): void;
+    /** attempt 生命周期事件(queued/start/phase/progress/complete/early-exit),见
+     *  `AttemptLifecycleEvent`。只驱动 human dashboard 的 active slot,不落 RunSummary/结果文件,
+     *  所以没有活跃 coordinator 时(见 `reportAttemptLifecycle`)静默丢弃是安全的 —— 这类信息
+     *  本身就只服务「正在画着的 dashboard」,不是必须留痕的诊断。 */
+    lifecycle(event: AttemptLifecycleEvent): void;
+}
+/**
+ * coordinator 进入「活跃」阶段时调用一次(见 coordinator.ts 的 start()),把自己注册为当前
+ * reportXxx() 调用的目的地。返回的函数用于退出活跃状态(见 coordinator.ts 的 finish())——
+ * 调用一次即失效,重复调用是安全的 no-op。
+ */
+export declare function activateFeedbackSink(sink: FeedbackSink): () => void;
+/** 仅供测试:断言没有遗留未退出的活跃 coordinator(避免一个测试忘记 finish() 污染下一个)。 */
+export declare function activeFeedbackSinkCount(): number;
+/** 不需要去重、不进入 RunFeedbackState 的瞬时活动文本(docker 镜像拉取进度、vercel session
+ *  rotate 成功通知……)。没有活跃 coordinator 时退回一行 stderr,与迁移前的裸写视觉效果一致。 */
+export declare function reportActivity(text: string): void;
+/** 需要去重、要出现在三种 profile 永久事件流里的一条 warning/error。 */
+export declare function reportDiagnostic(input: DiagnosticInput): void;
+/** 一次失败/errored attempt 的永久通知(见 `FailureInput`)。与 `reportDiagnostic` 同级别的
+ *  「必须留痕」信号 —— 没有活跃 coordinator 时退回一行 stderr,不像 `reportAttemptLifecycle`
+ *  那样静默丢弃(定位一次真实失败不该因为没接 coordinator 就彻底没有出口)。 */
+export declare function reportFailure(input: FailureInput): void;
+/** 一个因预算到顶而未被派发的 attempt(见 `BudgetExhaustedInput`)。没有活跃 coordinator 时的
+ *  兜底文案与 coordinator.ts 的 `fallbackTextFor` 对 "budget-exhausted" 事件的格式化保持一致。 */
+/** 一次留存授予的永久通知(--keep-sandbox);没有活跃 coordinator 时退回一行 stderr。 */
+export declare function reportKept(input: KeptInput): void;
+export declare function reportBudgetExhausted(input: BudgetExhaustedInput): void;
+/** 用户中断(Ctrl+C)。没有活跃 coordinator 时的兜底文案与迁移前的 `runner.interrupted` 完全
+ *  相同 —— 调用方(run.ts)不再需要自己持有这段 i18n 文案。 */
+export declare function reportInterrupted(): void;
+/**
+ * runner 自己驱动的 attempt 生命周期投影(见 docs/feature/experiments/cli.md「Attempt 阶段」)——
+ * `src/runner/attempt.ts`(phase/progress)与 `src/runner/run.ts`(start/complete/early-exit)是
+ * 目前仅有的两个调用方。没有活跃 coordinator 时(今天:CLI 还没接入 --output)静默 no-op ——
+ * 与其它 reportXxx() 不同,这里不退回 `writeStderrLine` 兜底:这类事件只服务尚不存在的
+ * dashboard,不是需要留痕的诊断,现有可观察行为(直到 CLI 接入真正的 coordinator 之前)因此
+ * 完全不变。
+ */
+export declare function reportAttemptLifecycle(event: AttemptLifecycleEvent): void;
+/** 一个 reporter 的某次回调抛错(见 `runner/report.ts` 的 `runReporter`)。`reporter`/`required`
+ *  来自调用方注册这个 reporter 时的 `ReporterRegistration`(见其字段注释)——默认 artifacts、
+ *  显式 `--json`/`--junit` 传 `required: true`,用户 `config.reporters`/`EvalDef.reporters`
+ *  传 `required: false`。coordinator 把它折进 `RunFeedbackState.diagnostics`(reducer 按
+ *  `reporter-error:<reporter>` 去重),调用方(`cli.ts` 的 `assembleRunCompletion`)据此把
+ *  `required` 为真的失败折进 `RunCompletion.reporterErrors`,让 completion/CI 退出码判红。 */
+export declare function reportReporterError(input: {
+    reporter: string;
+    required: boolean;
+    message: string;
+}): void;